Fossil SCM

Update the built-in SQLite to version 3.7.0rc2.

drh 2010-07-21 16:33 trunk

Commit 93d7f371cc94693e0552393ae0df5c356c66a368

Parent e3653248ae4d74f…

2 files changed +1821 -1501 +17 -10

M src/sqlite3.c

+1821 -1501

		--- src/sqlite3.c
		+++ src/sqlite3.c
		@@ -514,11 +514,11 @@
514	514	/*
515	515	** Return true (non-zero) if the input is a integer that is too large
516	516	** to fit in 32-bits. This macro is used inside of various testcase()
517	517	** macros to verify that we have tested SQLite for large-file support.
518	518	*/
519		-#define IS_BIG_INT(X) (((X)&(i64)0xffffffff)!=0)
	519	+#define IS_BIG_INT(X) (((X)&~(i64)0xffffffff)!=0)
520	520
521	521	/*
522	522	** The macro unlikely() is a hint that surrounds a boolean
523	523	** expression that is usually false. Macro likely() surrounds
524	524	** a boolean expression that is usually true. GCC is able to
		@@ -643,11 +643,11 @@
643	643	** [sqlite3_libversion_number()], [sqlite3_sourceid()],
644	644	** [sqlite_version()] and [sqlite_source_id()].
645	645	*/
646	646	#define SQLITE_VERSION "3.7.0"
647	647	#define SQLITE_VERSION_NUMBER 3007000
648		-#define SQLITE_SOURCE_ID "2010-07-08 17:40:38 e396184cd3bdb96e29ac33af5d1f631cac553341"
	648	+#define SQLITE_SOURCE_ID "2010-07-21 16:16:28 b36b105eab6fd3195f4bfba6cb5cda0f063b7460"
649	649
650	650	/*
651	651	** CAPI3REF: Run-Time Library Version Numbers
652	652	** KEYWORDS: sqlite3_version, sqlite3_sourceid
653	653	**
		@@ -1015,15 +1015,16 @@
1015	1015	#define SQLITE_OPEN_MASTER_JOURNAL 0x00004000 /* VFS only */
1016	1016	#define SQLITE_OPEN_NOMUTEX 0x00008000 /* Ok for sqlite3_open_v2() */
1017	1017	#define SQLITE_OPEN_FULLMUTEX 0x00010000 /* Ok for sqlite3_open_v2() */
1018	1018	#define SQLITE_OPEN_SHAREDCACHE 0x00020000 /* Ok for sqlite3_open_v2() */
1019	1019	#define SQLITE_OPEN_PRIVATECACHE 0x00040000 /* Ok for sqlite3_open_v2() */
	1020	+#define SQLITE_OPEN_WAL 0x00080000 /* VFS only */
1020	1021
1021	1022	/*
1022	1023	** CAPI3REF: Device Characteristics
1023	1024	**
1024		-** The xDeviceCapabilities method of the [sqlite3_io_methods]
	1025	+** The xDeviceCharacteristics method of the [sqlite3_io_methods]
1025	1026	** object returns an integer which is a vector of the these
1026	1027	** bit values expressing I/O characteristics of the mass storage
1027	1028	** device that holds the file that the [sqlite3_io_methods]
1028	1029	** refers to.
1029	1030	**
		@@ -1199,15 +1200,14 @@
1199	1200	int (xCheckReservedLock)(sqlite3_file, int *pResOut);
1200	1201	int (xFileControl)(sqlite3_file, int op, void *pArg);
1201	1202	int (xSectorSize)(sqlite3_file);
1202	1203	int (xDeviceCharacteristics)(sqlite3_file);
1203	1204	/* Methods above are valid for version 1 */
1204		- int (xShmOpen)(sqlite3_file);
	1205	+ int (xShmMap)(sqlite3_file, int iPg, int pgsz, int, void volatile**);
1205	1206	int (xShmLock)(sqlite3_file, int offset, int n, int flags);
1206		- int (xShmMap)(sqlite3_file, int iPage, int pgsz, int, void volatile**);
1207	1207	void (xShmBarrier)(sqlite3_file);
1208		- int (xShmClose)(sqlite3_file, int deleteFlag);
	1208	+ int (xShmUnmap)(sqlite3_file, int deleteFlag);
1209	1209	/* Methods above are valid for version 2 */
1210	1210	/* Additional methods may be added in future releases */
1211	1211	};
1212	1212
1213	1213	/*
		@@ -1426,17 +1426,24 @@
1426	1426	** the xAccess method of an [sqlite3_vfs] object. They determine
1427	1427	** what kind of permissions the xAccess method is looking for.
1428	1428	** With SQLITE_ACCESS_EXISTS, the xAccess method
1429	1429	** simply checks whether the file exists.
1430	1430	** With SQLITE_ACCESS_READWRITE, the xAccess method
1431		-** checks whether the file is both readable and writable.
	1431	+** checks whether the named directory is both readable and writable
	1432	+** (in other words, if files can be added, removed, and renamed within
	1433	+** the directory).
	1434	+** The SQLITE_ACCESS_READWRITE constant is currently used only by the
	1435	+** [temp_store_directory pragma], though this could change in a future
	1436	+** release of SQLite.
1432	1437	** With SQLITE_ACCESS_READ, the xAccess method
1433		-** checks whether the file is readable.
	1438	+** checks whether the file is readable. The SQLITE_ACCESS_READ constant is
	1439	+** currently unused, though it might be used in a future release of
	1440	+** SQLite.
1434	1441	*/
1435	1442	#define SQLITE_ACCESS_EXISTS 0
1436		-#define SQLITE_ACCESS_READWRITE 1
1437		-#define SQLITE_ACCESS_READ 2
	1443	+#define SQLITE_ACCESS_READWRITE 1 /* Used by PRAGMA temp_store_directory */
	1444	+#define SQLITE_ACCESS_READ 2 /* Unused */
1438	1445
1439	1446	/*
1440	1447	** CAPI3REF: Flags for the xShmLock VFS method
1441	1448	**
1442	1449	** These integer constants define the various locking operations
		@@ -5767,11 +5774,11 @@
5767	5774	**
5768	5775	** <dt>SQLITE_DBSTATUS_CACHE_USED</dt>
5769	5776	** <dd>^This parameter returns the approximate number of of bytes of heap
5770	5777	** memory used by all pager caches associated with the database connection.
5771	5778	** ^The highwater mark associated with SQLITE_DBSTATUS_CACHE_USED is always 0.
5772		-** checked out.</dd>)^
	5779	+** </dd>
5773	5780	** </dl>
5774	5781	*/
5775	5782	#define SQLITE_DBSTATUS_LOOKASIDE_USED 0
5776	5783	#define SQLITE_DBSTATUS_CACHE_USED 1
5777	5784	#define SQLITE_DBSTATUS_MAX 1 /* Largest defined DBSTATUS */
		@@ -8307,15 +8314,14 @@
8307	8314	SQLITE_PRIVATE int sqlite3OsCheckReservedLock(sqlite3_file id, int pResOut);
8308	8315	SQLITE_PRIVATE int sqlite3OsFileControl(sqlite3_file,int,void);
8309	8316	#define SQLITE_FCNTL_DB_UNCHANGED 0xca093fa0
8310	8317	SQLITE_PRIVATE int sqlite3OsSectorSize(sqlite3_file *id);
8311	8318	SQLITE_PRIVATE int sqlite3OsDeviceCharacteristics(sqlite3_file *id);
8312		-SQLITE_PRIVATE int sqlite3OsShmOpen(sqlite3_file *id);
	8319	+SQLITE_PRIVATE int sqlite3OsShmMap(sqlite3_file ,int,int,int,void volatile *);
8313	8320	SQLITE_PRIVATE int sqlite3OsShmLock(sqlite3_file *id, int, int, int);
8314	8321	SQLITE_PRIVATE void sqlite3OsShmBarrier(sqlite3_file *id);
8315		-SQLITE_PRIVATE int sqlite3OsShmClose(sqlite3_file *id, int);
8316		-SQLITE_PRIVATE int sqlite3OsShmMap(sqlite3_file ,int,int,int,void volatile *);
	8322	+SQLITE_PRIVATE int sqlite3OsShmUnmap(sqlite3_file *id, int);
8317	8323
8318	8324	/*
8319	8325	** Functions for accessing sqlite3_vfs methods
8320	8326	*/
8321	8327	SQLITE_PRIVATE int sqlite3OsOpen(sqlite3_vfs , const char , sqlite3_file, int, int );
		@@ -10665,10 +10671,11 @@
10665	10671	SQLITE_PRIVATE void sqlite3ValueApplyAffinity(sqlite3_value *, u8, u8);
10666	10672	#ifndef SQLITE_AMALGAMATION
10667	10673	SQLITE_PRIVATE const unsigned char sqlite3OpcodeProperty[];
10668	10674	SQLITE_PRIVATE const unsigned char sqlite3UpperToLower[];
10669	10675	SQLITE_PRIVATE const unsigned char sqlite3CtypeMap[];
	10676	+SQLITE_PRIVATE const Token sqlite3IntTokens[];
10670	10677	SQLITE_PRIVATE SQLITE_WSD struct Sqlite3Config sqlite3Config;
10671	10678	SQLITE_PRIVATE SQLITE_WSD FuncDefHash sqlite3GlobalFunctions;
10672	10679	#ifndef SQLITE_OMIT_WSD
10673	10680	SQLITE_PRIVATE int sqlite3PendingByte;
10674	10681	#endif
		@@ -11110,10 +11117,19 @@
11110	11117	** Hash table for global functions - functions common to all
11111	11118	** database connections. After initialization, this table is
11112	11119	** read-only.
11113	11120	*/
11114	11121	SQLITE_PRIVATE SQLITE_WSD FuncDefHash sqlite3GlobalFunctions;
	11122	+
	11123	+/*
	11124	+** Constant tokens for values 0 and 1.
	11125	+*/
	11126	+SQLITE_PRIVATE const Token sqlite3IntTokens[] = {
	11127	+ { "0", 1 },
	11128	+ { "1", 1 }
	11129	+};
	11130	+
11115	11131
11116	11132	/*
11117	11133	** The value of the "pending" byte must be 0x40000000 (1 byte past the
11118	11134	** 1-gibabyte boundary) in a compatible database. SQLite never uses
11119	11135	** the database page that contains the pending byte. It never attempts
		@@ -12875,30 +12891,27 @@
12875	12891	return (xSectorSize ? xSectorSize(id) : SQLITE_DEFAULT_SECTOR_SIZE);
12876	12892	}
12877	12893	SQLITE_PRIVATE int sqlite3OsDeviceCharacteristics(sqlite3_file *id){
12878	12894	return id->pMethods->xDeviceCharacteristics(id);
12879	12895	}
12880		-SQLITE_PRIVATE int sqlite3OsShmOpen(sqlite3_file *id){
12881		- return id->pMethods->xShmOpen(id);
12882		-}
12883	12896	SQLITE_PRIVATE int sqlite3OsShmLock(sqlite3_file *id, int offset, int n, int flags){
12884	12897	return id->pMethods->xShmLock(id, offset, n, flags);
12885	12898	}
12886	12899	SQLITE_PRIVATE void sqlite3OsShmBarrier(sqlite3_file *id){
12887	12900	id->pMethods->xShmBarrier(id);
12888	12901	}
12889		-SQLITE_PRIVATE int sqlite3OsShmClose(sqlite3_file *id, int deleteFlag){
12890		- return id->pMethods->xShmClose(id, deleteFlag);
	12902	+SQLITE_PRIVATE int sqlite3OsShmUnmap(sqlite3_file *id, int deleteFlag){
	12903	+ return id->pMethods->xShmUnmap(id, deleteFlag);
12891	12904	}
12892	12905	SQLITE_PRIVATE int sqlite3OsShmMap(
12893		- sqlite3_file *id,
12894		- int iPage,
12895		- int pgsz,
12896		- int isWrite,
12897		- void volatile **pp
	12906	+ sqlite3_file id, / Database file handle */
	12907	+ int iPage,
	12908	+ int pgsz,
	12909	+ int bExtend, /* True to extend file if necessary */
	12910	+ void volatile *pp / OUT: Pointer to mapping */
12898	12911	){
12899		- return id->pMethods->xShmMap(id, iPage, pgsz, isWrite, pp);
	12912	+ return id->pMethods->xShmMap(id, iPage, pgsz, bExtend, pp);
12900	12913	}
12901	12914
12902	12915	/*
12903	12916	** The next group of routines are convenience wrappers around the
12904	12917	** VFS methods.
		@@ -12910,15 +12923,15 @@
12910	12923	int flags,
12911	12924	int *pFlagsOut
12912	12925	){
12913	12926	int rc;
12914	12927	DO_OS_MALLOC_TEST(0);
12915		- /* 0x7f3f is a mask of SQLITE_OPEN_ flags that are valid to be passed
	12928	+ /* 0x87f3f is a mask of SQLITE_OPEN_ flags that are valid to be passed
12916	12929	** down into the VFS layer. Some SQLITE_OPEN_ flags (for example,
12917	12930	** SQLITE_OPEN_FULLMUTEX or SQLITE_OPEN_SHAREDCACHE) are blocked before
12918	12931	** reaching the VFS. */
12919		- rc = pVfs->xOpen(pVfs, zPath, pFile, flags & 0x7f3f, pFlagsOut);
	12932	+ rc = pVfs->xOpen(pVfs, zPath, pFile, flags & 0x87f3f, pFlagsOut);
12920	12933	assert( rc==SQLITE_OK \|\| pFile->pMethods==0 );
12921	12934	return rc;
12922	12935	}
12923	12936	SQLITE_PRIVATE int sqlite3OsDelete(sqlite3_vfs pVfs, const char zPath, int dirSync){
12924	12937	return pVfs->xDelete(pVfs, zPath, dirSync);
		@@ -25708,74 +25721,100 @@
25708	25721	sqlite3_free(p);
25709	25722	}
25710	25723	}
25711	25724
25712	25725	/*
25713		-** Open a shared-memory area associated with open database file fd.
	25726	+** Open a shared-memory area associated with open database file pDbFd.
25714	25727	** This particular implementation uses mmapped files.
25715	25728	**
25716	25729	** The file used to implement shared-memory is in the same directory
25717	25730	** as the open database file and has the same name as the open database
25718	25731	** file with the "-shm" suffix added. For example, if the database file
25719	25732	** is "/home/user1/config.db" then the file that is created and mmapped
25720		-** for shared memory will be called "/home/user1/config.db-shm". We
25721		-** experimented with using files in /dev/tmp or an some other tmpfs mount.
25722		-** But if a file in a different directory from the database file is used,
25723		-** then differing access permissions or a chroot() might cause two different
25724		-** processes on the same database to end up using different files for
25725		-** shared memory - meaning that their memory would not really be shared -
25726		-** resulting in database corruption.
	25733	+** for shared memory will be called "/home/user1/config.db-shm".
	25734	+**
	25735	+** Another approach to is to use files in /dev/shm or /dev/tmp or an
	25736	+** some other tmpfs mount. But if a file in a different directory
	25737	+** from the database file is used, then differing access permissions
	25738	+** or a chroot() might cause two different processes on the same
	25739	+** database to end up using different files for shared memory -
	25740	+** meaning that their memory would not really be shared - resulting
	25741	+** in database corruption. Nevertheless, this tmpfs file usage
	25742	+** can be enabled at compile-time using -DSQLITE_SHM_DIRECTORY="/dev/shm"
	25743	+** or the equivalent. The use of the SQLITE_SHM_DIRECTORY compile-time
	25744	+** option results in an incompatible build of SQLite; builds of SQLite
	25745	+** that with differing SQLITE_SHM_DIRECTORY settings attempt to use the
	25746	+** same database file at the same time, database corruption will likely
	25747	+** result. The SQLITE_SHM_DIRECTORY compile-time option is considered
	25748	+** "unsupported" and may go away in a future SQLite release.
25727	25749	**
25728	25750	** When opening a new shared-memory file, if no other instances of that
25729	25751	** file are currently open, in this process or in other processes, then
25730	25752	** the file must be truncated to zero length or have its header cleared.
25731	25753	*/
25732		-static int unixShmOpen(
25733		- sqlite3_file fd / The file descriptor of the associated database */
25734		-){
25735		- struct unixShm p = 0; / The connection to be opened */
25736		- struct unixShmNode pShmNode = 0; / The underlying mmapped file */
25737		- int rc; /* Result code */
25738		- struct unixFile pDbFd; / Underlying database file */
25739		- unixInodeInfo pInode; / The inode of fd */
25740		- char zShmFilename; / Name of the file used for SHM */
25741		- int nShmFilename; /* Size of the SHM filename in bytes */
25742		-
25743		- /* Allocate space for the new sqlite3_shm object.
25744		- */
	25754	+static int unixOpenSharedMemory(unixFile *pDbFd){
	25755	+ struct unixShm p = 0; / The connection to be opened */
	25756	+ struct unixShmNode pShmNode; / The underlying mmapped file */
	25757	+ int rc; /* Result code */
	25758	+ unixInodeInfo pInode; / The inode of fd */
	25759	+ char zShmFilename; / Name of the file used for SHM */
	25760	+ int nShmFilename; /* Size of the SHM filename in bytes */
	25761	+
	25762	+ /* Allocate space for the new unixShm object. */
25745	25763	p = sqlite3_malloc( sizeof(*p) );
25746	25764	if( p==0 ) return SQLITE_NOMEM;
25747	25765	memset(p, 0, sizeof(*p));
25748		- pDbFd = (struct unixFile*)fd;
25749	25766	assert( pDbFd->pShm==0 );
25750	25767
25751		- /* Check to see if a unixShmNode object already exists. Reuse an existing
25752		- ** one if present. Create a new one if necessary.
	25768	+ /* Check to see if a unixShmNode object already exists. Reuse an existing
	25769	+ ** one if present. Create a new one if necessary.
25753	25770	*/
25754	25771	unixEnterMutex();
25755	25772	pInode = pDbFd->pInode;
25756	25773	pShmNode = pInode->pShmNode;
25757	25774	if( pShmNode==0 ){
	25775	+ struct stat sStat; /* fstat() info for database file */
	25776	+
	25777	+ /* Call fstat() to figure out the permissions on the database file. If
	25778	+ ** a new *-shm file is created, an attempt will be made to create it
	25779	+ ** with the same permissions. The actual permissions the file is created
	25780	+ ** with are subject to the current umask setting.
	25781	+ */
	25782	+ if( fstat(pDbFd->h, &sStat) ){
	25783	+ rc = SQLITE_IOERR_FSTAT;
	25784	+ goto shm_open_err;
	25785	+ }
	25786	+
	25787	+#ifdef SQLITE_SHM_DIRECTORY
	25788	+ nShmFilename = sizeof(SQLITE_SHM_DIRECTORY) + 30;
	25789	+#else
25758	25790	nShmFilename = 5 + (int)strlen(pDbFd->zPath);
	25791	+#endif
25759	25792	pShmNode = sqlite3_malloc( sizeof(*pShmNode) + nShmFilename );
25760	25793	if( pShmNode==0 ){
25761	25794	rc = SQLITE_NOMEM;
25762	25795	goto shm_open_err;
25763	25796	}
25764	25797	memset(pShmNode, 0, sizeof(*pShmNode));
25765	25798	zShmFilename = pShmNode->zFilename = (char*)&pShmNode[1];
	25799	+#ifdef SQLITE_SHM_DIRECTORY
	25800	+ sqlite3_snprintf(nShmFilename, zShmFilename,
	25801	+ SQLITE_SHM_DIRECTORY "/sqlite-shm-%x-%x",
	25802	+ (u32)sStat.st_ino, (u32)sStat.st_dev);
	25803	+#else
25766	25804	sqlite3_snprintf(nShmFilename, zShmFilename, "%s-shm", pDbFd->zPath);
	25805	+#endif
25767	25806	pShmNode->h = -1;
25768	25807	pDbFd->pInode->pShmNode = pShmNode;
25769	25808	pShmNode->pInode = pDbFd->pInode;
25770	25809	pShmNode->mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST);
25771	25810	if( pShmNode->mutex==0 ){
25772	25811	rc = SQLITE_NOMEM;
25773	25812	goto shm_open_err;
25774	25813	}
25775	25814
25776		- pShmNode->h = open(zShmFilename, O_RDWR\|O_CREAT, 0664);
	25815	+ pShmNode->h = open(zShmFilename, O_RDWR\|O_CREAT, (sStat.st_mode & 0777));
25777	25816	if( pShmNode->h<0 ){
25778	25817	rc = SQLITE_CANTOPEN_BKPT;
25779	25818	goto shm_open_err;
25780	25819	}
25781	25820
		@@ -25794,18 +25833,28 @@
25794	25833	if( rc ) goto shm_open_err;
25795	25834	}
25796	25835
25797	25836	/* Make the new connection a child of the unixShmNode */
25798	25837	p->pShmNode = pShmNode;
25799		- p->pNext = pShmNode->pFirst;
25800	25838	#ifdef SQLITE_DEBUG
25801	25839	p->id = pShmNode->nextShmId++;
25802	25840	#endif
25803		- pShmNode->pFirst = p;
25804	25841	pShmNode->nRef++;
25805	25842	pDbFd->pShm = p;
25806	25843	unixLeaveMutex();
	25844	+
	25845	+ /* The reference count on pShmNode has already been incremented under
	25846	+ ** the cover of the unixEnterMutex() mutex and the pointer from the
	25847	+ ** new (struct unixShm) object to the pShmNode has been set. All that is
	25848	+ ** left to do is to link the new object into the linked list starting
	25849	+ ** at pShmNode->pFirst. This must be done while holding the pShmNode->mutex
	25850	+ ** mutex.
	25851	+ */
	25852	+ sqlite3_mutex_enter(pShmNode->mutex);
	25853	+ p->pNext = pShmNode->pFirst;
	25854	+ pShmNode->pFirst = p;
	25855	+ sqlite3_mutex_leave(pShmNode->mutex);
25807	25856	return SQLITE_OK;
25808	25857
25809	25858	/* Jump here on any error */
25810	25859	shm_open_err:
25811	25860	unixShmPurge(pDbFd); /* This call frees pShmNode if required */
		@@ -25813,53 +25862,111 @@
25813	25862	unixLeaveMutex();
25814	25863	return rc;
25815	25864	}
25816	25865
25817	25866	/*
25818		-** Close a connection to shared-memory. Delete the underlying
25819		-** storage if deleteFlag is true.
	25867	+** This function is called to obtain a pointer to region iRegion of the
	25868	+** shared-memory associated with the database file fd. Shared-memory regions
	25869	+** are numbered starting from zero. Each shared-memory region is szRegion
	25870	+** bytes in size.
	25871	+**
	25872	+** If an error occurs, an error code is returned and *pp is set to NULL.
	25873	+**
	25874	+** Otherwise, if the bExtend parameter is 0 and the requested shared-memory
	25875	+** region has not been allocated (by any client, including one running in a
	25876	+** separate process), then *pp is set to NULL and SQLITE_OK returned. If
	25877	+** bExtend is non-zero and the requested shared-memory region has not yet
	25878	+** been allocated, it is allocated by this function.
	25879	+**
	25880	+** If the shared-memory region has already been allocated or is allocated by
	25881	+** this call as described above, then it is mapped into this processes
	25882	+** address space (if it is not already), *pp is set to point to the mapped
	25883	+** memory and SQLITE_OK returned.
25820	25884	*/
25821		-static int unixShmClose(
25822		- sqlite3_file fd, / The underlying database file */
25823		- int deleteFlag /* Delete shared-memory if true */
	25885	+static int unixShmMap(
	25886	+ sqlite3_file fd, / Handle open on database file */
	25887	+ int iRegion, /* Region to retrieve */
	25888	+ int szRegion, /* Size of regions */
	25889	+ int bExtend, /* True to extend file if necessary */
	25890	+ void volatile *pp / OUT: Mapped memory */
25824	25891	){
25825		- unixShm p; / The connection to be closed */
25826		- unixShmNode pShmNode; / The underlying shared-memory file */
25827		- unixShm *pp; / For looping over sibling connections */
25828		- unixFile pDbFd; / The underlying database file */
25829		-
25830		- pDbFd = (unixFile*)fd;
25831		- p = pDbFd->pShm;
25832		- if( p==0 ) return SQLITE_OK;
	25892	+ unixFile pDbFd = (unixFile)fd;
	25893	+ unixShm *p;
	25894	+ unixShmNode *pShmNode;
	25895	+ int rc = SQLITE_OK;
	25896	+
	25897	+ /* If the shared-memory file has not yet been opened, open it now. */
	25898	+ if( pDbFd->pShm==0 ){
	25899	+ rc = unixOpenSharedMemory(pDbFd);
	25900	+ if( rc!=SQLITE_OK ) return rc;
	25901	+ }
	25902	+
	25903	+ p = pDbFd->pShm;
25833	25904	pShmNode = p->pShmNode;
25834		-
25835		- assert( pShmNode==pDbFd->pInode->pShmNode );
25836		- assert( pShmNode->pInode==pDbFd->pInode );
25837		-
25838		- /* Remove connection p from the set of connections associated
25839		- ** with pShmNode */
25840	25905	sqlite3_mutex_enter(pShmNode->mutex);
25841		- for(pp=&pShmNode->pFirst; (pp)!=p; pp = &(pp)->pNext){}
25842		- *pp = p->pNext;
	25906	+ assert( szRegion==pShmNode->szRegion \|\| pShmNode->nRegion==0 );
25843	25907
25844		- /* Free the connection p */
25845		- sqlite3_free(p);
25846		- pDbFd->pShm = 0;
	25908	+ if( pShmNode->nRegion<=iRegion ){
	25909	+ char *apNew; / New apRegion[] array */
	25910	+ int nByte = (iRegion+1)szRegion; / Minimum required file size */
	25911	+ struct stat sStat; /* Used by fstat() */
	25912	+
	25913	+ pShmNode->szRegion = szRegion;
	25914	+
	25915	+ /* The requested region is not mapped into this processes address space.
	25916	+ ** Check to see if it has been allocated (i.e. if the wal-index file is
	25917	+ ** large enough to contain the requested region).
	25918	+ */
	25919	+ if( fstat(pShmNode->h, &sStat) ){
	25920	+ rc = SQLITE_IOERR_SHMSIZE;
	25921	+ goto shmpage_out;
	25922	+ }
	25923	+
	25924	+ if( sStat.st_size<nByte ){
	25925	+ /* The requested memory region does not exist. If bExtend is set to
	25926	+ ** false, exit early. *pp will be set to NULL and SQLITE_OK returned.
	25927	+ **
	25928	+ ** Alternatively, if bExtend is true, use ftruncate() to allocate
	25929	+ ** the requested memory region.
	25930	+ */
	25931	+ if( !bExtend ) goto shmpage_out;
	25932	+ if( ftruncate(pShmNode->h, nByte) ){
	25933	+ rc = SQLITE_IOERR_SHMSIZE;
	25934	+ goto shmpage_out;
	25935	+ }
	25936	+ }
	25937	+
	25938	+ /* Map the requested memory region into this processes address space. */
	25939	+ apNew = (char **)sqlite3_realloc(
	25940	+ pShmNode->apRegion, (iRegion+1)sizeof(char )
	25941	+ );
	25942	+ if( !apNew ){
	25943	+ rc = SQLITE_IOERR_NOMEM;
	25944	+ goto shmpage_out;
	25945	+ }
	25946	+ pShmNode->apRegion = apNew;
	25947	+ while(pShmNode->nRegion<=iRegion){
	25948	+ void *pMem = mmap(0, szRegion, PROT_READ\|PROT_WRITE,
	25949	+ MAP_SHARED, pShmNode->h, iRegion*szRegion
	25950	+ );
	25951	+ if( pMem==MAP_FAILED ){
	25952	+ rc = SQLITE_IOERR;
	25953	+ goto shmpage_out;
	25954	+ }
	25955	+ pShmNode->apRegion[pShmNode->nRegion] = pMem;
	25956	+ pShmNode->nRegion++;
	25957	+ }
	25958	+ }
	25959	+
	25960	+shmpage_out:
	25961	+ if( pShmNode->nRegion>iRegion ){
	25962	+ *pp = pShmNode->apRegion[iRegion];
	25963	+ }else{
	25964	+ *pp = 0;
	25965	+ }
25847	25966	sqlite3_mutex_leave(pShmNode->mutex);
25848		-
25849		- /* If pShmNode->nRef has reached 0, then close the underlying
25850		- ** shared-memory file, too */
25851		- unixEnterMutex();
25852		- assert( pShmNode->nRef>0 );
25853		- pShmNode->nRef--;
25854		- if( pShmNode->nRef==0 ){
25855		- if( deleteFlag ) unlink(pShmNode->zFilename);
25856		- unixShmPurge(pDbFd);
25857		- }
25858		- unixLeaveMutex();
25859		-
25860		- return SQLITE_OK;
	25967	+ return rc;
25861	25968	}
25862	25969
25863	25970	/*
25864	25971	** Change the lock state for a shared-memory segment.
25865	25972	**
		@@ -25985,111 +26092,64 @@
25985	26092	unixEnterMutex();
25986	26093	unixLeaveMutex();
25987	26094	}
25988	26095
25989	26096	/*
25990		-** This function is called to obtain a pointer to region iRegion of the
25991		-** shared-memory associated with the database file fd. Shared-memory regions
25992		-** are numbered starting from zero. Each shared-memory region is szRegion
25993		-** bytes in size.
25994		-**
25995		-** If an error occurs, an error code is returned and *pp is set to NULL.
25996		-**
25997		-** Otherwise, if the isWrite parameter is 0 and the requested shared-memory
25998		-** region has not been allocated (by any client, including one running in a
25999		-** separate process), then *pp is set to NULL and SQLITE_OK returned. If
26000		-** isWrite is non-zero and the requested shared-memory region has not yet
26001		-** been allocated, it is allocated by this function.
26002		-**
26003		-** If the shared-memory region has already been allocated or is allocated by
26004		-** this call as described above, then it is mapped into this processes
26005		-** address space (if it is not already), *pp is set to point to the mapped
26006		-** memory and SQLITE_OK returned.
26007		-*/
26008		-static int unixShmMap(
26009		- sqlite3_file fd, / Handle open on database file */
26010		- int iRegion, /* Region to retrieve */
26011		- int szRegion, /* Size of regions */
26012		- int isWrite, /* True to extend file if necessary */
26013		- void volatile *pp / OUT: Mapped memory */
26014		-){
26015		- unixFile pDbFd = (unixFile)fd;
26016		- unixShm *p = pDbFd->pShm;
26017		- unixShmNode *pShmNode = p->pShmNode;
26018		- int rc = SQLITE_OK;
26019		-
	26097	+** Close a connection to shared-memory. Delete the underlying
	26098	+** storage if deleteFlag is true.
	26099	+**
	26100	+** If there is no shared memory associated with the connection then this
	26101	+** routine is a harmless no-op.
	26102	+*/
	26103	+static int unixShmUnmap(
	26104	+ sqlite3_file fd, / The underlying database file */
	26105	+ int deleteFlag /* Delete shared-memory if true */
	26106	+){
	26107	+ unixShm p; / The connection to be closed */
	26108	+ unixShmNode pShmNode; / The underlying shared-memory file */
	26109	+ unixShm *pp; / For looping over sibling connections */
	26110	+ unixFile pDbFd; / The underlying database file */
	26111	+
	26112	+ pDbFd = (unixFile*)fd;
	26113	+ p = pDbFd->pShm;
	26114	+ if( p==0 ) return SQLITE_OK;
	26115	+ pShmNode = p->pShmNode;
	26116	+
	26117	+ assert( pShmNode==pDbFd->pInode->pShmNode );
	26118	+ assert( pShmNode->pInode==pDbFd->pInode );
	26119	+
	26120	+ /* Remove connection p from the set of connections associated
	26121	+ ** with pShmNode */
26020	26122	sqlite3_mutex_enter(pShmNode->mutex);
26021		- assert( szRegion==pShmNode->szRegion \|\| pShmNode->nRegion==0 );
26022		-
26023		- if( pShmNode->nRegion<=iRegion ){
26024		- char *apNew; / New apRegion[] array */
26025		- int nByte = (iRegion+1)szRegion; / Minimum required file size */
26026		- struct stat sStat; /* Used by fstat() */
26027		-
26028		- pShmNode->szRegion = szRegion;
26029		-
26030		- /* The requested region is not mapped into this processes address space.
26031		- ** Check to see if it has been allocated (i.e. if the wal-index file is
26032		- ** large enough to contain the requested region).
26033		- */
26034		- if( fstat(pShmNode->h, &sStat) ){
26035		- rc = SQLITE_IOERR_SHMSIZE;
26036		- goto shmpage_out;
26037		- }
26038		-
26039		- if( sStat.st_size<nByte ){
26040		- /* The requested memory region does not exist. If isWrite is set to
26041		- ** zero, exit early. *pp will be set to NULL and SQLITE_OK returned.
26042		- **
26043		- ** Alternatively, if isWrite is non-zero, use ftruncate() to allocate
26044		- ** the requested memory region.
26045		- */
26046		- if( !isWrite ) goto shmpage_out;
26047		- if( ftruncate(pShmNode->h, nByte) ){
26048		- rc = SQLITE_IOERR_SHMSIZE;
26049		- goto shmpage_out;
26050		- }
26051		- }
26052		-
26053		- /* Map the requested memory region into this processes address space. */
26054		- apNew = (char **)sqlite3_realloc(
26055		- pShmNode->apRegion, (iRegion+1)sizeof(char )
26056		- );
26057		- if( !apNew ){
26058		- rc = SQLITE_IOERR_NOMEM;
26059		- goto shmpage_out;
26060		- }
26061		- pShmNode->apRegion = apNew;
26062		- while(pShmNode->nRegion<=iRegion){
26063		- void *pMem = mmap(0, szRegion, PROT_READ\|PROT_WRITE,
26064		- MAP_SHARED, pShmNode->h, iRegion*szRegion
26065		- );
26066		- if( pMem==MAP_FAILED ){
26067		- rc = SQLITE_IOERR;
26068		- goto shmpage_out;
26069		- }
26070		- pShmNode->apRegion[pShmNode->nRegion] = pMem;
26071		- pShmNode->nRegion++;
26072		- }
26073		- }
26074		-
26075		-shmpage_out:
26076		- if( pShmNode->nRegion>iRegion ){
26077		- *pp = pShmNode->apRegion[iRegion];
26078		- }else{
26079		- *pp = 0;
26080		- }
	26123	+ for(pp=&pShmNode->pFirst; (pp)!=p; pp = &(pp)->pNext){}
	26124	+ *pp = p->pNext;
	26125	+
	26126	+ /* Free the connection p */
	26127	+ sqlite3_free(p);
	26128	+ pDbFd->pShm = 0;
26081	26129	sqlite3_mutex_leave(pShmNode->mutex);
26082		- return rc;
	26130	+
	26131	+ /* If pShmNode->nRef has reached 0, then close the underlying
	26132	+ ** shared-memory file, too */
	26133	+ unixEnterMutex();
	26134	+ assert( pShmNode->nRef>0 );
	26135	+ pShmNode->nRef--;
	26136	+ if( pShmNode->nRef==0 ){
	26137	+ if( deleteFlag ) unlink(pShmNode->zFilename);
	26138	+ unixShmPurge(pDbFd);
	26139	+ }
	26140	+ unixLeaveMutex();
	26141	+
	26142	+ return SQLITE_OK;
26083	26143	}
	26144	+
26084	26145
26085	26146	#else
26086		-# define unixShmOpen 0
	26147	+# define unixShmMap 0
26087	26148	# define unixShmLock 0
26088		-# define unixShmMap 0
26089	26149	# define unixShmBarrier 0
26090		-# define unixShmClose 0
	26150	+# define unixShmUnmap 0
26091	26151	#endif /* #ifndef SQLITE_OMIT_WAL */
26092	26152
26093	26153	/*
26094	26154	** Here ends the implementation of all sqlite3_file methods.
26095	26155	**
		@@ -26143,15 +26203,14 @@
26143	26203	UNLOCK, /* xUnlock */ \
26144	26204	CKLOCK, /* xCheckReservedLock */ \
26145	26205	unixFileControl, /* xFileControl */ \
26146	26206	unixSectorSize, /* xSectorSize */ \
26147	26207	unixDeviceCharacteristics, /* xDeviceCapabilities */ \
26148		- unixShmOpen, /* xShmOpen */ \
	26208	+ unixShmMap, /* xShmMap */ \
26149	26209	unixShmLock, /* xShmLock */ \
26150		- unixShmMap, /* xShmMap */ \
26151	26210	unixShmBarrier, /* xShmBarrier */ \
26152		- unixShmClose /* xShmClose */ \
	26211	+ unixShmUnmap /* xShmUnmap */ \
26153	26212	}; \
26154	26213	static const sqlite3_io_methods FINDER##Impl(const char z, unixFile *p){ \
26155	26214	UNUSED_PARAMETER(z); UNUSED_PARAMETER(p); \
26156	26215	return &METHOD; \
26157	26216	} \
		@@ -26164,29 +26223,29 @@
26164	26223	** are also created.
26165	26224	*/
26166	26225	IOMETHODS(
26167	26226	posixIoFinder, /* Finder function name */
26168	26227	posixIoMethods, /* sqlite3_io_methods object name */
26169		- 2, /* ShmOpen is enabled */
	26228	+ 2, /* shared memory is enabled */
26170	26229	unixClose, /* xClose method */
26171	26230	unixLock, /* xLock method */
26172	26231	unixUnlock, /* xUnlock method */
26173	26232	unixCheckReservedLock /* xCheckReservedLock method */
26174	26233	)
26175	26234	IOMETHODS(
26176	26235	nolockIoFinder, /* Finder function name */
26177	26236	nolockIoMethods, /* sqlite3_io_methods object name */
26178		- 1, /* ShmOpen is disabled */
	26237	+ 1, /* shared memory is disabled */
26179	26238	nolockClose, /* xClose method */
26180	26239	nolockLock, /* xLock method */
26181	26240	nolockUnlock, /* xUnlock method */
26182	26241	nolockCheckReservedLock /* xCheckReservedLock method */
26183	26242	)
26184	26243	IOMETHODS(
26185	26244	dotlockIoFinder, /* Finder function name */
26186	26245	dotlockIoMethods, /* sqlite3_io_methods object name */
26187		- 1, /* ShmOpen is disabled */
	26246	+ 1, /* shared memory is disabled */
26188	26247	dotlockClose, /* xClose method */
26189	26248	dotlockLock, /* xLock method */
26190	26249	dotlockUnlock, /* xUnlock method */
26191	26250	dotlockCheckReservedLock /* xCheckReservedLock method */
26192	26251	)
		@@ -26193,11 +26252,11 @@
26193	26252
26194	26253	#if SQLITE_ENABLE_LOCKING_STYLE && !OS_VXWORKS
26195	26254	IOMETHODS(
26196	26255	flockIoFinder, /* Finder function name */
26197	26256	flockIoMethods, /* sqlite3_io_methods object name */
26198		- 1, /* ShmOpen is disabled */
	26257	+ 1, /* shared memory is disabled */
26199	26258	flockClose, /* xClose method */
26200	26259	flockLock, /* xLock method */
26201	26260	flockUnlock, /* xUnlock method */
26202	26261	flockCheckReservedLock /* xCheckReservedLock method */
26203	26262	)
		@@ -26205,11 +26264,11 @@
26205	26264
26206	26265	#if OS_VXWORKS
26207	26266	IOMETHODS(
26208	26267	semIoFinder, /* Finder function name */
26209	26268	semIoMethods, /* sqlite3_io_methods object name */
26210		- 1, /* ShmOpen is disabled */
	26269	+ 1, /* shared memory is disabled */
26211	26270	semClose, /* xClose method */
26212	26271	semLock, /* xLock method */
26213	26272	semUnlock, /* xUnlock method */
26214	26273	semCheckReservedLock /* xCheckReservedLock method */
26215	26274	)
		@@ -26217,11 +26276,11 @@
26217	26276
26218	26277	#if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE
26219	26278	IOMETHODS(
26220	26279	afpIoFinder, /* Finder function name */
26221	26280	afpIoMethods, /* sqlite3_io_methods object name */
26222		- 1, /* ShmOpen is disabled */
	26281	+ 1, /* shared memory is disabled */
26223	26282	afpClose, /* xClose method */
26224	26283	afpLock, /* xLock method */
26225	26284	afpUnlock, /* xUnlock method */
26226	26285	afpCheckReservedLock /* xCheckReservedLock method */
26227	26286	)
		@@ -26242,11 +26301,11 @@
26242	26301	static int proxyUnlock(sqlite3_file*, int);
26243	26302	static int proxyCheckReservedLock(sqlite3_file, int);
26244	26303	IOMETHODS(
26245	26304	proxyIoFinder, /* Finder function name */
26246	26305	proxyIoMethods, /* sqlite3_io_methods object name */
26247		- 1, /* ShmOpen is disabled */
	26306	+ 1, /* shared memory is disabled */
26248	26307	proxyClose, /* xClose method */
26249	26308	proxyLock, /* xLock method */
26250	26309	proxyUnlock, /* xUnlock method */
26251	26310	proxyCheckReservedLock /* xCheckReservedLock method */
26252	26311	)
		@@ -26255,11 +26314,11 @@
26255	26314	/* nfs lockd on OSX 10.3+ doesn't clear write locks when a read lock is set */
26256	26315	#if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE
26257	26316	IOMETHODS(
26258	26317	nfsIoFinder, /* Finder function name */
26259	26318	nfsIoMethods, /* sqlite3_io_methods object name */
26260		- 1, /* ShmOpen is disabled */
	26319	+ 1, /* shared memory is disabled */
26261	26320	unixClose, /* xClose method */
26262	26321	unixLock, /* xLock method */
26263	26322	nfsUnlock, /* xUnlock method */
26264	26323	unixCheckReservedLock /* xCheckReservedLock method */
26265	26324	)
		@@ -26717,10 +26776,55 @@
26717	26776	unixLeaveMutex();
26718	26777	}
26719	26778	#endif /* if !OS_VXWORKS */
26720	26779	return pUnused;
26721	26780	}
	26781	+
	26782	+/*
	26783	+** This function is called by unixOpen() to determine the unix permissions
	26784	+** to create new files with. If no error occurs, then SQLITE_OK is returned
	26785	+** and a value suitable for passing as the third argument to open(2) is
	26786	+** written to *pMode. If an IO error occurs, an SQLite error code is
	26787	+** returned and the value of *pMode is not modified.
	26788	+**
	26789	+** If the file being opened is a temporary file, it is always created with
	26790	+** the octal permissions 0600 (read/writable by owner only). If the file
	26791	+** is a database or master journal file, it is created with the permissions
	26792	+** mask SQLITE_DEFAULT_FILE_PERMISSIONS.
	26793	+**
	26794	+** Finally, if the file being opened is a WAL or regular journal file, then
	26795	+** this function queries the file-system for the permissions on the
	26796	+** corresponding database file and sets *pMode to this value. Whenever
	26797	+** possible, WAL and journal files are created using the same permissions
	26798	+** as the associated database file.
	26799	+*/
	26800	+static int findCreateFileMode(
	26801	+ const char zPath, / Path of file (possibly) being created */
	26802	+ int flags, /* Flags passed as 4th argument to xOpen() */
	26803	+ mode_t pMode / OUT: Permissions to open file with */
	26804	+){
	26805	+ int rc = SQLITE_OK; /* Return Code */
	26806	+ if( flags & (SQLITE_OPEN_WAL\|SQLITE_OPEN_MAIN_JOURNAL) ){
	26807	+ char zDb[MAX_PATHNAME+1]; /* Database file path */
	26808	+ int nDb; /* Number of valid bytes in zDb */
	26809	+ struct stat sStat; /* Output of stat() on database file */
	26810	+
	26811	+ nDb = sqlite3Strlen30(zPath) - ((flags & SQLITE_OPEN_WAL) ? 4 : 8);
	26812	+ memcpy(zDb, zPath, nDb);
	26813	+ zDb[nDb] = '\0';
	26814	+ if( 0==stat(zDb, &sStat) ){
	26815	+ *pMode = sStat.st_mode & 0777;
	26816	+ }else{
	26817	+ rc = SQLITE_IOERR_FSTAT;
	26818	+ }
	26819	+ }else if( flags & SQLITE_OPEN_DELETEONCLOSE ){
	26820	+ *pMode = 0600;
	26821	+ }else{
	26822	+ *pMode = SQLITE_DEFAULT_FILE_PERMISSIONS;
	26823	+ }
	26824	+ return rc;
	26825	+}
26722	26826
26723	26827	/*
26724	26828	** Open the file zPath.
26725	26829	**
26726	26830	** Previously, the SQLite OS layer used three functions in place of this
		@@ -26768,13 +26872,15 @@
26768	26872
26769	26873	/* If creating a master or main-file journal, this function will open
26770	26874	** a file-descriptor on the directory too. The first time unixSync()
26771	26875	** is called the directory file descriptor will be fsync()ed and close()d.
26772	26876	*/
26773		- int isOpenDirectory = (isCreate &&
26774		- (eType==SQLITE_OPEN_MASTER_JOURNAL \|\| eType==SQLITE_OPEN_MAIN_JOURNAL)
26775		- );
	26877	+ int isOpenDirectory = (isCreate && (
	26878	+ eType==SQLITE_OPEN_MASTER_JOURNAL
	26879	+ \|\| eType==SQLITE_OPEN_MAIN_JOURNAL
	26880	+ \|\| eType==SQLITE_OPEN_WAL
	26881	+ ));
26776	26882
26777	26883	/* If argument zPath is a NULL pointer, this function is required to open
26778	26884	** a temporary file. Use this buffer to store the file name in.
26779	26885	*/
26780	26886	char zTmpname[MAX_PATHNAME+1];
		@@ -26790,21 +26896,22 @@
26790	26896	assert((isReadonly==0 \|\| isReadWrite==0) && (isReadWrite \|\| isReadonly));
26791	26897	assert(isCreate==0 \|\| isReadWrite);
26792	26898	assert(isExclusive==0 \|\| isCreate);
26793	26899	assert(isDelete==0 \|\| isCreate);
26794	26900
26795		- /* The main DB, main journal, and master journal are never automatically
26796		- ** deleted. Nor are they ever temporary files. */
	26901	+ /* The main DB, main journal, WAL file and master journal are never
	26902	+ ** automatically deleted. Nor are they ever temporary files. */
26797	26903	assert( (!isDelete && zName) \|\| eType!=SQLITE_OPEN_MAIN_DB );
26798	26904	assert( (!isDelete && zName) \|\| eType!=SQLITE_OPEN_MAIN_JOURNAL );
26799	26905	assert( (!isDelete && zName) \|\| eType!=SQLITE_OPEN_MASTER_JOURNAL );
	26906	+ assert( (!isDelete && zName) \|\| eType!=SQLITE_OPEN_WAL );
26800	26907
26801	26908	/* Assert that the upper layer has set one of the "file-type" flags. */
26802	26909	assert( eType==SQLITE_OPEN_MAIN_DB \|\| eType==SQLITE_OPEN_TEMP_DB
26803	26910	\|\| eType==SQLITE_OPEN_MAIN_JOURNAL \|\| eType==SQLITE_OPEN_TEMP_JOURNAL
26804	26911	\|\| eType==SQLITE_OPEN_SUBJOURNAL \|\| eType==SQLITE_OPEN_MASTER_JOURNAL
26805		- \|\| eType==SQLITE_OPEN_TRANSIENT_DB
	26912	+ \|\| eType==SQLITE_OPEN_TRANSIENT_DB \|\| eType==SQLITE_OPEN_WAL
26806	26913	);
26807	26914
26808	26915	memset(p, 0, sizeof(unixFile));
26809	26916
26810	26917	if( eType==SQLITE_OPEN_MAIN_DB ){
		@@ -26838,11 +26945,17 @@
26838	26945	if( isCreate ) openFlags \|= O_CREAT;
26839	26946	if( isExclusive ) openFlags \|= (O_EXCL\|O_NOFOLLOW);
26840	26947	openFlags \|= (O_LARGEFILE\|O_BINARY);
26841	26948
26842	26949	if( fd<0 ){
26843		- mode_t openMode = (isDelete?0600:SQLITE_DEFAULT_FILE_PERMISSIONS);
	26950	+ mode_t openMode; /* Permissions to create file with */
	26951	+ rc = findCreateFileMode(zName, flags, &openMode);
	26952	+ if( rc!=SQLITE_OK ){
	26953	+ assert( !p->pUnused );
	26954	+ assert( eType==SQLITE_OPEN_WAL \|\| eType==SQLITE_OPEN_MAIN_JOURNAL );
	26955	+ return rc;
	26956	+ }
26844	26957	fd = open(zName, openFlags, openMode);
26845	26958	OSTRACE(("OPENX %-3d %s 0%o\n", fd, zName, openFlags));
26846	26959	if( fd<0 && errno!=EISDIR && isReadWrite && !isExclusive ){
26847	26960	/* Failed to open the file for read/write access. Try read-only. */
26848	26961	flags &= ~(SQLITE_OPEN_READWRITE\|SQLITE_OPEN_CREATE);
		@@ -26981,11 +27094,13 @@
26981	27094	int dirSync /* If true, fsync() directory after deleting file */
26982	27095	){
26983	27096	int rc = SQLITE_OK;
26984	27097	UNUSED_PARAMETER(NotUsed);
26985	27098	SimulateIOError(return SQLITE_IOERR_DELETE);
26986		- unlink(zPath);
	27099	+ if( unlink(zPath)==(-1) && errno!=ENOENT ){
	27100	+ return SQLITE_IOERR_DELETE;
	27101	+ }
26987	27102	#ifndef SQLITE_DISABLE_DIRSYNC
26988	27103	if( dirSync ){
26989	27104	int fd;
26990	27105	rc = openDirectory(zPath, &fd);
26991	27106	if( rc==SQLITE_OK ){
		@@ -29959,15 +30074,10 @@
29959	30074	static int winDeviceCharacteristics(sqlite3_file *id){
29960	30075	UNUSED_PARAMETER(id);
29961	30076	return SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN;
29962	30077	}
29963	30078
29964		-/****************************************************************************
29965		-******************************* Shared Memory ***************************
29966		-**
29967		-** The next subdivision of code manages the shared-memory primitives.
29968		-*/
29969	30079	#ifndef SQLITE_OMIT_WAL
29970	30080
29971	30081	/*
29972	30082	** Helper functions to obtain and relinquish the global mutex. The
29973	30083	** global mutex is used to protect the winLockInfo objects used by
		@@ -29977,11 +30087,11 @@
29977	30087	** is held when required. This function is only used as part of assert()
29978	30088	** statements. e.g.
29979	30089	**
29980	30090	** winShmEnterMutex()
29981	30091	** assert( winShmMutexHeld() );
29982		-** winEnterLeave()
	30092	+** winShmLeaveMutex()
29983	30093	*/
29984	30094	static void winShmEnterMutex(void){
29985	30095	sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
29986	30096	}
29987	30097	static void winShmLeaveMutex(void){
		@@ -30013,15 +30123,10 @@
30013	30123	**
30014	30124	** Either winShmNode.mutex must be held or winShmNode.nRef==0 and
30015	30125	** winShmMutexHeld() is true when reading or writing any other field
30016	30126	** in this structure.
30017	30127	**
30018		-** To avoid deadlocks, mutex and mutexBuf are always released in the
30019		-** reverse order that they are acquired. mutexBuf is always acquired
30020		-** first and released last. This invariant is check by asserting
30021		-** sqlite3_mutex_notheld() on mutex whenever mutexBuf is acquired or
30022		-** released.
30023	30128	*/
30024	30129	struct winShmNode {
30025	30130	sqlite3_mutex mutex; / Mutex to access this object */
30026	30131	char zFilename; / Name of the file */
30027	30132	winFile hFile; /* File handle from winOpen */
		@@ -30051,21 +30156,25 @@
30051	30156
30052	30157	/*
30053	30158	** Structure used internally by this VFS to record the state of an
30054	30159	** open shared memory connection.
30055	30160	**
30056		-** winShm.pFile->mutex must be held while reading or writing the
30057		-** winShm.pNext and winShm.locks[] elements.
	30161	+** The following fields are initialized when this object is created and
	30162	+** are read-only thereafter:
30058	30163	**
30059		-** The winShm.pFile element is initialized when the object is created
30060		-** and is read-only thereafter.
	30164	+** winShm.pShmNode
	30165	+** winShm.id
	30166	+**
	30167	+** All other fields are read/write. The winShm.pShmNode->mutex must be held
	30168	+** while accessing any read/write fields.
30061	30169	*/
30062	30170	struct winShm {
30063	30171	winShmNode pShmNode; / The underlying winShmNode object */
30064	30172	winShm pNext; / Next winShm with the same winShmNode */
30065	30173	u8 hasMutex; /* True if holding the winShmNode mutex */
30066		- u8 hasMutexBuf; /* True if holding pFile->mutexBuf */
	30174	+ u16 sharedMask; /* Mask of shared locks held */
	30175	+ u16 exclMask; /* Mask of exclusive locks held */
30067	30176	#ifdef SQLITE_DEBUG
30068	30177	u8 id; /* Id of this connection with its winShmNode */
30069	30178	#endif
30070	30179	};
30071	30180
		@@ -30096,27 +30205,32 @@
30096	30205
30097	30206	/* Initialize the locking parameters */
30098	30207	dwFlags = LOCKFILE_FAIL_IMMEDIATELY;
30099	30208	if( lockType == _SHM_WRLCK ) dwFlags \|= LOCKFILE_EXCLUSIVE_LOCK;
30100	30209
30101		- /* Find the first bit in lockMask that is set */
30102	30210	memset(&ovlp, 0, sizeof(OVERLAPPED));
30103	30211	ovlp.Offset = ofst;
30104	30212
30105	30213	/* Release/Acquire the system-level lock */
30106	30214	if( lockType==_SHM_UNLCK ){
30107	30215	rc = UnlockFileEx(pFile->hFile.h, 0, nByte, 0, &ovlp);
30108	30216	}else{
30109	30217	rc = LockFileEx(pFile->hFile.h, dwFlags, 0, nByte, 0, &ovlp);
30110	30218	}
30111		- if( !rc ){
30112		- OSTRACE(("SHM-LOCK %d %s ERROR 0x%08lx\n",
30113		- pFile->hFile.h,
30114		- lockType==_SHM_UNLCK ? "UnlockFileEx" : "LockFileEx",
30115		- GetLastError()));
	30219	+
	30220	+ if( rc!= 0 ){
	30221	+ rc = SQLITE_OK;
	30222	+ }else{
	30223	+ pFile->lastErrno = GetLastError();
	30224	+ rc = SQLITE_BUSY;
30116	30225	}
30117		- rc = (rc!=0) ? SQLITE_OK : SQLITE_BUSY;
	30226	+
	30227	+ OSTRACE(("SHM-LOCK %d %s %s 0x%08lx\n",
	30228	+ pFile->hFile.h,
	30229	+ rc==SQLITE_OK ? "ok" : "failed",
	30230	+ lockType==_SHM_UNLCK ? "UnlockFileEx" : "LockFileEx",
	30231	+ pFile->lastErrno));
30118	30232
30119	30233	return rc;
30120	30234	}
30121	30235
30122	30236	/* Forward references to VFS methods */
		@@ -30160,35 +30274,23 @@
30160	30274	}
30161	30275	}
30162	30276	}
30163	30277
30164	30278	/*
30165		-** Open a shared-memory area. This particular implementation uses
30166		-** mmapped files.
30167		-**
30168		-** zName is a filename used to identify the shared-memory area. The
30169		-** implementation does not (and perhaps should not) use this name
30170		-** directly, but rather use it as a template for finding an appropriate
30171		-** name for the shared-memory storage. In this implementation, the
30172		-** string "-index" is appended to zName and used as the name of the
30173		-** mmapped file.
	30279	+** Open the shared-memory area associated with database file pDbFd.
30174	30280	**
30175	30281	** When opening a new shared-memory file, if no other instances of that
30176	30282	** file are currently open, in this process or in other processes, then
30177	30283	** the file must be truncated to zero length or have its header cleared.
30178	30284	*/
30179		-static int winShmOpen(
30180		- sqlite3_file fd / The file to which to attach shared memory */
30181		-){
30182		- struct winFile pDbFd; / Database to which to attach SHM */
	30285	+static int winOpenSharedMemory(winFile *pDbFd){
30183	30286	struct winShm p; / The connection to be opened */
30184	30287	struct winShmNode pShmNode = 0; / The underlying mmapped file */
30185	30288	int rc; /* Result code */
30186	30289	struct winShmNode pNew; / Newly allocated winShmNode */
30187	30290	int nName; /* Size of zName in bytes */
30188	30291
30189		- pDbFd = (winFile*)fd;
30190	30292	assert( pDbFd->pShm==0 ); /* Not previously opened */
30191	30293
30192	30294	/* Allocate space for the new sqlite3_shm object. Also speculatively
30193	30295	** allocate space for a new winShmNode and filename.
30194	30296	*/
		@@ -30255,18 +30357,28 @@
30255	30357	if( rc ) goto shm_open_err;
30256	30358	}
30257	30359
30258	30360	/* Make the new connection a child of the winShmNode */
30259	30361	p->pShmNode = pShmNode;
30260		- p->pNext = pShmNode->pFirst;
30261	30362	#ifdef SQLITE_DEBUG
30262	30363	p->id = pShmNode->nextShmId++;
30263	30364	#endif
30264		- pShmNode->pFirst = p;
30265	30365	pShmNode->nRef++;
30266	30366	pDbFd->pShm = p;
30267	30367	winShmLeaveMutex();
	30368	+
	30369	+ /* The reference count on pShmNode has already been incremented under
	30370	+ ** the cover of the winShmEnterMutex() mutex and the pointer from the
	30371	+ ** new (struct winShm) object to the pShmNode has been set. All that is
	30372	+ ** left to do is to link the new object into the linked list starting
	30373	+ ** at pShmNode->pFirst. This must be done while holding the pShmNode->mutex
	30374	+ ** mutex.
	30375	+ */
	30376	+ sqlite3_mutex_enter(pShmNode->mutex);
	30377	+ p->pNext = pShmNode->pFirst;
	30378	+ pShmNode->pFirst = p;
	30379	+ sqlite3_mutex_leave(pShmNode->mutex);
30268	30380	return SQLITE_OK;
30269	30381
30270	30382	/* Jump here on any error */
30271	30383	shm_open_err:
30272	30384	winShmSystemLock(pShmNode, _SHM_UNLCK, WIN_SHM_DMS, 1);
		@@ -30279,11 +30391,11 @@
30279	30391
30280	30392	/*
30281	30393	** Close a connection to shared-memory. Delete the underlying
30282	30394	** storage if deleteFlag is true.
30283	30395	*/
30284		-static int winShmClose(
	30396	+static int winShmUnmap(
30285	30397	sqlite3_file fd, / Database holding shared memory */
30286	30398	int deleteFlag /* Delete after closing if true */
30287	30399	){
30288	30400	winFile pDbFd; / Database holding shared-memory */
30289	30401	winShm p; / The connection to be closed */
		@@ -30290,10 +30402,11 @@
30290	30402	winShmNode pShmNode; / The underlying shared-memory file */
30291	30403	winShm *pp; / For looping over sibling connections */
30292	30404
30293	30405	pDbFd = (winFile*)fd;
30294	30406	p = pDbFd->pShm;
	30407	+ if( p==0 ) return SQLITE_OK;
30295	30408	pShmNode = p->pShmNode;
30296	30409
30297	30410	/* Remove connection p from the set of connections associated
30298	30411	** with pShmNode */
30299	30412	sqlite3_mutex_enter(pShmNode->mutex);
		@@ -30315,10 +30428,131 @@
30315	30428	}
30316	30429	winShmLeaveMutex();
30317	30430
30318	30431	return SQLITE_OK;
30319	30432	}
	30433	+
	30434	+/*
	30435	+** Change the lock state for a shared-memory segment.
	30436	+*/
	30437	+static int winShmLock(
	30438	+ sqlite3_file fd, / Database file holding the shared memory */
	30439	+ int ofst, /* First lock to acquire or release */
	30440	+ int n, /* Number of locks to acquire or release */
	30441	+ int flags /* What to do with the lock */
	30442	+){
	30443	+ winFile pDbFd = (winFile)fd; /* Connection holding shared memory */
	30444	+ winShm p = pDbFd->pShm; / The shared memory being locked */
	30445	+ winShm pX; / For looping over all siblings */
	30446	+ winShmNode *pShmNode = p->pShmNode;
	30447	+ int rc = SQLITE_OK; /* Result code */
	30448	+ u16 mask; /* Mask of locks to take or release */
	30449	+
	30450	+ assert( ofst>=0 && ofst+n<=SQLITE_SHM_NLOCK );
	30451	+ assert( n>=1 );
	30452	+ assert( flags==(SQLITE_SHM_LOCK \| SQLITE_SHM_SHARED)
	30453	+ \|\| flags==(SQLITE_SHM_LOCK \| SQLITE_SHM_EXCLUSIVE)
	30454	+ \|\| flags==(SQLITE_SHM_UNLOCK \| SQLITE_SHM_SHARED)
	30455	+ \|\| flags==(SQLITE_SHM_UNLOCK \| SQLITE_SHM_EXCLUSIVE) );
	30456	+ assert( n==1 \|\| (flags & SQLITE_SHM_EXCLUSIVE)!=0 );
	30457	+
	30458	+ mask = (u16)((1U<<(ofst+n)) - (1U<<ofst));
	30459	+ assert( n>1 \|\| mask==(1<<ofst) );
	30460	+ sqlite3_mutex_enter(pShmNode->mutex);
	30461	+ if( flags & SQLITE_SHM_UNLOCK ){
	30462	+ u16 allMask = 0; /* Mask of locks held by siblings */
	30463	+
	30464	+ /* See if any siblings hold this same lock */
	30465	+ for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
	30466	+ if( pX==p ) continue;
	30467	+ assert( (pX->exclMask & (p->exclMask\|p->sharedMask))==0 );
	30468	+ allMask \|= pX->sharedMask;
	30469	+ }
	30470	+
	30471	+ /* Unlock the system-level locks */
	30472	+ if( (mask & allMask)==0 ){
	30473	+ rc = winShmSystemLock(pShmNode, _SHM_UNLCK, ofst+WIN_SHM_BASE, n);
	30474	+ }else{
	30475	+ rc = SQLITE_OK;
	30476	+ }
	30477	+
	30478	+ /* Undo the local locks */
	30479	+ if( rc==SQLITE_OK ){
	30480	+ p->exclMask &= ~mask;
	30481	+ p->sharedMask &= ~mask;
	30482	+ }
	30483	+ }else if( flags & SQLITE_SHM_SHARED ){
	30484	+ u16 allShared = 0; /* Union of locks held by connections other than "p" */
	30485	+
	30486	+ /* Find out which shared locks are already held by sibling connections.
	30487	+ ** If any sibling already holds an exclusive lock, go ahead and return
	30488	+ ** SQLITE_BUSY.
	30489	+ */
	30490	+ for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
	30491	+ if( (pX->exclMask & mask)!=0 ){
	30492	+ rc = SQLITE_BUSY;
	30493	+ break;
	30494	+ }
	30495	+ allShared \|= pX->sharedMask;
	30496	+ }
	30497	+
	30498	+ /* Get shared locks at the system level, if necessary */
	30499	+ if( rc==SQLITE_OK ){
	30500	+ if( (allShared & mask)==0 ){
	30501	+ rc = winShmSystemLock(pShmNode, _SHM_RDLCK, ofst+WIN_SHM_BASE, n);
	30502	+ }else{
	30503	+ rc = SQLITE_OK;
	30504	+ }
	30505	+ }
	30506	+
	30507	+ /* Get the local shared locks */
	30508	+ if( rc==SQLITE_OK ){
	30509	+ p->sharedMask \|= mask;
	30510	+ }
	30511	+ }else{
	30512	+ /* Make sure no sibling connections hold locks that will block this
	30513	+ ** lock. If any do, return SQLITE_BUSY right away.
	30514	+ */
	30515	+ for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
	30516	+ if( (pX->exclMask & mask)!=0 \|\| (pX->sharedMask & mask)!=0 ){
	30517	+ rc = SQLITE_BUSY;
	30518	+ break;
	30519	+ }
	30520	+ }
	30521	+
	30522	+ /* Get the exclusive locks at the system level. Then if successful
	30523	+ ** also mark the local connection as being locked.
	30524	+ */
	30525	+ if( rc==SQLITE_OK ){
	30526	+ rc = winShmSystemLock(pShmNode, _SHM_WRLCK, ofst+WIN_SHM_BASE, n);
	30527	+ if( rc==SQLITE_OK ){
	30528	+ assert( (p->sharedMask & mask)==0 );
	30529	+ p->exclMask \|= mask;
	30530	+ }
	30531	+ }
	30532	+ }
	30533	+ sqlite3_mutex_leave(pShmNode->mutex);
	30534	+ OSTRACE(("SHM-LOCK shmid-%d, pid-%d got %03x,%03x %s\n",
	30535	+ p->id, (int)GetCurrentProcessId(), p->sharedMask, p->exclMask,
	30536	+ rc ? "failed" : "ok"));
	30537	+ return rc;
	30538	+}
	30539	+
	30540	+/*
	30541	+** Implement a memory barrier or memory fence on shared memory.
	30542	+**
	30543	+** All loads and stores begun before the barrier must complete before
	30544	+** any load or store begun after the barrier.
	30545	+*/
	30546	+static void winShmBarrier(
	30547	+ sqlite3_file fd / Database holding the shared memory */
	30548	+){
	30549	+ UNUSED_PARAMETER(fd);
	30550	+ /* MemoryBarrier(); // does not work -- do not know why not */
	30551	+ winShmEnterMutex();
	30552	+ winShmLeaveMutex();
	30553	+}
30320	30554
30321	30555	/*
30322	30556	** This function is called to obtain a pointer to region iRegion of the
30323	30557	** shared-memory associated with the database file fd. Shared-memory regions
30324	30558	** are numbered starting from zero. Each shared-memory region is szRegion
		@@ -30344,13 +30578,20 @@
30344	30578	int isWrite, /* True to extend file if necessary */
30345	30579	void volatile *pp / OUT: Mapped memory */
30346	30580	){
30347	30581	winFile pDbFd = (winFile)fd;
30348	30582	winShm *p = pDbFd->pShm;
30349		- winShmNode *pShmNode = p->pShmNode;
	30583	+ winShmNode *pShmNode;
30350	30584	int rc = SQLITE_OK;
30351	30585
	30586	+ if( !p ){
	30587	+ rc = winOpenSharedMemory(pDbFd);
	30588	+ if( rc!=SQLITE_OK ) return rc;
	30589	+ p = pDbFd->pShm;
	30590	+ }
	30591	+ pShmNode = p->pShmNode;
	30592	+
30352	30593	sqlite3_mutex_enter(pShmNode->mutex);
30353	30594	assert( szRegion==pShmNode->szRegion \|\| pShmNode->nRegion==0 );
30354	30595
30355	30596	if( pShmNode->nRegion<=iRegion ){
30356	30597	struct ShmRegion apNew; / New aRegion[] array */
		@@ -30363,10 +30604,11 @@
30363	30604	** Check to see if it has been allocated (i.e. if the wal-index file is
30364	30605	** large enough to contain the requested region).
30365	30606	*/
30366	30607	rc = winFileSize((sqlite3_file *)&pShmNode->hFile, &sz);
30367	30608	if( rc!=SQLITE_OK ){
	30609	+ rc = SQLITE_IOERR_SHMSIZE;
30368	30610	goto shmpage_out;
30369	30611	}
30370	30612
30371	30613	if( sz<nByte ){
30372	30614	/* The requested memory region does not exist. If isWrite is set to
		@@ -30376,10 +30618,11 @@
30376	30618	** the requested memory region.
30377	30619	*/
30378	30620	if( !isWrite ) goto shmpage_out;
30379	30621	rc = winTruncate((sqlite3_file *)&pShmNode->hFile, nByte);
30380	30622	if( rc!=SQLITE_OK ){
	30623	+ rc = SQLITE_IOERR_SHMSIZE;
30381	30624	goto shmpage_out;
30382	30625	}
30383	30626	}
30384	30627
30385	30628	/* Map the requested memory region into this processes address space. */
		@@ -30426,102 +30669,53 @@
30426	30669	}
30427	30670	sqlite3_mutex_leave(pShmNode->mutex);
30428	30671	return rc;
30429	30672	}
30430	30673
30431		-/*
30432		-** Change the lock state for a shared-memory segment.
30433		-*/
30434		-static int winShmLock(
30435		- sqlite3_file fd, / Database file holding the shared memory */
30436		- int ofst, /* First lock to acquire or release */
30437		- int n, /* Number of locks to acquire or release */
30438		- int flags /* What to do with the lock */
30439		-){
30440		- winFile pDbFd = (winFile)fd;
30441		- winShm *p = pDbFd->pShm;
30442		- winShmNode *pShmNode = p->pShmNode;
30443		- int rc = SQLITE_PROTOCOL;
30444		-
30445		- assert( ofst>=0 && ofst+n<=SQLITE_SHM_NLOCK );
30446		- assert( n>=1 );
30447		- assert( flags==(SQLITE_SHM_LOCK \| SQLITE_SHM_SHARED)
30448		- \|\| flags==(SQLITE_SHM_LOCK \| SQLITE_SHM_EXCLUSIVE)
30449		- \|\| flags==(SQLITE_SHM_UNLOCK \| SQLITE_SHM_SHARED)
30450		- \|\| flags==(SQLITE_SHM_UNLOCK \| SQLITE_SHM_EXCLUSIVE) );
30451		- assert( n==1 \|\| (flags & SQLITE_SHM_EXCLUSIVE)!=0 );
30452		-
30453		- sqlite3_mutex_enter(pShmNode->mutex);
30454		- if( flags & SQLITE_SHM_UNLOCK ){
30455		- rc = winShmSystemLock(pShmNode, _SHM_UNLCK, ofst+WIN_SHM_BASE, n);
30456		- }else if( flags & SQLITE_SHM_SHARED ){
30457		- rc = winShmSystemLock(pShmNode, _SHM_RDLCK, ofst+WIN_SHM_BASE, n);
30458		- }else{
30459		- rc = winShmSystemLock(pShmNode, _SHM_WRLCK, ofst+WIN_SHM_BASE, n);
30460		- }
30461		- sqlite3_mutex_leave(pShmNode->mutex);
30462		- OSTRACE(("SHM-LOCK shmid-%d, pid-%d %s\n",
30463		- p->id, (int)GetCurrentProcessId(), rc ? "failed" : "ok"));
30464		- return rc;
30465		-}
30466		-
30467		-/*
30468		-** Implement a memory barrier or memory fence on shared memory.
30469		-**
30470		-** All loads and stores begun before the barrier must complete before
30471		-** any load or store begun after the barrier.
30472		-*/
30473		-static void winShmBarrier(
30474		- sqlite3_file fd / Database holding the shared memory */
30475		-){
30476		- UNUSED_PARAMETER(fd);
30477		- /* MemoryBarrier(); // does not work -- do not know why not */
30478		- winShmEnterMutex();
30479		- winShmLeaveMutex();
30480		-}
30481		-
30482	30674	#else
30483		-# define winShmOpen 0
30484	30675	# define winShmMap 0
30485	30676	# define winShmLock 0
30486	30677	# define winShmBarrier 0
30487		-# define winShmClose 0
	30678	+# define winShmUnmap 0
30488	30679	#endif /* #ifndef SQLITE_OMIT_WAL */
	30680	+
30489	30681	/*
30490		-*************************** End Shared Memory ***************************
30491		-****************************************************************************/
	30682	+** Here ends the implementation of all sqlite3_file methods.
	30683	+**
	30684	+******************** End sqlite3_file Methods *****************************
	30685	+******************************************************************************/
30492	30686
30493	30687	/*
30494	30688	** This vector defines all the methods that can operate on an
30495	30689	** sqlite3_file for win32.
30496	30690	*/
30497	30691	static const sqlite3_io_methods winIoMethod = {
30498		- 2, /* iVersion */
30499		- winClose,
30500		- winRead,
30501		- winWrite,
30502		- winTruncate,
30503		- winSync,
30504		- winFileSize,
30505		- winLock,
30506		- winUnlock,
30507		- winCheckReservedLock,
30508		- winFileControl,
30509		- winSectorSize,
30510		- winDeviceCharacteristics,
30511		- winShmOpen, /* xShmOpen */
30512		- winShmLock, /* xShmLock */
30513		- winShmMap, /* xShmMap */
30514		- winShmBarrier, /* xShmBarrier */
30515		- winShmClose /* xShmClose */
	30692	+ 2, /* iVersion */
	30693	+ winClose, /* xClose */
	30694	+ winRead, /* xRead */
	30695	+ winWrite, /* xWrite */
	30696	+ winTruncate, /* xTruncate */
	30697	+ winSync, /* xSync */
	30698	+ winFileSize, /* xFileSize */
	30699	+ winLock, /* xLock */
	30700	+ winUnlock, /* xUnlock */
	30701	+ winCheckReservedLock, /* xCheckReservedLock */
	30702	+ winFileControl, /* xFileControl */
	30703	+ winSectorSize, /* xSectorSize */
	30704	+ winDeviceCharacteristics, /* xDeviceCharacteristics */
	30705	+ winShmMap, /* xShmMap */
	30706	+ winShmLock, /* xShmLock */
	30707	+ winShmBarrier, /* xShmBarrier */
	30708	+ winShmUnmap /* xShmUnmap */
30516	30709	};
30517	30710
30518		-/***************************************************************************
30519		-** Here ends the I/O methods that form the sqlite3_io_methods object.
	30711	+/****************************************************************************
	30712	+************************** sqlite3_vfs methods **************************
30520	30713	**
30521		-** The next block of code implements the VFS methods.
30522		-****************************************************************************/
	30714	+** This division contains the implementation of methods on the
	30715	+** sqlite3_vfs object.
	30716	+*/
30523	30717
30524	30718	/*
30525	30719	** Convert a UTF-8 filename into whatever form the underlying
30526	30720	** operating system wants filenames in. Space to hold the result
30527	30721	** is obtained from malloc and must be freed by the calling
		@@ -30788,10 +30982,11 @@
30788	30982	}
30789	30983	OSTRACE(("OPEN %d %s 0x%lx %s\n",
30790	30984	h, zName, dwDesiredAccess,
30791	30985	h==INVALID_HANDLE_VALUE ? "failed" : "ok"));
30792	30986	if( h==INVALID_HANDLE_VALUE ){
	30987	+ pFile->lastErrno = GetLastError();
30793	30988	free(zConverted);
30794	30989	if( flags & SQLITE_OPEN_READWRITE ){
30795	30990	return winOpen(pVfs, zName, id,
30796	30991	((flags\|SQLITE_OPEN_READONLY)&~SQLITE_OPEN_READWRITE), pOutFlags);
30797	30992	}else{
		@@ -39553,16 +39748,15 @@
39553	39748	\|\| eMode==PAGER_JOURNALMODE_PERSIST
39554	39749	\|\| eMode==PAGER_JOURNALMODE_OFF
39555	39750	\|\| eMode==PAGER_JOURNALMODE_WAL
39556	39751	\|\| eMode==PAGER_JOURNALMODE_MEMORY );
39557	39752
39558		- /* Do not allow the journalmode of a TEMP database to be changed to WAL
	39753	+ /* This routine is only called from the OP_JournalMode opcode, and
	39754	+ ** the logic there will never allow a temporary file to be changed
	39755	+ ** to WAL mode.
39559	39756	*/
39560		- if( pPager->tempFile && eMode==PAGER_JOURNALMODE_WAL ){
39561		- assert( eOld!=PAGER_JOURNALMODE_WAL );
39562		- eMode = eOld;
39563		- }
	39757	+ assert( pPager->tempFile==0 \|\| eMode!=PAGER_JOURNALMODE_WAL );
39564	39758
39565	39759	/* Do allow the journalmode of an in-memory database to be set to
39566	39760	** anything other than MEMORY or OFF
39567	39761	*/
39568	39762	if( MEMDB ){
		@@ -39697,11 +39891,11 @@
39697	39891	** Return true if the underlying VFS for the given pager supports the
39698	39892	** primitives necessary for write-ahead logging.
39699	39893	*/
39700	39894	SQLITE_PRIVATE int sqlite3PagerWalSupported(Pager *pPager){
39701	39895	const sqlite3_io_methods *pMethods = pPager->fd->pMethods;
39702		- return pMethods->iVersion>=2 && pMethods->xShmOpen!=0;
	39896	+ return pMethods->iVersion>=2 && pMethods->xShmMap!=0;
39703	39897	}
39704	39898
39705	39899	/*
39706	39900	** The caller must be holding a SHARED lock on the database file to call
39707	39901	** this function.
		@@ -40229,13 +40423,13 @@
40229	40423	int nWiData; /* Size of array apWiData */
40230	40424	volatile u32 *apWiData; / Pointer to wal-index content in memory */
40231	40425	u16 szPage; /* Database page size */
40232	40426	i16 readLock; /* Which read lock is being held. -1 for none */
40233	40427	u8 exclusiveMode; /* Non-zero if connection is in exclusive mode */
40234		- u8 isWIndexOpen; /* True if ShmOpen() called on pDbFd */
40235	40428	u8 writeLock; /* True if in a write transaction */
40236	40429	u8 ckptLock; /* True if holding a checkpoint lock */
	40430	+ u8 readOnly; /* True if the WAL file is open read-only */
40237	40431	WalIndexHdr hdr; /* Wal-index header for current transaction */
40238	40432	const char zWalName; / Name of WAL file */
40239	40433	u32 nCkpt; /* Checkpoint sequence counter in the wal-header */
40240	40434	#ifdef SQLITE_DEBUG
40241	40435	u8 lockError; /* True if a locking error has occurred */
		@@ -40311,18 +40505,19 @@
40311	40505	static int walIndexPage(Wal pWal, int iPage, volatile u32 *ppPage){
40312	40506	int rc = SQLITE_OK;
40313	40507
40314	40508	/* Enlarge the pWal->apWiData[] array if required */
40315	40509	if( pWal->nWiData<=iPage ){
40316		- int nByte = sizeof(u32 )(iPage+1);
	40510	+ int nByte = sizeof(u32)(iPage+1);
40317	40511	volatile u32 **apNew;
40318	40512	apNew = (volatile u32 *)sqlite3_realloc((void )pWal->apWiData, nByte);
40319	40513	if( !apNew ){
40320	40514	*ppPage = 0;
40321	40515	return SQLITE_NOMEM;
40322	40516	}
40323		- memset((void )&apNew[pWal->nWiData], 0, sizeof(u32 )*(iPage+1-pWal->nWiData));
	40517	+ memset((void*)&apNew[pWal->nWiData], 0,
	40518	+ sizeof(u32)(iPage+1-pWal->nWiData));
40324	40519	pWal->apWiData = apNew;
40325	40520	pWal->nWiData = iPage+1;
40326	40521	}
40327	40522
40328	40523	/* Request a pointer to the required page from the VFS */
		@@ -40494,13 +40689,14 @@
40494	40689	pgno = sqlite3Get4byte(&aFrame[0]);
40495	40690	if( pgno==0 ){
40496	40691	return 0;
40497	40692	}
40498	40693
40499		- /* A frame is only valid if a checksum of the first 16 bytes
40500		- ** of the frame-header, and the frame-data matches
40501		- ** the checksum in the last 8 bytes of the frame-header.
	40694	+ /* A frame is only valid if a checksum of the WAL header,
	40695	+ ** all prior frams, the first 16 bytes of this frame-header,
	40696	+ ** and the frame-data matches the checksum in the last 8
	40697	+ ** bytes of this frame-header.
40502	40698	*/
40503	40699	nativeCksum = (pWal->hdr.bigEndCksum==SQLITE_BIGENDIAN);
40504	40700	walChecksumBytes(nativeCksum, aFrame, 8, aCksum, aCksum);
40505	40701	walChecksumBytes(nativeCksum, aData, pWal->szPage, aCksum, aCksum);
40506	40702	if( aCksum[0]!=sqlite3Get4byte(&aFrame[16])
		@@ -40756,11 +40952,11 @@
40756	40952	** page number array and hash table entry.
40757	40953	*/
40758	40954	if( rc==SQLITE_OK ){
40759	40955	int iKey; /* Hash table key */
40760	40956	int idx; /* Value to write to hash-table slot */
40761		- TESTONLY( int nCollide = 0; /* Number of hash collisions */ )
	40957	+ int nCollide; /* Number of hash collisions */
40762	40958
40763	40959	idx = iFrame - iZero;
40764	40960	assert( idx <= HASHTABLE_NSLOT/2 + 1 );
40765	40961
40766	40962	/* If this is the first entry to be added to this hash-table, zero the
		@@ -40781,12 +40977,13 @@
40781	40977	walCleanupHash(pWal);
40782	40978	assert( !aPgno[idx] );
40783	40979	}
40784	40980
40785	40981	/* Write the aPgno[] array entry and the hash-table slot. */
	40982	+ nCollide = idx;
40786	40983	for(iKey=walHash(iPage); aHash[iKey]; iKey=walNextHash(iKey)){
40787		- assert( nCollide++ < idx );
	40984	+ if( (nCollide--)==0 ) return SQLITE_CORRUPT_BKPT;
40788	40985	}
40789	40986	aPgno[idx] = iPage;
40790	40987	aHash[iKey] = (ht_slot)idx;
40791	40988
40792	40989	#ifdef SQLITE_ENABLE_EXPENSIVE_ASSERT
		@@ -40981,14 +41178,11 @@
40981	41178
40982	41179	/*
40983	41180	** Close an open wal-index.
40984	41181	*/
40985	41182	static void walIndexClose(Wal *pWal, int isDelete){
40986		- if( pWal->isWIndexOpen ){
40987		- sqlite3OsShmClose(pWal->pDbFd, isDelete);
40988		- pWal->isWIndexOpen = 0;
40989		- }
	41183	+ sqlite3OsShmUnmap(pWal->pDbFd, isDelete);
40990	41184	}
40991	41185
40992	41186	/*
40993	41187	** Open a connection to the WAL file zWalName. The database file must
40994	41188	** already be opened on connection pDbFd. The buffer that zWalName points
		@@ -41039,17 +41233,16 @@
41039	41233	pRet->pVfs = pVfs;
41040	41234	pRet->pWalFd = (sqlite3_file *)&pRet[1];
41041	41235	pRet->pDbFd = pDbFd;
41042	41236	pRet->readLock = -1;
41043	41237	pRet->zWalName = zWalName;
41044		- rc = sqlite3OsShmOpen(pDbFd);
41045	41238
41046	41239	/* Open file handle on the write-ahead log file. */
41047		- if( rc==SQLITE_OK ){
41048		- pRet->isWIndexOpen = 1;
41049		- flags = (SQLITE_OPEN_READWRITE\|SQLITE_OPEN_CREATE\|SQLITE_OPEN_MAIN_JOURNAL);
41050		- rc = sqlite3OsOpen(pVfs, zWalName, pRet->pWalFd, flags, &flags);
	41240	+ flags = (SQLITE_OPEN_READWRITE\|SQLITE_OPEN_CREATE\|SQLITE_OPEN_WAL);
	41241	+ rc = sqlite3OsOpen(pVfs, zWalName, pRet->pWalFd, flags, &flags);
	41242	+ if( rc==SQLITE_OK && flags&SQLITE_OPEN_READONLY ){
	41243	+ pRet->readOnly = 1;
41051	41244	}
41052	41245
41053	41246	if( rc!=SQLITE_OK ){
41054	41247	walIndexClose(pRet, 0);
41055	41248	sqlite3OsClose(pRet->pWalFd);
		@@ -41268,11 +41461,15 @@
41268	41461	int j; /* Counter variable */
41269	41462	int nEntry; /* Number of entries in this segment */
41270	41463	ht_slot aIndex; / Sorted index for this segment */
41271	41464
41272	41465	aPgno++;
41273		- nEntry = (int)(((i+1)==nSegment)?(int)(iLast-iZero):(u32 )aHash-(u32 )aPgno);
	41466	+ if( (i+1)==nSegment ){
	41467	+ nEntry = (int)(iLast - iZero);
	41468	+ }else{
	41469	+ nEntry = (int)((u32)aHash - (u32)aPgno);
	41470	+ }
41274	41471	aIndex = &((ht_slot *)&p->aSegment[p->nSegment])[iZero];
41275	41472	iZero++;
41276	41473
41277	41474	for(j=0; j<nEntry; j++){
41278	41475	aIndex[j] = (ht_slot)j;
		@@ -41680,12 +41877,20 @@
41680	41877	** which might cause WAL_RETRY to be returned even if BUSY_RECOVERY
41681	41878	** would be technically correct. But the race is benign since with
41682	41879	** WAL_RETRY this routine will be called again and will probably be
41683	41880	** right on the second iteration.
41684	41881	*/
41685		- rc = walLockShared(pWal, WAL_RECOVER_LOCK);
41686		- if( rc==SQLITE_OK ){
	41882	+ if( pWal->apWiData[0]==0 ){
	41883	+ /* This branch is taken when the xShmMap() method returns SQLITE_BUSY.
	41884	+ ** We assume this is a transient condition, so return WAL_RETRY. The
	41885	+ ** xShmMap() implementation used by the default unix and win32 VFS
	41886	+ ** modules may return SQLITE_BUSY due to a race condition in the
	41887	+ ** code that determines whether or not the shared-memory region
	41888	+ ** must be zeroed before the requested page is returned.
	41889	+ */
	41890	+ rc = WAL_RETRY;
	41891	+ }else if( SQLITE_OK==(rc = walLockShared(pWal, WAL_RECOVER_LOCK)) ){
41687	41892	walUnlockShared(pWal, WAL_RECOVER_LOCK);
41688	41893	rc = WAL_RETRY;
41689	41894	}else if( rc==SQLITE_BUSY ){
41690	41895	rc = SQLITE_BUSY_RECOVERY;
41691	41896	}
		@@ -41905,22 +42110,27 @@
41905	42110	for(iHash=walFramePage(iLast); iHash>=0 && iRead==0; iHash--){
41906	42111	volatile ht_slot aHash; / Pointer to hash table */
41907	42112	volatile u32 aPgno; / Pointer to array of page numbers */
41908	42113	u32 iZero; /* Frame number corresponding to aPgno[0] */
41909	42114	int iKey; /* Hash slot index */
41910		- int rc;
	42115	+ int nCollide; /* Number of hash collisions remaining */
	42116	+ int rc; /* Error code */
41911	42117
41912	42118	rc = walHashGet(pWal, iHash, &aHash, &aPgno, &iZero);
41913	42119	if( rc!=SQLITE_OK ){
41914	42120	return rc;
41915	42121	}
	42122	+ nCollide = HASHTABLE_NSLOT;
41916	42123	for(iKey=walHash(pgno); aHash[iKey]; iKey=walNextHash(iKey)){
41917	42124	u32 iFrame = aHash[iKey] + iZero;
41918	42125	if( iFrame<=iLast && aPgno[aHash[iKey]]==pgno ){
41919	42126	assert( iFrame>iRead );
41920	42127	iRead = iFrame;
41921	42128	}
	42129	+ if( (nCollide--)==0 ){
	42130	+ return SQLITE_CORRUPT_BKPT;
	42131	+ }
41922	42132	}
41923	42133	}
41924	42134
41925	42135	#ifdef SQLITE_ENABLE_EXPENSIVE_ASSERT
41926	42136	/* If expensive assert() statements are available, do a linear search
		@@ -41980,10 +42190,14 @@
41980	42190	int rc;
41981	42191
41982	42192	/* Cannot start a write transaction without first holding a read
41983	42193	** transaction. */
41984	42194	assert( pWal->readLock>=0 );
	42195	+
	42196	+ if( pWal->readOnly ){
	42197	+ return SQLITE_READONLY;
	42198	+ }
41985	42199
41986	42200	/* Only one writer allowed at a time. Get the write lock. Return
41987	42201	** SQLITE_BUSY if unable.
41988	42202	*/
41989	42203	rc = walLockExclusive(pWal, WAL_WRITE_LOCK, 1);
		@@ -42008,12 +42222,14 @@
42008	42222	/*
42009	42223	** End a write transaction. The commit has already been done. This
42010	42224	** routine merely releases the lock.
42011	42225	*/
42012	42226	SQLITE_PRIVATE int sqlite3WalEndWriteTransaction(Wal *pWal){
42013		- walUnlockExclusive(pWal, WAL_WRITE_LOCK, 1);
42014		- pWal->writeLock = 0;
	42227	+ if( pWal->writeLock ){
	42228	+ walUnlockExclusive(pWal, WAL_WRITE_LOCK, 1);
	42229	+ pWal->writeLock = 0;
	42230	+ }
42015	42231	return SQLITE_OK;
42016	42232	}
42017	42233
42018	42234	/*
42019	42235	** If any data has been written (but not committed) to the log file, this
		@@ -63636,15 +63852,15 @@
63636	63852
63637	63853	#ifndef SQLITE_OMIT_WAL
63638	63854	u.cd.zFilename = sqlite3PagerFilename(u.cd.pPager);
63639	63855
63640	63856	/* Do not allow a transition to journal_mode=WAL for a database
63641		- ** in temporary storage or if the VFS does not support xShmOpen.
	63857	+ ** in temporary storage or if the VFS does not support shared memory
63642	63858	*/
63643	63859	if( u.cd.eNew==PAGER_JOURNALMODE_WAL
63644	63860	&& (u.cd.zFilename[0]==0 /* Temp file */
63645		- \|\| !sqlite3PagerWalSupported(u.cd.pPager)) /* No xShmOpen support */
	63861	+ \|\| !sqlite3PagerWalSupported(u.cd.pPager)) /* No shared-memory support */
63646	63862	){
63647	63863	u.cd.eNew = u.cd.eOld;
63648	63864	}
63649	63865
63650	63866	if( (u.cd.eNew!=u.cd.eOld)
		@@ -64882,15 +65098,14 @@
64882	65098	0, /* xUnlock */
64883	65099	0, /* xCheckReservedLock */
64884	65100	0, /* xFileControl */
64885	65101	0, /* xSectorSize */
64886	65102	0, /* xDeviceCharacteristics */
64887		- 0, /* xShmOpen */
	65103	+ 0, /* xShmMap */
64888	65104	0, /* xShmLock */
64889		- 0, /* xShmMap */
64890	65105	0, /* xShmBarrier */
64891		- 0 /* xShmClose */
	65106	+ 0 /* xShmUnmap */
64892	65107	};
64893	65108
64894	65109	/*
64895	65110	** Open a journal file.
64896	65111	*/
		@@ -65167,15 +65382,14 @@
65167	65382	0, /* xUnlock */
65168	65383	0, /* xCheckReservedLock */
65169	65384	0, /* xFileControl */
65170	65385	0, /* xSectorSize */
65171	65386	0, /* xDeviceCharacteristics */
65172		- 0, /* xShmOpen */
	65387	+ 0, /* xShmMap */
65173	65388	0, /* xShmLock */
65174		- 0, /* xShmMap */
65175	65389	0, /* xShmBarrier */
65176		- 0 /* xShmClose */
	65390	+ 0 /* xShmUnlock */
65177	65391	};
65178	65392
65179	65393	/*
65180	65394	** Open a journal file.
65181	65395	*/
		@@ -68178,11 +68392,11 @@
68178	68392	pEList = pExpr->x.pSelect->pEList;
68179	68393	if( ALWAYS(pEList!=0 && pEList->nExpr>0) ){
68180	68394	keyInfo.aColl[0] = sqlite3BinaryCompareCollSeq(pParse, pExpr->pLeft,
68181	68395	pEList->a[0].pExpr);
68182	68396	}
68183		- }else if( pExpr->x.pList!=0 ){
	68397	+ }else if( ALWAYS(pExpr->x.pList!=0) ){
68184	68398	/* Case 2: expr IN (exprlist)
68185	68399	**
68186	68400	** For each expression, build an index key from the evaluation and
68187	68401	** store it in the temporary table. If <expr> is a column, then use
68188	68402	** that columns affinity when building index keys. If <expr> is not
		@@ -68248,11 +68462,10 @@
68248	68462	** value of this select in a memory cell and record the number
68249	68463	** of the memory cell in iColumn. If this is an EXISTS, write
68250	68464	** an integer 0 (not exists) or 1 (exists) into a memory cell
68251	68465	** and record that memory cell in iColumn.
68252	68466	*/
68253		- static const Token one = { "1", 1 }; /* Token for literal value 1 */
68254	68467	Select pSel; / SELECT statement to encode */
68255	68468	SelectDest dest; /* How to deal with SELECt result */
68256	68469
68257	68470	testcase( pExpr->op==TK_EXISTS );
68258	68471	testcase( pExpr->op==TK_SELECT );
		@@ -68269,11 +68482,12 @@
68269	68482	dest.eDest = SRT_Exists;
68270	68483	sqlite3VdbeAddOp2(v, OP_Integer, 0, dest.iParm);
68271	68484	VdbeComment((v, "Init EXISTS result"));
68272	68485	}
68273	68486	sqlite3ExprDelete(pParse->db, pSel->pLimit);
68274		- pSel->pLimit = sqlite3PExpr(pParse, TK_INTEGER, 0, 0, &one);
	68487	+ pSel->pLimit = sqlite3PExpr(pParse, TK_INTEGER, 0, 0,
	68488	+ &sqlite3IntTokens[1]);
68275	68489	if( sqlite3Select(pParse, pSel, &dest) ){
68276	68490	return 0;
68277	68491	}
68278	68492	rReg = dest.iParm;
68279	68493	ExprSetIrreducible(pExpr);
		@@ -68337,12 +68551,24 @@
68337	68551	/* Code the LHS, the <expr> from "<expr> IN (...)".
68338	68552	*/
68339	68553	sqlite3ExprCachePush(pParse);
68340	68554	r1 = sqlite3GetTempReg(pParse);
68341	68555	sqlite3ExprCode(pParse, pExpr->pLeft, r1);
68342		- sqlite3VdbeAddOp2(v, OP_IsNull, r1, destIfNull);
68343	68556
	68557	+ /* If the LHS is NULL, then the result is either false or NULL depending
	68558	+ ** on whether the RHS is empty or not, respectively.
	68559	+ */
	68560	+ if( destIfNull==destIfFalse ){
	68561	+ /* Shortcut for the common case where the false and NULL outcomes are
	68562	+ ** the same. */
	68563	+ sqlite3VdbeAddOp2(v, OP_IsNull, r1, destIfNull);
	68564	+ }else{
	68565	+ int addr1 = sqlite3VdbeAddOp1(v, OP_NotNull, r1);
	68566	+ sqlite3VdbeAddOp2(v, OP_Rewind, pExpr->iTable, destIfFalse);
	68567	+ sqlite3VdbeAddOp2(v, OP_Goto, 0, destIfNull);
	68568	+ sqlite3VdbeJumpHere(v, addr1);
	68569	+ }
68344	68570
68345	68571	if( eType==IN_INDEX_ROWID ){
68346	68572	/* In this case, the RHS is the ROWID of table b-tree
68347	68573	*/
68348	68574	sqlite3VdbeAddOp2(v, OP_MustBeInt, r1, destIfFalse);
		@@ -95669,11 +95895,11 @@
95669	95895	Expr *pExpr = pTerm->pExpr;
95670	95896	wsFlags \|= WHERE_COLUMN_IN;
95671	95897	if( ExprHasProperty(pExpr, EP_xIsSelect) ){
95672	95898	nInMul *= 25;
95673	95899	bInEst = 1;
95674		- }else if( pExpr->x.pList ){
	95900	+ }else if( ALWAYS(pExpr->x.pList) ){
95675	95901	nInMul *= pExpr->x.pList->nExpr + 1;
95676	95902	}
95677	95903	}else if( pTerm->eOperator & WO_ISNULL ){
95678	95904	wsFlags \|= WHERE_COLUMN_NULL;
95679	95905	}
		@@ -97713,40 +97939,40 @@
97713	97939	** YYNRULE the number of rules in the grammar
97714	97940	** YYERRORSYMBOL is the code number of the error symbol. If not
97715	97941	** defined, then do no error processing.
97716	97942	*/
97717	97943	#define YYCODETYPE unsigned char
97718		-#define YYNOCODE 254
	97944	+#define YYNOCODE 253
97719	97945	#define YYACTIONTYPE unsigned short int
97720	97946	#define YYWILDCARD 67
97721	97947	#define sqlite3ParserTOKENTYPE Token
97722	97948	typedef union {
97723	97949	int yyinit;
97724	97950	sqlite3ParserTOKENTYPE yy0;
97725		- Select* yy3;
97726		- ExprList* yy14;
97727		- SrcList* yy65;
97728		- struct LikeOp yy96;
97729		- Expr* yy132;
97730		- u8 yy186;
97731		- int yy328;
97732		- ExprSpan yy346;
97733		- struct TrigEvent yy378;
97734		- IdList* yy408;
97735		- struct {int value; int mask;} yy429;
97736		- TriggerStep* yy473;
97737		- struct LimitVal yy476;
	97951	+ int yy4;
	97952	+ struct TrigEvent yy90;
	97953	+ ExprSpan yy118;
	97954	+ TriggerStep* yy203;
	97955	+ u8 yy210;
	97956	+ struct {int value; int mask;} yy215;
	97957	+ SrcList* yy259;
	97958	+ struct LimitVal yy292;
	97959	+ Expr* yy314;
	97960	+ ExprList* yy322;
	97961	+ struct LikeOp yy342;
	97962	+ IdList* yy384;
	97963	+ Select* yy387;
97738	97964	} YYMINORTYPE;
97739	97965	#ifndef YYSTACKDEPTH
97740	97966	#define YYSTACKDEPTH 100
97741	97967	#endif
97742	97968	#define sqlite3ParserARG_SDECL Parse *pParse;
97743	97969	#define sqlite3ParserARG_PDECL ,Parse *pParse
97744	97970	#define sqlite3ParserARG_FETCH Parse *pParse = yypParser->pParse
97745	97971	#define sqlite3ParserARG_STORE yypParser->pParse = pParse
97746		-#define YYNSTATE 631
97747		-#define YYNRULE 330
	97972	+#define YYNSTATE 630
	97973	+#define YYNRULE 329
97748	97974	#define YYFALLBACK 1
97749	97975	#define YY_NO_ACTION (YYNSTATE+YYNRULE+2)
97750	97976	#define YY_ACCEPT_ACTION (YYNSTATE+YYNRULE+1)
97751	97977	#define YY_ERROR_ACTION (YYNSTATE+YYNRULE)
97752	97978
		@@ -97812,476 +98038,477 @@
97812	98038	** shifting terminals.
97813	98039	** yy_reduce_ofst[] For each state, the offset into yy_action for
97814	98040	** shifting non-terminals after a reduce.
97815	98041	** yy_default[] Default action for each state.
97816	98042	*/
97817		-#define YY_ACTTAB_COUNT (1550)
	98043	+#define YY_ACTTAB_COUNT (1557)
97818	98044	static const YYACTIONTYPE yy_action[] = {
97819		- /* 0 */ 313, 49, 556, 46, 147, 172, 628, 598, 55, 55,
97820		- /* 10 */ 55, 55, 302, 53, 53, 53, 53, 52, 52, 51,
97821		- /* 20 */ 51, 51, 50, 238, 603, 66, 624, 623, 604, 598,
97822		- /* 30 */ 591, 585, 48, 53, 53, 53, 53, 52, 52, 51,
97823		- /* 40 */ 51, 51, 50, 238, 51, 51, 51, 50, 238, 56,
97824		- /* 50 */ 57, 47, 583, 582, 584, 584, 54, 54, 55, 55,
97825		- /* 60 */ 55, 55, 609, 53, 53, 53, 53, 52, 52, 51,
97826		- /* 70 */ 51, 51, 50, 238, 313, 598, 672, 330, 411, 217,
	98045	+ /* 0 */ 313, 960, 186, 419, 2, 172, 627, 597, 55, 55,
	98046	+ /* 10 */ 55, 55, 48, 53, 53, 53, 53, 52, 52, 51,
	98047	+ /* 20 */ 51, 51, 50, 238, 302, 283, 623, 622, 516, 515,
	98048	+ /* 30 */ 590, 584, 55, 55, 55, 55, 282, 53, 53, 53,
	98049	+ /* 40 */ 53, 52, 52, 51, 51, 51, 50, 238, 6, 56,
	98050	+ /* 50 */ 57, 47, 582, 581, 583, 583, 54, 54, 55, 55,
	98051	+ /* 60 */ 55, 55, 608, 53, 53, 53, 53, 52, 52, 51,
	98052	+ /* 70 */ 51, 51, 50, 238, 313, 597, 409, 330, 579, 579,
97827	98053	/* 80 */ 32, 53, 53, 53, 53, 52, 52, 51, 51, 51,
97828		- /* 90 */ 50, 238, 330, 414, 621, 620, 166, 598, 673, 382,
97829		- /* 100 */ 379, 378, 602, 73, 591, 585, 307, 424, 166, 58,
97830		- /* 110 */ 377, 382, 379, 378, 516, 515, 624, 623, 254, 200,
97831		- /* 120 */ 199, 198, 377, 56, 57, 47, 583, 582, 584, 584,
97832		- /* 130 */ 54, 54, 55, 55, 55, 55, 581, 53, 53, 53,
97833		- /* 140 */ 53, 52, 52, 51, 51, 51, 50, 238, 313, 270,
97834		- /* 150 */ 226, 422, 283, 133, 177, 139, 284, 385, 279, 384,
97835		- /* 160 */ 169, 197, 251, 282, 253, 226, 411, 275, 440, 167,
97836		- /* 170 */ 139, 284, 385, 279, 384, 169, 571, 236, 591, 585,
97837		- /* 180 */ 240, 414, 275, 622, 621, 620, 674, 437, 441, 442,
97838		- /* 190 */ 602, 88, 352, 266, 439, 268, 438, 56, 57, 47,
97839		- /* 200 */ 583, 582, 584, 584, 54, 54, 55, 55, 55, 55,
	98054	+ /* 90 */ 50, 238, 330, 217, 620, 619, 166, 411, 624, 382,
	98055	+ /* 100 */ 379, 378, 7, 491, 590, 584, 200, 199, 198, 58,
	98056	+ /* 110 */ 377, 300, 414, 621, 481, 66, 623, 622, 621, 580,
	98057	+ /* 120 */ 254, 601, 94, 56, 57, 47, 582, 581, 583, 583,
	98058	+ /* 130 */ 54, 54, 55, 55, 55, 55, 671, 53, 53, 53,
	98059	+ /* 140 */ 53, 52, 52, 51, 51, 51, 50, 238, 313, 532,
	98060	+ /* 150 */ 226, 506, 507, 133, 177, 139, 284, 385, 279, 384,
	98061	+ /* 160 */ 169, 197, 342, 398, 251, 226, 253, 275, 388, 167,
	98062	+ /* 170 */ 139, 284, 385, 279, 384, 169, 570, 236, 590, 584,
	98063	+ /* 180 */ 672, 240, 275, 157, 620, 619, 554, 437, 51, 51,
	98064	+ /* 190 */ 51, 50, 238, 343, 439, 553, 438, 56, 57, 47,
	98065	+ /* 200 */ 582, 581, 583, 583, 54, 54, 55, 55, 55, 55,
97840	98066	/* 210 */ 465, 53, 53, 53, 53, 52, 52, 51, 51, 51,
97841		- /* 220 */ 50, 238, 313, 471, 52, 52, 51, 51, 51, 50,
97842		- /* 230 */ 238, 234, 166, 491, 567, 382, 379, 378, 1, 440,
97843		- /* 240 */ 252, 176, 624, 623, 608, 67, 377, 513, 622, 443,
97844		- /* 250 */ 237, 577, 591, 585, 622, 172, 466, 598, 554, 441,
97845		- /* 260 */ 340, 409, 526, 580, 580, 349, 596, 553, 194, 482,
97846		- /* 270 */ 175, 56, 57, 47, 583, 582, 584, 584, 54, 54,
97847		- /* 280 */ 55, 55, 55, 55, 562, 53, 53, 53, 53, 52,
97848		- /* 290 */ 52, 51, 51, 51, 50, 238, 313, 594, 594, 594,
97849		- /* 300 */ 561, 578, 469, 65, 259, 351, 258, 411, 624, 623,
97850		- /* 310 */ 621, 620, 332, 576, 575, 240, 560, 568, 520, 411,
97851		- /* 320 */ 341, 237, 414, 624, 623, 598, 591, 585, 542, 519,
97852		- /* 330 */ 171, 602, 95, 68, 414, 624, 623, 624, 623, 38,
97853		- /* 340 */ 877, 506, 507, 602, 88, 56, 57, 47, 583, 582,
97854		- /* 350 */ 584, 584, 54, 54, 55, 55, 55, 55, 532, 53,
	98067	+ /* 220 */ 50, 238, 313, 390, 52, 52, 51, 51, 51, 50,
	98068	+ /* 230 */ 238, 391, 166, 491, 566, 382, 379, 378, 409, 440,
	98069	+ /* 240 */ 579, 579, 252, 440, 607, 66, 377, 513, 621, 49,
	98070	+ /* 250 */ 46, 147, 590, 584, 621, 16, 466, 189, 621, 441,
	98071	+ /* 260 */ 442, 673, 526, 441, 340, 577, 595, 64, 194, 482,
	98072	+ /* 270 */ 434, 56, 57, 47, 582, 581, 583, 583, 54, 54,
	98073	+ /* 280 */ 55, 55, 55, 55, 30, 53, 53, 53, 53, 52,
	98074	+ /* 290 */ 52, 51, 51, 51, 50, 238, 313, 593, 593, 593,
	98075	+ /* 300 */ 387, 578, 606, 493, 259, 351, 258, 411, 1, 623,
	98076	+ /* 310 */ 622, 496, 623, 622, 65, 240, 623, 622, 597, 443,
	98077	+ /* 320 */ 237, 239, 414, 341, 237, 602, 590, 584, 18, 603,
	98078	+ /* 330 */ 166, 601, 87, 382, 379, 378, 67, 623, 622, 38,
	98079	+ /* 340 */ 623, 622, 176, 270, 377, 56, 57, 47, 582, 581,
	98080	+ /* 350 */ 583, 583, 54, 54, 55, 55, 55, 55, 175, 53,
97855	98081	/* 360 */ 53, 53, 53, 52, 52, 51, 51, 51, 50, 238,
97856		- /* 370 */ 313, 411, 579, 398, 531, 237, 621, 620, 388, 625,
97857		- /* 380 */ 500, 206, 167, 396, 233, 312, 414, 387, 569, 492,
97858		- /* 390 */ 216, 621, 620, 566, 622, 602, 74, 533, 210, 491,
97859		- /* 400 */ 591, 585, 548, 621, 620, 621, 620, 300, 598, 466,
97860		- /* 410 */ 481, 67, 603, 35, 622, 601, 604, 547, 6, 56,
97861		- /* 420 */ 57, 47, 583, 582, 584, 584, 54, 54, 55, 55,
97862		- /* 430 */ 55, 55, 601, 53, 53, 53, 53, 52, 52, 51,
97863		- /* 440 */ 51, 51, 50, 238, 313, 411, 184, 409, 528, 580,
97864		- /* 450 */ 580, 551, 962, 186, 419, 2, 353, 259, 351, 258,
97865		- /* 460 */ 414, 409, 411, 580, 580, 44, 411, 544, 240, 602,
97866		- /* 470 */ 94, 190, 7, 62, 591, 585, 598, 414, 350, 607,
97867		- /* 480 */ 493, 414, 409, 317, 580, 580, 602, 95, 496, 565,
97868		- /* 490 */ 602, 80, 203, 56, 57, 47, 583, 582, 584, 584,
97869		- /* 500 */ 54, 54, 55, 55, 55, 55, 535, 53, 53, 53,
97870		- /* 510 */ 53, 52, 52, 51, 51, 51, 50, 238, 313, 202,
97871		- /* 520 */ 564, 293, 511, 49, 562, 46, 147, 411, 394, 183,
97872		- /* 530 */ 563, 549, 505, 549, 174, 409, 322, 580, 580, 39,
97873		- /* 540 */ 561, 37, 414, 624, 623, 192, 473, 383, 591, 585,
97874		- /* 550 */ 474, 602, 80, 601, 504, 544, 560, 364, 402, 210,
97875		- /* 560 */ 421, 952, 361, 952, 365, 201, 144, 56, 57, 47,
97876		- /* 570 */ 583, 582, 584, 584, 54, 54, 55, 55, 55, 55,
97877		- /* 580 */ 559, 53, 53, 53, 53, 52, 52, 51, 51, 51,
97878		- /* 590 */ 50, 238, 313, 601, 232, 264, 272, 321, 374, 484,
97879		- /* 600 */ 510, 146, 342, 146, 328, 425, 485, 407, 576, 575,
97880		- /* 610 */ 622, 621, 620, 49, 168, 46, 147, 353, 546, 491,
97881		- /* 620 */ 204, 240, 591, 585, 421, 951, 549, 951, 549, 168,
97882		- /* 630 */ 429, 67, 390, 343, 622, 434, 307, 423, 338, 360,
97883		- /* 640 */ 391, 56, 57, 47, 583, 582, 584, 584, 54, 54,
97884		- /* 650 */ 55, 55, 55, 55, 601, 53, 53, 53, 53, 52,
97885		- /* 660 */ 52, 51, 51, 51, 50, 238, 313, 34, 318, 425,
97886		- /* 670 */ 237, 21, 359, 273, 411, 167, 411, 276, 411, 540,
97887		- /* 680 */ 411, 422, 13, 318, 619, 618, 617, 622, 275, 414,
97888		- /* 690 */ 336, 414, 622, 414, 622, 414, 591, 585, 602, 69,
97889		- /* 700 */ 602, 97, 602, 100, 602, 98, 631, 629, 334, 475,
97890		- /* 710 */ 475, 367, 319, 148, 327, 56, 57, 47, 583, 582,
97891		- /* 720 */ 584, 584, 54, 54, 55, 55, 55, 55, 411, 53,
	98082	+ /* 370 */ 313, 396, 233, 411, 531, 565, 317, 620, 619, 44,
	98083	+ /* 380 */ 620, 619, 240, 206, 620, 619, 597, 266, 414, 268,
	98084	+ /* 390 */ 409, 597, 579, 579, 352, 184, 505, 601, 73, 533,
	98085	+ /* 400 */ 590, 584, 466, 548, 190, 620, 619, 576, 620, 619,
	98086	+ /* 410 */ 547, 383, 551, 35, 332, 575, 574, 600, 504, 56,
	98087	+ /* 420 */ 57, 47, 582, 581, 583, 583, 54, 54, 55, 55,
	98088	+ /* 430 */ 55, 55, 567, 53, 53, 53, 53, 52, 52, 51,
	98089	+ /* 440 */ 51, 51, 50, 238, 313, 411, 561, 561, 528, 364,
	98090	+ /* 450 */ 259, 351, 258, 183, 361, 549, 524, 374, 411, 597,
	98091	+ /* 460 */ 414, 240, 560, 560, 409, 604, 579, 579, 328, 601,
	98092	+ /* 470 */ 93, 623, 622, 414, 590, 584, 237, 564, 559, 559,
	98093	+ /* 480 */ 520, 402, 601, 87, 409, 210, 579, 579, 168, 421,
	98094	+ /* 490 */ 950, 519, 950, 56, 57, 47, 582, 581, 583, 583,
	98095	+ /* 500 */ 54, 54, 55, 55, 55, 55, 192, 53, 53, 53,
	98096	+ /* 510 */ 53, 52, 52, 51, 51, 51, 50, 238, 313, 600,
	98097	+ /* 520 */ 293, 563, 511, 234, 357, 146, 475, 475, 367, 411,
	98098	+ /* 530 */ 562, 411, 358, 542, 425, 171, 411, 215, 144, 620,
	98099	+ /* 540 */ 619, 544, 318, 353, 414, 203, 414, 275, 590, 584,
	98100	+ /* 550 */ 549, 414, 174, 601, 94, 601, 79, 558, 471, 61,
	98101	+ /* 560 */ 601, 79, 421, 949, 350, 949, 34, 56, 57, 47,
	98102	+ /* 570 */ 582, 581, 583, 583, 54, 54, 55, 55, 55, 55,
	98103	+ /* 580 */ 535, 53, 53, 53, 53, 52, 52, 51, 51, 51,
	98104	+ /* 590 */ 50, 238, 313, 307, 424, 394, 272, 49, 46, 147,
	98105	+ /* 600 */ 349, 322, 4, 411, 491, 312, 321, 425, 568, 492,
	98106	+ /* 610 */ 216, 264, 407, 575, 574, 429, 66, 549, 414, 621,
	98107	+ /* 620 */ 540, 602, 590, 584, 13, 603, 621, 601, 72, 12,
	98108	+ /* 630 */ 618, 617, 616, 202, 210, 621, 546, 469, 422, 319,
	98109	+ /* 640 */ 148, 56, 57, 47, 582, 581, 583, 583, 54, 54,
	98110	+ /* 650 */ 55, 55, 55, 55, 338, 53, 53, 53, 53, 52,
	98111	+ /* 660 */ 52, 51, 51, 51, 50, 238, 313, 600, 600, 411,
	98112	+ /* 670 */ 39, 21, 37, 170, 237, 875, 411, 572, 572, 201,
	98113	+ /* 680 */ 144, 473, 538, 331, 414, 474, 143, 146, 630, 628,
	98114	+ /* 690 */ 334, 414, 353, 601, 68, 168, 590, 584, 132, 365,
	98115	+ /* 700 */ 601, 96, 307, 423, 530, 336, 49, 46, 147, 568,
	98116	+ /* 710 */ 406, 216, 549, 360, 529, 56, 57, 47, 582, 581,
	98117	+ /* 720 */ 583, 583, 54, 54, 55, 55, 55, 55, 411, 53,
97892	98118	/* 730 */ 53, 53, 53, 52, 52, 51, 51, 51, 50, 238,
97893		- /* 740 */ 313, 411, 331, 414, 411, 49, 276, 46, 147, 569,
97894		- /* 750 */ 406, 216, 602, 106, 573, 573, 414, 354, 524, 414,
97895		- /* 760 */ 411, 622, 411, 224, 4, 602, 104, 605, 602, 108,
97896		- /* 770 */ 591, 585, 622, 20, 375, 414, 167, 414, 215, 144,
97897		- /* 780 */ 470, 239, 167, 225, 602, 109, 602, 134, 18, 56,
97898		- /* 790 */ 57, 47, 583, 582, 584, 584, 54, 54, 55, 55,
	98119	+ /* 740 */ 313, 411, 605, 414, 484, 510, 172, 422, 597, 318,
	98120	+ /* 750 */ 496, 485, 601, 99, 411, 142, 414, 411, 231, 411,
	98121	+ /* 760 */ 540, 411, 359, 629, 2, 601, 97, 426, 308, 414,
	98122	+ /* 770 */ 590, 584, 414, 20, 414, 621, 414, 621, 601, 106,
	98123	+ /* 780 */ 503, 601, 105, 601, 108, 601, 109, 204, 28, 56,
	98124	+ /* 790 */ 57, 47, 582, 581, 583, 583, 54, 54, 55, 55,
97899	98125	/* 800 */ 55, 55, 411, 53, 53, 53, 53, 52, 52, 51,
97900		- /* 810 */ 51, 51, 50, 238, 313, 411, 276, 414, 12, 459,
97901		- /* 820 */ 276, 171, 411, 16, 223, 189, 602, 135, 354, 170,
97902		- /* 830 */ 414, 622, 630, 2, 411, 622, 540, 414, 143, 602,
97903		- /* 840 */ 61, 359, 132, 622, 591, 585, 602, 105, 458, 414,
97904		- /* 850 */ 23, 622, 446, 326, 23, 538, 622, 325, 602, 103,
97905		- /* 860 */ 427, 530, 309, 56, 57, 47, 583, 582, 584, 584,
	98126	+ /* 810 */ 51, 51, 50, 238, 313, 411, 597, 414, 411, 276,
	98127	+ /* 820 */ 214, 600, 411, 366, 213, 381, 601, 134, 274, 500,
	98128	+ /* 830 */ 414, 167, 130, 414, 621, 411, 354, 414, 376, 601,
	98129	+ /* 840 */ 135, 129, 601, 100, 590, 584, 601, 104, 522, 521,
	98130	+ /* 850 */ 414, 621, 224, 273, 600, 167, 327, 282, 600, 601,
	98131	+ /* 860 */ 103, 468, 521, 56, 57, 47, 582, 581, 583, 583,
97906	98132	/* 870 */ 54, 54, 55, 55, 55, 55, 411, 53, 53, 53,
97907	98133	/* 880 */ 53, 52, 52, 51, 51, 51, 50, 238, 313, 411,
97908		- /* 890 */ 264, 414, 411, 276, 359, 219, 157, 214, 357, 366,
97909		- /* 900 */ 602, 96, 522, 521, 414, 622, 358, 414, 622, 622,
97910		- /* 910 */ 411, 613, 612, 602, 102, 142, 602, 77, 591, 585,
97911		- /* 920 */ 529, 540, 231, 426, 308, 414, 622, 622, 468, 521,
97912		- /* 930 */ 324, 601, 257, 263, 602, 99, 622, 56, 45, 47,
97913		- /* 940 */ 583, 582, 584, 584, 54, 54, 55, 55, 55, 55,
	98134	+ /* 890 */ 27, 414, 411, 375, 276, 167, 359, 544, 50, 238,
	98135	+ /* 900 */ 601, 95, 128, 223, 414, 411, 165, 414, 411, 621,
	98136	+ /* 910 */ 411, 621, 612, 601, 102, 372, 601, 76, 590, 584,
	98137	+ /* 920 */ 414, 570, 236, 414, 470, 414, 167, 621, 188, 601,
	98138	+ /* 930 */ 98, 225, 601, 138, 601, 137, 232, 56, 45, 47,
	98139	+ /* 940 */ 582, 581, 583, 583, 54, 54, 55, 55, 55, 55,
97914	98140	/* 950 */ 411, 53, 53, 53, 53, 52, 52, 51, 51, 51,
97915		- /* 960 */ 50, 238, 313, 264, 264, 414, 411, 213, 209, 544,
97916		- /* 970 */ 544, 207, 611, 28, 602, 138, 50, 238, 622, 622,
97917		- /* 980 */ 381, 414, 503, 140, 323, 222, 274, 622, 590, 589,
97918		- /* 990 */ 602, 137, 591, 585, 629, 334, 606, 30, 622, 571,
97919		- /* 1000 */ 236, 601, 601, 130, 496, 601, 453, 451, 288, 286,
97920		- /* 1010 */ 587, 586, 57, 47, 583, 582, 584, 584, 54, 54,
	98141	+ /* 960 */ 50, 238, 313, 276, 276, 414, 411, 276, 544, 459,
	98142	+ /* 970 */ 359, 171, 209, 479, 601, 136, 628, 334, 621, 621,
	98143	+ /* 980 */ 125, 414, 621, 368, 411, 621, 257, 540, 589, 588,
	98144	+ /* 990 */ 601, 75, 590, 584, 458, 446, 23, 23, 124, 414,
	98145	+ /* 1000 */ 326, 325, 621, 427, 324, 309, 600, 288, 601, 92,
	98146	+ /* 1010 */ 586, 585, 57, 47, 582, 581, 583, 583, 54, 54,
97921	98147	/* 1020 */ 55, 55, 55, 55, 411, 53, 53, 53, 53, 52,
97922		- /* 1030 */ 52, 51, 51, 51, 50, 238, 313, 588, 411, 414,
97923		- /* 1040 */ 411, 264, 410, 129, 595, 400, 27, 376, 602, 136,
97924		- /* 1050 */ 128, 165, 479, 414, 282, 414, 622, 622, 411, 622,
97925		- /* 1060 */ 622, 411, 602, 76, 602, 93, 591, 585, 188, 372,
97926		- /* 1070 */ 368, 125, 476, 414, 261, 160, 414, 171, 124, 472,
97927		- /* 1080 */ 123, 15, 602, 92, 450, 602, 75, 47, 583, 582,
97928		- /* 1090 */ 584, 584, 54, 54, 55, 55, 55, 55, 464, 53,
	98148	+ /* 1030 */ 52, 51, 51, 51, 50, 238, 313, 587, 411, 414,
	98149	+ /* 1040 */ 411, 207, 611, 476, 171, 472, 160, 123, 601, 91,
	98150	+ /* 1050 */ 323, 261, 15, 414, 464, 414, 411, 621, 411, 354,
	98151	+ /* 1060 */ 222, 411, 601, 74, 601, 90, 590, 584, 159, 264,
	98152	+ /* 1070 */ 158, 414, 461, 414, 621, 600, 414, 121, 120, 25,
	98153	+ /* 1080 */ 601, 89, 601, 101, 621, 601, 88, 47, 582, 581,
	98154	+ /* 1090 */ 583, 583, 54, 54, 55, 55, 55, 55, 544, 53,
97929	98155	/* 1100 */ 53, 53, 53, 52, 52, 51, 51, 51, 50, 238,
97930		- /* 1110 */ 43, 405, 264, 3, 558, 264, 545, 415, 623, 159,
97931		- /* 1120 */ 541, 158, 539, 278, 25, 461, 121, 622, 408, 622,
97932		- /* 1130 */ 622, 622, 24, 43, 405, 622, 3, 622, 622, 120,
97933		- /* 1140 */ 415, 623, 11, 456, 411, 156, 452, 403, 509, 277,
97934		- /* 1150 */ 118, 408, 489, 113, 205, 449, 271, 567, 221, 414,
97935		- /* 1160 */ 269, 267, 155, 622, 622, 111, 411, 622, 602, 95,
97936		- /* 1170 */ 403, 622, 411, 110, 10, 622, 622, 40, 41, 534,
97937		- /* 1180 */ 567, 414, 64, 264, 42, 413, 412, 414, 601, 596,
97938		- /* 1190 */ 602, 91, 445, 436, 150, 435, 602, 90, 622, 265,
97939		- /* 1200 */ 40, 41, 337, 242, 411, 191, 333, 42, 413, 412,
97940		- /* 1210 */ 398, 420, 596, 316, 622, 399, 260, 107, 230, 414,
97941		- /* 1220 */ 594, 594, 594, 593, 592, 14, 220, 411, 602, 101,
97942		- /* 1230 */ 240, 622, 43, 405, 362, 3, 149, 315, 626, 415,
97943		- /* 1240 */ 623, 127, 414, 594, 594, 594, 593, 592, 14, 622,
97944		- /* 1250 */ 408, 602, 89, 411, 181, 33, 405, 463, 3, 411,
97945		- /* 1260 */ 264, 462, 415, 623, 616, 615, 614, 355, 414, 403,
97946		- /* 1270 */ 417, 416, 622, 408, 414, 622, 622, 602, 87, 567,
97947		- /* 1280 */ 418, 627, 622, 602, 86, 8, 241, 180, 126, 255,
97948		- /* 1290 */ 600, 178, 403, 240, 208, 455, 395, 294, 444, 40,
97949		- /* 1300 */ 41, 297, 567, 248, 622, 296, 42, 413, 412, 247,
97950		- /* 1310 */ 622, 596, 244, 622, 30, 60, 31, 243, 430, 624,
97951		- /* 1320 */ 623, 292, 40, 41, 622, 295, 145, 622, 601, 42,
97952		- /* 1330 */ 413, 412, 622, 622, 596, 393, 622, 397, 599, 59,
97953		- /* 1340 */ 235, 622, 594, 594, 594, 593, 592, 14, 218, 291,
97954		- /* 1350 */ 622, 36, 344, 305, 304, 303, 179, 301, 411, 567,
97955		- /* 1360 */ 454, 557, 173, 185, 622, 594, 594, 594, 593, 592,
97956		- /* 1370 */ 14, 411, 29, 414, 151, 289, 246, 523, 411, 196,
97957		- /* 1380 */ 195, 335, 602, 85, 411, 245, 414, 526, 392, 543,
97958		- /* 1390 */ 411, 596, 287, 414, 285, 602, 72, 537, 153, 414,
97959		- /* 1400 */ 466, 411, 602, 71, 154, 414, 411, 152, 602, 84,
97960		- /* 1410 */ 386, 536, 329, 411, 602, 83, 414, 518, 280, 411,
97961		- /* 1420 */ 513, 414, 594, 594, 594, 602, 82, 517, 414, 311,
97962		- /* 1430 */ 602, 81, 411, 514, 414, 512, 131, 602, 70, 229,
97963		- /* 1440 */ 228, 227, 494, 602, 17, 411, 488, 414, 259, 346,
97964		- /* 1450 */ 249, 389, 487, 486, 314, 164, 602, 79, 310, 240,
97965		- /* 1460 */ 414, 373, 480, 163, 262, 371, 414, 162, 369, 602,
97966		- /* 1470 */ 78, 212, 478, 26, 477, 602, 9, 161, 467, 363,
97967		- /* 1480 */ 141, 122, 339, 187, 119, 457, 348, 347, 117, 116,
97968		- /* 1490 */ 115, 112, 114, 448, 182, 22, 320, 433, 432, 431,
97969		- /* 1500 */ 19, 428, 610, 597, 574, 193, 572, 63, 298, 404,
97970		- /* 1510 */ 555, 552, 290, 281, 510, 460, 498, 499, 495, 447,
97971		- /* 1520 */ 356, 497, 256, 380, 306, 570, 5, 250, 345, 238,
97972		- /* 1530 */ 299, 550, 527, 490, 508, 525, 502, 401, 501, 963,
97973		- /* 1540 */ 211, 963, 483, 963, 963, 963, 963, 963, 963, 370,
	98156	+ /* 1110 */ 43, 405, 263, 3, 610, 264, 140, 415, 622, 24,
	98157	+ /* 1120 */ 410, 11, 456, 594, 118, 155, 219, 452, 408, 621,
	98158	+ /* 1130 */ 621, 621, 156, 43, 405, 621, 3, 286, 621, 113,
	98159	+ /* 1140 */ 415, 622, 111, 445, 411, 400, 557, 403, 545, 10,
	98160	+ /* 1150 */ 411, 408, 264, 110, 205, 436, 541, 566, 453, 414,
	98161	+ /* 1160 */ 621, 621, 63, 621, 435, 414, 411, 621, 601, 94,
	98162	+ /* 1170 */ 403, 621, 411, 337, 601, 86, 150, 40, 41, 534,
	98163	+ /* 1180 */ 566, 414, 242, 264, 42, 413, 412, 414, 600, 595,
	98164	+ /* 1190 */ 601, 85, 191, 333, 107, 451, 601, 84, 621, 539,
	98165	+ /* 1200 */ 40, 41, 420, 230, 411, 149, 316, 42, 413, 412,
	98166	+ /* 1210 */ 398, 127, 595, 315, 621, 399, 278, 625, 181, 414,
	98167	+ /* 1220 */ 593, 593, 593, 592, 591, 14, 450, 411, 601, 71,
	98168	+ /* 1230 */ 240, 621, 43, 405, 264, 3, 615, 180, 264, 415,
	98169	+ /* 1240 */ 622, 614, 414, 593, 593, 593, 592, 591, 14, 621,
	98170	+ /* 1250 */ 408, 601, 70, 621, 417, 33, 405, 613, 3, 411,
	98171	+ /* 1260 */ 264, 411, 415, 622, 418, 626, 178, 509, 8, 403,
	98172	+ /* 1270 */ 241, 416, 126, 408, 414, 621, 414, 449, 208, 566,
	98173	+ /* 1280 */ 240, 221, 621, 601, 83, 601, 82, 599, 297, 277,
	98174	+ /* 1290 */ 296, 30, 403, 31, 395, 264, 295, 397, 489, 40,
	98175	+ /* 1300 */ 41, 411, 566, 220, 621, 294, 42, 413, 412, 271,
	98176	+ /* 1310 */ 621, 595, 600, 621, 59, 60, 414, 269, 267, 623,
	98177	+ /* 1320 */ 622, 36, 40, 41, 621, 601, 81, 598, 235, 42,
	98178	+ /* 1330 */ 413, 412, 621, 621, 595, 265, 344, 411, 248, 556,
	98179	+ /* 1340 */ 173, 185, 593, 593, 593, 592, 591, 14, 218, 29,
	98180	+ /* 1350 */ 621, 543, 414, 305, 304, 303, 179, 301, 411, 566,
	98181	+ /* 1360 */ 454, 601, 80, 289, 335, 593, 593, 593, 592, 591,
	98182	+ /* 1370 */ 14, 411, 287, 414, 151, 392, 246, 260, 411, 196,
	98183	+ /* 1380 */ 195, 523, 601, 69, 411, 245, 414, 526, 537, 285,
	98184	+ /* 1390 */ 389, 595, 621, 414, 536, 601, 17, 362, 153, 414,
	98185	+ /* 1400 */ 466, 463, 601, 78, 154, 414, 462, 152, 601, 77,
	98186	+ /* 1410 */ 355, 255, 621, 455, 601, 9, 621, 386, 444, 517,
	98187	+ /* 1420 */ 247, 621, 593, 593, 593, 621, 621, 244, 621, 243,
	98188	+ /* 1430 */ 430, 518, 292, 621, 329, 621, 145, 393, 280, 513,
	98189	+ /* 1440 */ 291, 131, 621, 514, 621, 621, 311, 621, 259, 346,
	98190	+ /* 1450 */ 249, 621, 621, 229, 314, 621, 228, 512, 227, 240,
	98191	+ /* 1460 */ 494, 488, 310, 164, 487, 486, 373, 480, 163, 262,
	98192	+ /* 1470 */ 369, 371, 162, 26, 212, 478, 477, 161, 141, 363,
	98193	+ /* 1480 */ 467, 122, 339, 187, 119, 348, 347, 117, 116, 115,
	98194	+ /* 1490 */ 114, 112, 182, 457, 320, 22, 433, 432, 448, 19,
	98195	+ /* 1500 */ 609, 431, 428, 62, 193, 596, 573, 298, 555, 552,
	98196	+ /* 1510 */ 571, 404, 290, 380, 498, 510, 495, 306, 281, 499,
	98197	+ /* 1520 */ 250, 5, 497, 460, 345, 447, 569, 550, 238, 299,
	98198	+ /* 1530 */ 527, 525, 508, 961, 502, 501, 961, 401, 961, 211,
	98199	+ /* 1540 */ 490, 356, 256, 961, 483, 961, 961, 961, 961, 961,
	98200	+ /* 1550 */ 961, 961, 961, 961, 961, 961, 370,
97974	98201	};
97975	98202	static const YYCODETYPE yy_lookahead[] = {
97976		- /* 0 */ 19, 222, 223, 224, 225, 24, 1, 26, 77, 78,
97977		- /* 10 */ 79, 80, 15, 82, 83, 84, 85, 86, 87, 88,
97978		- /* 20 */ 89, 90, 91, 92, 113, 22, 26, 27, 117, 26,
97979		- /* 30 */ 49, 50, 81, 82, 83, 84, 85, 86, 87, 88,
97980		- /* 40 */ 89, 90, 91, 92, 88, 89, 90, 91, 92, 68,
	98203	+ /* 0 */ 19, 142, 143, 144, 145, 24, 1, 26, 77, 78,
	98204	+ /* 10 */ 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
	98205	+ /* 20 */ 89, 90, 91, 92, 15, 98, 26, 27, 7, 8,
	98206	+ /* 30 */ 49, 50, 77, 78, 79, 80, 109, 82, 83, 84,
	98207	+ /* 40 */ 85, 86, 87, 88, 89, 90, 91, 92, 22, 68,
97981	98208	/* 50 */ 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
97982	98209	/* 60 */ 79, 80, 23, 82, 83, 84, 85, 86, 87, 88,
97983		- /* 70 */ 89, 90, 91, 92, 19, 94, 118, 19, 150, 22,
	98210	+ /* 70 */ 89, 90, 91, 92, 19, 94, 112, 19, 114, 115,
97984	98211	/* 80 */ 25, 82, 83, 84, 85, 86, 87, 88, 89, 90,
97985		- /* 90 */ 91, 92, 19, 165, 94, 95, 96, 94, 118, 99,
97986		- /* 100 */ 100, 101, 174, 175, 49, 50, 22, 23, 96, 54,
97987		- /* 110 */ 110, 99, 100, 101, 7, 8, 26, 27, 16, 105,
97988		- /* 120 */ 106, 107, 110, 68, 69, 70, 71, 72, 73, 74,
97989		- /* 130 */ 75, 76, 77, 78, 79, 80, 113, 82, 83, 84,
97990		- /* 140 */ 85, 86, 87, 88, 89, 90, 91, 92, 19, 16,
97991		- /* 150 */ 92, 67, 98, 24, 96, 97, 98, 99, 100, 101,
97992		- /* 160 */ 102, 25, 60, 109, 62, 92, 150, 109, 150, 25,
	98212	+ /* 90 */ 91, 92, 19, 22, 94, 95, 96, 150, 150, 99,
	98213	+ /* 100 */ 100, 101, 76, 150, 49, 50, 105, 106, 107, 54,
	98214	+ /* 110 */ 110, 158, 165, 165, 161, 162, 26, 27, 165, 113,
	98215	+ /* 120 */ 16, 174, 175, 68, 69, 70, 71, 72, 73, 74,
	98216	+ /* 130 */ 75, 76, 77, 78, 79, 80, 118, 82, 83, 84,
	98217	+ /* 140 */ 85, 86, 87, 88, 89, 90, 91, 92, 19, 23,
	98218	+ /* 150 */ 92, 97, 98, 24, 96, 97, 98, 99, 100, 101,
	98219	+ /* 160 */ 102, 25, 97, 216, 60, 92, 62, 109, 221, 25,
97993	98220	/* 170 */ 97, 98, 99, 100, 101, 102, 86, 87, 49, 50,
97994		- /* 180 */ 116, 165, 109, 165, 94, 95, 118, 97, 170, 171,
97995		- /* 190 */ 174, 175, 128, 60, 104, 62, 106, 68, 69, 70,
	98221	+ /* 180 */ 118, 116, 109, 25, 94, 95, 32, 97, 88, 89,
	98222	+ /* 190 */ 90, 91, 92, 128, 104, 41, 106, 68, 69, 70,
97996	98223	/* 200 */ 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
97997	98224	/* 210 */ 11, 82, 83, 84, 85, 86, 87, 88, 89, 90,
97998		- /* 220 */ 91, 92, 19, 21, 86, 87, 88, 89, 90, 91,
97999		- /* 230 */ 92, 215, 96, 150, 66, 99, 100, 101, 22, 150,
98000		- /* 240 */ 138, 118, 26, 27, 161, 162, 110, 103, 165, 231,
98001		- /* 250 */ 232, 23, 49, 50, 165, 24, 57, 26, 32, 170,
98002		- /* 260 */ 171, 112, 94, 114, 115, 63, 98, 41, 185, 186,
98003		- /* 270 */ 118, 68, 69, 70, 71, 72, 73, 74, 75, 76,
98004		- /* 280 */ 77, 78, 79, 80, 12, 82, 83, 84, 85, 86,
	98225	+ /* 220 */ 91, 92, 19, 19, 86, 87, 88, 89, 90, 91,
	98226	+ /* 230 */ 92, 27, 96, 150, 66, 99, 100, 101, 112, 150,
	98227	+ /* 240 */ 114, 115, 138, 150, 161, 162, 110, 103, 165, 222,
	98228	+ /* 250 */ 223, 224, 49, 50, 165, 22, 57, 24, 165, 170,
	98229	+ /* 260 */ 171, 118, 94, 170, 171, 23, 98, 25, 185, 186,
	98230	+ /* 270 */ 243, 68, 69, 70, 71, 72, 73, 74, 75, 76,
	98231	+ /* 280 */ 77, 78, 79, 80, 126, 82, 83, 84, 85, 86,
98005	98232	/* 290 */ 87, 88, 89, 90, 91, 92, 19, 129, 130, 131,
98006		- /* 300 */ 28, 23, 100, 25, 105, 106, 107, 150, 26, 27,
98007		- /* 310 */ 94, 95, 169, 170, 171, 116, 44, 23, 46, 150,
98008		- /* 320 */ 231, 232, 165, 26, 27, 94, 49, 50, 23, 57,
98009		- /* 330 */ 25, 174, 175, 22, 165, 26, 27, 26, 27, 136,
98010		- /* 340 */ 138, 97, 98, 174, 175, 68, 69, 70, 71, 72,
98011		- /* 350 */ 73, 74, 75, 76, 77, 78, 79, 80, 23, 82,
	98233	+ /* 300 */ 88, 23, 172, 173, 105, 106, 107, 150, 22, 26,
	98234	+ /* 310 */ 27, 181, 26, 27, 22, 116, 26, 27, 26, 230,
	98235	+ /* 320 */ 231, 197, 165, 230, 231, 113, 49, 50, 204, 117,
	98236	+ /* 330 */ 96, 174, 175, 99, 100, 101, 22, 26, 27, 136,
	98237	+ /* 340 */ 26, 27, 118, 16, 110, 68, 69, 70, 71, 72,
	98238	+ /* 350 */ 73, 74, 75, 76, 77, 78, 79, 80, 118, 82,
98012	98239	/* 360 */ 83, 84, 85, 86, 87, 88, 89, 90, 91, 92,
98013		- /* 370 */ 19, 150, 23, 216, 23, 232, 94, 95, 221, 150,
98014		- /* 380 */ 23, 160, 25, 214, 215, 163, 165, 88, 166, 167,
98015		- /* 390 */ 168, 94, 95, 23, 165, 174, 175, 88, 160, 150,
98016		- /* 400 */ 49, 50, 120, 94, 95, 94, 95, 158, 26, 57,
98017		- /* 410 */ 161, 162, 113, 136, 165, 194, 117, 120, 22, 68,
	98240	+ /* 370 */ 19, 214, 215, 150, 23, 23, 155, 94, 95, 22,
	98241	+ /* 380 */ 94, 95, 116, 160, 94, 95, 94, 60, 165, 62,
	98242	+ /* 390 */ 112, 26, 114, 115, 128, 23, 36, 174, 175, 88,
	98243	+ /* 400 */ 49, 50, 57, 120, 22, 94, 95, 23, 94, 95,
	98244	+ /* 410 */ 120, 51, 25, 136, 169, 170, 171, 194, 58, 68,
98018	98245	/* 420 */ 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
98019		- /* 430 */ 79, 80, 194, 82, 83, 84, 85, 86, 87, 88,
98020		- /* 440 */ 89, 90, 91, 92, 19, 150, 23, 112, 23, 114,
98021		- /* 450 */ 115, 25, 142, 143, 144, 145, 218, 105, 106, 107,
98022		- /* 460 */ 165, 112, 150, 114, 115, 22, 150, 166, 116, 174,
98023		- /* 470 */ 175, 22, 76, 235, 49, 50, 94, 165, 240, 172,
98024		- /* 480 */ 173, 165, 112, 155, 114, 115, 174, 175, 181, 11,
98025		- /* 490 */ 174, 175, 22, 68, 69, 70, 71, 72, 73, 74,
98026		- /* 500 */ 75, 76, 77, 78, 79, 80, 205, 82, 83, 84,
98027		- /* 510 */ 85, 86, 87, 88, 89, 90, 91, 92, 19, 160,
98028		- /* 520 */ 23, 226, 23, 222, 12, 224, 225, 150, 216, 23,
98029		- /* 530 */ 23, 25, 36, 25, 25, 112, 220, 114, 115, 135,
98030		- /* 540 */ 28, 137, 165, 26, 27, 119, 30, 51, 49, 50,
98031		- /* 550 */ 34, 174, 175, 194, 58, 166, 44, 229, 46, 160,
98032		- /* 560 */ 22, 23, 234, 25, 48, 206, 207, 68, 69, 70,
	98246	+ /* 430 */ 79, 80, 23, 82, 83, 84, 85, 86, 87, 88,
	98247	+ /* 440 */ 89, 90, 91, 92, 19, 150, 12, 12, 23, 228,
	98248	+ /* 450 */ 105, 106, 107, 23, 233, 25, 165, 19, 150, 94,
	98249	+ /* 460 */ 165, 116, 28, 28, 112, 174, 114, 115, 108, 174,
	98250	+ /* 470 */ 175, 26, 27, 165, 49, 50, 231, 11, 44, 44,
	98251	+ /* 480 */ 46, 46, 174, 175, 112, 160, 114, 115, 50, 22,
	98252	+ /* 490 */ 23, 57, 25, 68, 69, 70, 71, 72, 73, 74,
	98253	+ /* 500 */ 75, 76, 77, 78, 79, 80, 119, 82, 83, 84,
	98254	+ /* 510 */ 85, 86, 87, 88, 89, 90, 91, 92, 19, 194,
	98255	+ /* 520 */ 225, 23, 23, 215, 19, 95, 105, 106, 107, 150,
	98256	+ /* 530 */ 23, 150, 27, 23, 67, 25, 150, 206, 207, 94,
	98257	+ /* 540 */ 95, 166, 104, 218, 165, 22, 165, 109, 49, 50,
	98258	+ /* 550 */ 120, 165, 25, 174, 175, 174, 175, 23, 21, 234,
	98259	+ /* 560 */ 174, 175, 22, 23, 239, 25, 25, 68, 69, 70,
98033	98260	/* 570 */ 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
98034		- /* 580 */ 23, 82, 83, 84, 85, 86, 87, 88, 89, 90,
98035		- /* 590 */ 91, 92, 19, 194, 205, 150, 23, 220, 19, 181,
98036		- /* 600 */ 182, 95, 97, 95, 108, 67, 188, 169, 170, 171,
98037		- /* 610 */ 165, 94, 95, 222, 50, 224, 225, 218, 120, 150,
98038		- /* 620 */ 160, 116, 49, 50, 22, 23, 120, 25, 120, 50,
98039		- /* 630 */ 161, 162, 19, 128, 165, 244, 22, 23, 193, 240,
98040		- /* 640 */ 27, 68, 69, 70, 71, 72, 73, 74, 75, 76,
98041		- /* 650 */ 77, 78, 79, 80, 194, 82, 83, 84, 85, 86,
98042		- /* 660 */ 87, 88, 89, 90, 91, 92, 19, 25, 104, 67,
98043		- /* 670 */ 232, 24, 150, 23, 150, 25, 150, 150, 150, 150,
98044		- /* 680 */ 150, 67, 25, 104, 7, 8, 9, 165, 109, 165,
98045		- /* 690 */ 245, 165, 165, 165, 165, 165, 49, 50, 174, 175,
98046		- /* 700 */ 174, 175, 174, 175, 174, 175, 0, 1, 2, 105,
98047		- /* 710 */ 106, 107, 248, 249, 187, 68, 69, 70, 71, 72,
	98261	+ /* 580 */ 205, 82, 83, 84, 85, 86, 87, 88, 89, 90,
	98262	+ /* 590 */ 91, 92, 19, 22, 23, 216, 23, 222, 223, 224,
	98263	+ /* 600 */ 63, 220, 35, 150, 150, 163, 220, 67, 166, 167,
	98264	+ /* 610 */ 168, 150, 169, 170, 171, 161, 162, 25, 165, 165,
	98265	+ /* 620 */ 150, 113, 49, 50, 25, 117, 165, 174, 175, 35,
	98266	+ /* 630 */ 7, 8, 9, 160, 160, 165, 120, 100, 67, 247,
	98267	+ /* 640 */ 248, 68, 69, 70, 71, 72, 73, 74, 75, 76,
	98268	+ /* 650 */ 77, 78, 79, 80, 193, 82, 83, 84, 85, 86,
	98269	+ /* 660 */ 87, 88, 89, 90, 91, 92, 19, 194, 194, 150,
	98270	+ /* 670 */ 135, 24, 137, 35, 231, 138, 150, 129, 130, 206,
	98271	+ /* 680 */ 207, 30, 27, 213, 165, 34, 118, 95, 0, 1,
	98272	+ /* 690 */ 2, 165, 218, 174, 175, 50, 49, 50, 22, 48,
	98273	+ /* 700 */ 174, 175, 22, 23, 23, 244, 222, 223, 224, 166,
	98274	+ /* 710 */ 167, 168, 120, 239, 23, 68, 69, 70, 71, 72,
98048	98275	/* 720 */ 73, 74, 75, 76, 77, 78, 79, 80, 150, 82,
98049	98276	/* 730 */ 83, 84, 85, 86, 87, 88, 89, 90, 91, 92,
98050		- /* 740 */ 19, 150, 213, 165, 150, 222, 150, 224, 225, 166,
98051		- /* 750 */ 167, 168, 174, 175, 129, 130, 165, 150, 165, 165,
98052		- /* 760 */ 150, 165, 150, 241, 35, 174, 175, 174, 174, 175,
98053		- /* 770 */ 49, 50, 165, 52, 23, 165, 25, 165, 206, 207,
98054		- /* 780 */ 23, 197, 25, 187, 174, 175, 174, 175, 204, 68,
	98277	+ /* 740 */ 19, 150, 173, 165, 181, 182, 24, 67, 26, 104,
	98278	+ /* 750 */ 181, 188, 174, 175, 150, 39, 165, 150, 52, 150,
	98279	+ /* 760 */ 150, 150, 150, 144, 145, 174, 175, 249, 250, 165,
	98280	+ /* 770 */ 49, 50, 165, 52, 165, 165, 165, 165, 174, 175,
	98281	+ /* 780 */ 29, 174, 175, 174, 175, 174, 175, 160, 22, 68,
98055	98282	/* 790 */ 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
98056	98283	/* 800 */ 79, 80, 150, 82, 83, 84, 85, 86, 87, 88,
98057		- /* 810 */ 89, 90, 91, 92, 19, 150, 150, 165, 35, 23,
98058		- /* 820 */ 150, 25, 150, 22, 217, 24, 174, 175, 150, 35,
98059		- /* 830 */ 165, 165, 144, 145, 150, 165, 150, 165, 118, 174,
98060		- /* 840 */ 175, 150, 22, 165, 49, 50, 174, 175, 23, 165,
98061		- /* 850 */ 25, 165, 23, 187, 25, 27, 165, 187, 174, 175,
98062		- /* 860 */ 23, 23, 25, 68, 69, 70, 71, 72, 73, 74,
	98284	+ /* 810 */ 89, 90, 91, 92, 19, 150, 94, 165, 150, 150,
	98285	+ /* 820 */ 160, 194, 150, 213, 160, 52, 174, 175, 23, 23,
	98286	+ /* 830 */ 165, 25, 22, 165, 165, 150, 150, 165, 52, 174,
	98287	+ /* 840 */ 175, 22, 174, 175, 49, 50, 174, 175, 190, 191,
	98288	+ /* 850 */ 165, 165, 240, 23, 194, 25, 187, 109, 194, 174,
	98289	+ /* 860 */ 175, 190, 191, 68, 69, 70, 71, 72, 73, 74,
98063	98290	/* 870 */ 75, 76, 77, 78, 79, 80, 150, 82, 83, 84,
98064	98291	/* 880 */ 85, 86, 87, 88, 89, 90, 91, 92, 19, 150,
98065		- /* 890 */ 150, 165, 150, 150, 150, 217, 25, 160, 19, 213,
98066		- /* 900 */ 174, 175, 190, 191, 165, 165, 27, 165, 165, 165,
98067		- /* 910 */ 150, 150, 150, 174, 175, 39, 174, 175, 49, 50,
98068		- /* 920 */ 23, 150, 52, 250, 251, 165, 165, 165, 190, 191,
98069		- /* 930 */ 187, 194, 241, 193, 174, 175, 165, 68, 69, 70,
	98292	+ /* 890 */ 22, 165, 150, 23, 150, 25, 150, 166, 91, 92,
	98293	+ /* 900 */ 174, 175, 22, 217, 165, 150, 102, 165, 150, 165,
	98294	+ /* 910 */ 150, 165, 150, 174, 175, 19, 174, 175, 49, 50,
	98295	+ /* 920 */ 165, 86, 87, 165, 23, 165, 25, 165, 24, 174,
	98296	+ /* 930 */ 175, 187, 174, 175, 174, 175, 205, 68, 69, 70,
98070	98297	/* 940 */ 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
98071	98298	/* 950 */ 150, 82, 83, 84, 85, 86, 87, 88, 89, 90,
98072		- /* 960 */ 91, 92, 19, 150, 150, 165, 150, 160, 160, 166,
98073		- /* 970 */ 166, 160, 150, 22, 174, 175, 91, 92, 165, 165,
98074		- /* 980 */ 52, 165, 29, 150, 213, 241, 23, 165, 49, 50,
98075		- /* 990 */ 174, 175, 49, 50, 1, 2, 173, 126, 165, 86,
98076		- /* 1000 */ 87, 194, 194, 22, 181, 194, 193, 193, 205, 205,
	98299	+ /* 960 */ 91, 92, 19, 150, 150, 165, 150, 150, 166, 23,
	98300	+ /* 970 */ 150, 25, 160, 20, 174, 175, 1, 2, 165, 165,
	98301	+ /* 980 */ 104, 165, 165, 43, 150, 165, 240, 150, 49, 50,
	98302	+ /* 990 */ 174, 175, 49, 50, 23, 23, 25, 25, 53, 165,
	98303	+ /* 1000 */ 187, 187, 165, 23, 187, 25, 194, 205, 174, 175,
98077	98304	/* 1010 */ 71, 72, 69, 70, 71, 72, 73, 74, 75, 76,
98078	98305	/* 1020 */ 77, 78, 79, 80, 150, 82, 83, 84, 85, 86,
98079	98306	/* 1030 */ 87, 88, 89, 90, 91, 92, 19, 98, 150, 165,
98080		- /* 1040 */ 150, 150, 150, 22, 150, 150, 22, 52, 174, 175,
98081		- /* 1050 */ 22, 102, 20, 165, 109, 165, 165, 165, 150, 165,
98082		- /* 1060 */ 165, 150, 174, 175, 174, 175, 49, 50, 24, 19,
98083		- /* 1070 */ 43, 104, 59, 165, 138, 104, 165, 25, 53, 53,
98084		- /* 1080 */ 22, 5, 174, 175, 193, 174, 175, 70, 71, 72,
98085		- /* 1090 */ 73, 74, 75, 76, 77, 78, 79, 80, 1, 82,
	98307	+ /* 1040 */ 150, 160, 150, 59, 25, 53, 104, 22, 174, 175,
	98308	+ /* 1050 */ 213, 138, 5, 165, 1, 165, 150, 165, 150, 150,
	98309	+ /* 1060 */ 240, 150, 174, 175, 174, 175, 49, 50, 118, 150,
	98310	+ /* 1070 */ 35, 165, 27, 165, 165, 194, 165, 108, 127, 76,
	98311	+ /* 1080 */ 174, 175, 174, 175, 165, 174, 175, 70, 71, 72,
	98312	+ /* 1090 */ 73, 74, 75, 76, 77, 78, 79, 80, 166, 82,
98086	98313	/* 1100 */ 83, 84, 85, 86, 87, 88, 89, 90, 91, 92,
98087		- /* 1110 */ 19, 20, 150, 22, 150, 150, 150, 26, 27, 118,
98088		- /* 1120 */ 150, 35, 150, 150, 76, 27, 108, 165, 37, 165,
98089		- /* 1130 */ 165, 165, 76, 19, 20, 165, 22, 165, 165, 127,
98090		- /* 1140 */ 26, 27, 22, 1, 150, 16, 20, 56, 150, 150,
98091		- /* 1150 */ 119, 37, 150, 119, 160, 193, 150, 66, 193, 165,
98092		- /* 1160 */ 150, 150, 121, 165, 165, 108, 150, 165, 174, 175,
98093		- /* 1170 */ 56, 165, 150, 127, 22, 165, 165, 86, 87, 88,
98094		- /* 1180 */ 66, 165, 16, 150, 93, 94, 95, 165, 194, 98,
98095		- /* 1190 */ 174, 175, 128, 23, 15, 23, 174, 175, 165, 150,
98096		- /* 1200 */ 86, 87, 65, 140, 150, 22, 3, 93, 94, 95,
98097		- /* 1210 */ 216, 4, 98, 252, 165, 221, 150, 164, 180, 165,
	98314	+ /* 1110 */ 19, 20, 193, 22, 150, 150, 150, 26, 27, 76,
	98315	+ /* 1120 */ 150, 22, 1, 150, 119, 121, 217, 20, 37, 165,
	98316	+ /* 1130 */ 165, 165, 16, 19, 20, 165, 22, 205, 165, 119,
	98317	+ /* 1140 */ 26, 27, 108, 128, 150, 150, 150, 56, 150, 22,
	98318	+ /* 1150 */ 150, 37, 150, 127, 160, 23, 150, 66, 193, 165,
	98319	+ /* 1160 */ 165, 165, 16, 165, 23, 165, 150, 165, 174, 175,
	98320	+ /* 1170 */ 56, 165, 150, 65, 174, 175, 15, 86, 87, 88,
	98321	+ /* 1180 */ 66, 165, 140, 150, 93, 94, 95, 165, 194, 98,
	98322	+ /* 1190 */ 174, 175, 22, 3, 164, 193, 174, 175, 165, 150,
	98323	+ /* 1200 */ 86, 87, 4, 180, 150, 248, 251, 93, 94, 95,
	98324	+ /* 1210 */ 216, 180, 98, 251, 165, 221, 150, 149, 6, 165,
98098	98325	/* 1220 */ 129, 130, 131, 132, 133, 134, 193, 150, 174, 175,
98099		- /* 1230 */ 116, 165, 19, 20, 150, 22, 249, 252, 149, 26,
98100		- /* 1240 */ 27, 180, 165, 129, 130, 131, 132, 133, 134, 165,
98101		- /* 1250 */ 37, 174, 175, 150, 6, 19, 20, 150, 22, 150,
98102		- /* 1260 */ 150, 150, 26, 27, 149, 149, 13, 150, 165, 56,
98103		- /* 1270 */ 149, 159, 165, 37, 165, 165, 165, 174, 175, 66,
98104		- /* 1280 */ 146, 147, 165, 174, 175, 25, 152, 151, 154, 150,
98105		- /* 1290 */ 194, 151, 56, 116, 160, 150, 123, 202, 150, 86,
98106		- /* 1300 */ 87, 199, 66, 193, 165, 200, 93, 94, 95, 150,
98107		- /* 1310 */ 165, 98, 150, 165, 126, 22, 124, 150, 150, 26,
98108		- /* 1320 */ 27, 150, 86, 87, 165, 201, 150, 165, 194, 93,
98109		- /* 1330 */ 94, 95, 165, 165, 98, 150, 165, 122, 203, 125,
98110		- /* 1340 */ 227, 165, 129, 130, 131, 132, 133, 134, 5, 150,
98111		- /* 1350 */ 165, 135, 218, 10, 11, 12, 13, 14, 150, 66,
98112		- /* 1360 */ 17, 157, 118, 157, 165, 129, 130, 131, 132, 133,
98113		- /* 1370 */ 134, 150, 104, 165, 31, 210, 33, 176, 150, 86,
98114		- /* 1380 */ 87, 247, 174, 175, 150, 42, 165, 94, 121, 211,
98115		- /* 1390 */ 150, 98, 210, 165, 210, 174, 175, 211, 55, 165,
	98326	+ /* 1230 */ 116, 165, 19, 20, 150, 22, 149, 151, 150, 26,
	98327	+ /* 1240 */ 27, 149, 165, 129, 130, 131, 132, 133, 134, 165,
	98328	+ /* 1250 */ 37, 174, 175, 165, 149, 19, 20, 13, 22, 150,
	98329	+ /* 1260 */ 150, 150, 26, 27, 146, 147, 151, 150, 25, 56,
	98330	+ /* 1270 */ 152, 159, 154, 37, 165, 165, 165, 193, 160, 66,
	98331	+ /* 1280 */ 116, 193, 165, 174, 175, 174, 175, 194, 199, 150,
	98332	+ /* 1290 */ 200, 126, 56, 124, 123, 150, 201, 122, 150, 86,
	98333	+ /* 1300 */ 87, 150, 66, 193, 165, 202, 93, 94, 95, 150,
	98334	+ /* 1310 */ 165, 98, 194, 165, 125, 22, 165, 150, 150, 26,
	98335	+ /* 1320 */ 27, 135, 86, 87, 165, 174, 175, 203, 226, 93,
	98336	+ /* 1330 */ 94, 95, 165, 165, 98, 150, 218, 150, 193, 157,
	98337	+ /* 1340 */ 118, 157, 129, 130, 131, 132, 133, 134, 5, 104,
	98338	+ /* 1350 */ 165, 211, 165, 10, 11, 12, 13, 14, 150, 66,
	98339	+ /* 1360 */ 17, 174, 175, 210, 246, 129, 130, 131, 132, 133,
	98340	+ /* 1370 */ 134, 150, 210, 165, 31, 121, 33, 150, 150, 86,
	98341	+ /* 1380 */ 87, 176, 174, 175, 150, 42, 165, 94, 211, 210,
	98342	+ /* 1390 */ 150, 98, 165, 165, 211, 174, 175, 150, 55, 165,
98116	98343	/* 1400 */ 57, 150, 174, 175, 61, 165, 150, 64, 174, 175,
98117		- /* 1410 */ 104, 211, 47, 150, 174, 175, 165, 176, 176, 150,
98118		- /* 1420 */ 103, 165, 129, 130, 131, 174, 175, 184, 165, 179,
98119		- /* 1430 */ 174, 175, 150, 178, 165, 176, 22, 174, 175, 230,
98120		- /* 1440 */ 92, 230, 184, 174, 175, 150, 176, 165, 105, 106,
98121		- /* 1450 */ 107, 150, 176, 176, 111, 156, 174, 175, 179, 116,
98122		- /* 1460 */ 165, 18, 157, 156, 238, 157, 165, 156, 45, 174,
98123		- /* 1470 */ 175, 157, 157, 135, 239, 174, 175, 156, 189, 157,
98124		- /* 1480 */ 68, 189, 139, 219, 22, 199, 157, 18, 192, 192,
98125		- /* 1490 */ 192, 189, 192, 199, 219, 243, 157, 40, 157, 157,
98126		- /* 1500 */ 243, 38, 153, 166, 233, 196, 233, 246, 198, 228,
98127		- /* 1510 */ 177, 177, 209, 177, 182, 199, 166, 177, 166, 199,
98128		- /* 1520 */ 242, 177, 242, 178, 148, 166, 196, 209, 209, 92,
98129		- /* 1530 */ 195, 208, 174, 186, 183, 174, 183, 191, 183, 253,
98130		- /* 1540 */ 236, 253, 186, 253, 253, 253, 253, 253, 253, 237,
	98344	+ /* 1410 */ 150, 150, 165, 150, 174, 175, 165, 104, 150, 184,
	98345	+ /* 1420 */ 150, 165, 129, 130, 131, 165, 165, 150, 165, 150,
	98346	+ /* 1430 */ 150, 176, 150, 165, 47, 165, 150, 150, 176, 103,
	98347	+ /* 1440 */ 150, 22, 165, 178, 165, 165, 179, 165, 105, 106,
	98348	+ /* 1450 */ 107, 165, 165, 229, 111, 165, 92, 176, 229, 116,
	98349	+ /* 1460 */ 184, 176, 179, 156, 176, 176, 18, 157, 156, 237,
	98350	+ /* 1470 */ 45, 157, 156, 135, 157, 157, 238, 156, 68, 157,
	98351	+ /* 1480 */ 189, 189, 139, 219, 22, 157, 18, 192, 192, 192,
	98352	+ /* 1490 */ 192, 189, 219, 199, 157, 242, 40, 157, 199, 242,
	98353	+ /* 1500 */ 153, 157, 38, 245, 196, 166, 232, 198, 177, 177,
	98354	+ /* 1510 */ 232, 227, 209, 178, 166, 182, 166, 148, 177, 177,
	98355	+ /* 1520 */ 209, 196, 177, 199, 209, 199, 166, 208, 92, 195,
	98356	+ /* 1530 */ 174, 174, 183, 252, 183, 183, 252, 191, 252, 235,
	98357	+ /* 1540 */ 186, 241, 241, 252, 186, 252, 252, 252, 252, 252,
	98358	+ /* 1550 */ 252, 252, 252, 252, 252, 252, 236,
98131	98359	};
98132		-#define YY_SHIFT_USE_DFLT (-90)
	98360	+#define YY_SHIFT_USE_DFLT (-74)
98133	98361	#define YY_SHIFT_COUNT (418)
98134		-#define YY_SHIFT_MIN (-89)
98135		-#define YY_SHIFT_MAX (1469)
	98362	+#define YY_SHIFT_MIN (-73)
	98363	+#define YY_SHIFT_MAX (1468)
98136	98364	static const short yy_shift_ofst[] = {
98137		- /* 0 */ 993, 1114, 1343, 1114, 1213, 1213, 90, 90, 0, -19,
98138		- /* 10 */ 1213, 1213, 1213, 1213, 1213, 352, 517, 721, 1091, 1213,
	98365	+ /* 0 */ 975, 1114, 1343, 1114, 1213, 1213, 90, 90, 0, -19,
	98366	+ /* 10 */ 1213, 1213, 1213, 1213, 1213, 345, 445, 721, 1091, 1213,
98139	98367	/* 20 */ 1213, 1213, 1213, 1213, 1213, 1213, 1213, 1213, 1213, 1213,
98140	98368	/* 30 */ 1213, 1213, 1213, 1213, 1213, 1213, 1213, 1213, 1213, 1213,
98141	98369	/* 40 */ 1213, 1213, 1213, 1213, 1213, 1213, 1213, 1236, 1213, 1213,
98142	98370	/* 50 */ 1213, 1213, 1213, 1213, 1213, 1213, 1213, 1213, 1213, 1213,
98143		- /* 60 */ 1213, -49, 199, 517, 517, 913, 913, 382, 1177, 55,
98144		- /* 70 */ 647, 573, 499, 425, 351, 277, 203, 129, 795, 795,
	98371	+ /* 60 */ 1213, 199, 445, 445, 835, 835, 365, 1164, 55, 647,
	98372	+ /* 70 */ 573, 499, 425, 351, 277, 203, 129, 795, 795, 795,
98145	98373	/* 80 */ 795, 795, 795, 795, 795, 795, 795, 795, 795, 795,
98146		- /* 90 */ 795, 795, 795, 795, 795, 795, 869, 795, 943, 1017,
98147		- /* 100 */ 1017, -69, -69, -69, -69, -1, -1, 58, 138, -44,
98148		- /* 110 */ 517, 517, 517, 517, 517, 517, 517, 517, 517, 517,
98149		- /* 120 */ 517, 517, 517, 517, 517, 517, 202, 579, 517, 517,
98150		- /* 130 */ 517, 517, 517, 382, 885, 1437, -90, -90, -90, 1293,
98151		- /* 140 */ 73, 272, 272, 309, 311, 297, 282, 216, 602, 538,
98152		- /* 150 */ 517, 517, 517, 517, 517, 517, 517, 517, 517, 517,
98153		- /* 160 */ 517, 517, 517, 517, 517, 517, 517, 517, 517, 517,
98154		- /* 170 */ 517, 517, 517, 517, 517, 517, 517, 517, 517, 517,
98155		- /* 180 */ 517, 517, 505, 231, 231, 231, 706, 64, 1177, 1177,
98156		- /* 190 */ 1177, -90, -90, -90, 136, 168, 168, 12, 496, 496,
98157		- /* 200 */ 496, 506, 423, 512, 370, 349, 335, 149, 149, 149,
98158		- /* 210 */ 149, 604, 516, 149, 149, 508, 3, 299, 677, 871,
98159		- /* 220 */ 613, 613, 879, 871, 879, 144, 382, 226, 382, 226,
98160		- /* 230 */ 564, 226, 613, 226, 226, 404, 625, 625, 382, 426,
98161		- /* 240 */ -89, 801, 1463, 1244, 1244, 1457, 1457, 1244, 1462, 1412,
98162		- /* 250 */ 1188, 1469, 1469, 1469, 1469, 1244, 1188, 1462, 1412, 1412,
98163		- /* 260 */ 1244, 1443, 1338, 1423, 1244, 1244, 1443, 1244, 1443, 1244,
98164		- /* 270 */ 1443, 1414, 1306, 1306, 1306, 1365, 1348, 1348, 1414, 1306,
98165		- /* 280 */ 1317, 1306, 1365, 1306, 1306, 1267, 1268, 1267, 1268, 1267,
98166		- /* 290 */ 1268, 1244, 1244, 1216, 1214, 1215, 1192, 1173, 1188, 1177,
98167		- /* 300 */ 1260, 1253, 1253, 1248, 1248, 1248, 1248, -90, -90, -90,
98168		- /* 310 */ -90, -90, -90, 939, 102, 614, 84, 133, 14, 837,
98169		- /* 320 */ 396, 829, 825, 796, 757, 751, 650, 357, 244, 107,
98170		- /* 330 */ 54, 305, 278, 1207, 1203, 1183, 1063, 1179, 1137, 1166,
98171		- /* 340 */ 1172, 1170, 1064, 1152, 1046, 1057, 1034, 1126, 1041, 1129,
98172		- /* 350 */ 1142, 1031, 1120, 1012, 1056, 1048, 1018, 1098, 1086, 1001,
98173		- /* 360 */ 1097, 1076, 1058, 971, 936, 1026, 1052, 1025, 1013, 1027,
98174		- /* 370 */ 967, 1044, 1032, 1050, 945, 949, 1028, 995, 1024, 1021,
98175		- /* 380 */ 963, 981, 928, 953, 951, 870, 876, 897, 838, 720,
98176		- /* 390 */ 828, 794, 820, 498, 642, 783, 657, 729, 642, 557,
98177		- /* 400 */ 507, 509, 497, 470, 478, 449, 294, 228, 443, 23,
98178		- /* 410 */ 152, 123, 68, -20, -42, 57, 39, -3, 5,
	98374	+ /* 90 */ 795, 795, 795, 795, 795, 869, 795, 943, 1017, 1017,
	98375	+ /* 100 */ -69, -45, -45, -45, -45, -45, -1, 58, 138, 100,
	98376	+ /* 110 */ 445, 445, 445, 445, 445, 445, 445, 445, 445, 445,
	98377	+ /* 120 */ 445, 445, 445, 445, 445, 445, 537, 438, 445, 445,
	98378	+ /* 130 */ 445, 445, 445, 365, 807, 1436, -74, -74, -74, 1293,
	98379	+ /* 140 */ 73, 434, 434, 311, 314, 290, 283, 286, 540, 467,
	98380	+ /* 150 */ 445, 445, 445, 445, 445, 445, 445, 445, 445, 445,
	98381	+ /* 160 */ 445, 445, 445, 445, 445, 445, 445, 445, 445, 445,
	98382	+ /* 170 */ 445, 445, 445, 445, 445, 445, 445, 445, 445, 445,
	98383	+ /* 180 */ 445, 445, 65, 722, 722, 722, 688, 266, 1164, 1164,
	98384	+ /* 190 */ 1164, -74, -74, -74, 136, 168, 168, 234, 360, 360,
	98385	+ /* 200 */ 360, 430, 372, 435, 352, 278, 126, -36, -36, -36,
	98386	+ /* 210 */ -36, 421, 651, -36, -36, 592, 292, 212, 623, 158,
	98387	+ /* 220 */ 204, 204, 505, 158, 505, 144, 365, 154, 365, 154,
	98388	+ /* 230 */ 645, 154, 204, 154, 154, 535, 548, 548, 365, 387,
	98389	+ /* 240 */ 508, 233, 1464, 1222, 1222, 1456, 1456, 1222, 1462, 1410,
	98390	+ /* 250 */ 1165, 1468, 1468, 1468, 1468, 1222, 1165, 1462, 1410, 1410,
	98391	+ /* 260 */ 1222, 1448, 1338, 1425, 1222, 1222, 1448, 1222, 1448, 1222,
	98392	+ /* 270 */ 1448, 1419, 1313, 1313, 1313, 1387, 1364, 1364, 1419, 1313,
	98393	+ /* 280 */ 1336, 1313, 1387, 1313, 1313, 1254, 1245, 1254, 1245, 1254,
	98394	+ /* 290 */ 1245, 1222, 1222, 1186, 1189, 1175, 1169, 1171, 1165, 1164,
	98395	+ /* 300 */ 1243, 1244, 1244, 1212, 1212, 1212, 1212, -74, -74, -74,
	98396	+ /* 310 */ -74, -74, -74, 939, 104, 680, 571, 327, 1, 980,
	98397	+ /* 320 */ 26, 972, 971, 946, 901, 870, 830, 806, 54, 21,
	98398	+ /* 330 */ -73, 510, 242, 1198, 1190, 1170, 1042, 1161, 1108, 1146,
	98399	+ /* 340 */ 1141, 1132, 1015, 1127, 1026, 1034, 1020, 1107, 1004, 1116,
	98400	+ /* 350 */ 1121, 1005, 1099, 951, 1043, 1003, 969, 1045, 1035, 950,
	98401	+ /* 360 */ 1053, 1047, 1025, 942, 913, 992, 1019, 945, 984, 940,
	98402	+ /* 370 */ 876, 904, 953, 896, 748, 804, 880, 786, 868, 819,
	98403	+ /* 380 */ 805, 810, 773, 751, 766, 706, 716, 691, 681, 568,
	98404	+ /* 390 */ 655, 638, 676, 516, 541, 594, 599, 567, 541, 534,
	98405	+ /* 400 */ 507, 527, 498, 523, 466, 382, 409, 384, 357, 6,
	98406	+ /* 410 */ 240, 224, 143, 62, 18, 71, 39, 9, 5,
98179	98407	};
98180		-#define YY_REDUCE_USE_DFLT (-222)
	98408	+#define YY_REDUCE_USE_DFLT (-142)
98181	98409	#define YY_REDUCE_COUNT (312)
98182		-#define YY_REDUCE_MIN (-221)
98183		-#define YY_REDUCE_MAX (1376)
	98410	+#define YY_REDUCE_MIN (-141)
	98411	+#define YY_REDUCE_MAX (1369)
98184	98412	static const short yy_reduce_ofst[] = {
98185		- /* 0 */ 310, 994, 1134, 221, 169, 157, 89, 18, 83, 301,
98186		- /* 10 */ 377, 316, 312, 16, 295, 238, 249, 391, 1301, 1295,
98187		- /* 20 */ 1282, 1269, 1263, 1256, 1251, 1240, 1234, 1228, 1221, 1208,
98188		- /* 30 */ 1109, 1103, 1077, 1054, 1022, 1016, 911, 908, 890, 888,
98189		- /* 40 */ 874, 816, 800, 760, 742, 739, 726, 684, 672, 665,
98190		- /* 50 */ 652, 612, 610, 594, 591, 578, 530, 528, 526, 524,
98191		- /* 60 */ -72, -221, 399, 469, 445, 438, 143, 222, 359, 523,
98192		- /* 70 */ 523, 523, 523, 523, 523, 523, 523, 523, 523, 523,
98193		- /* 80 */ 523, 523, 523, 523, 523, 523, 523, 523, 523, 523,
98194		- /* 90 */ 523, 523, 523, 523, 523, 523, 523, 523, 523, 523,
98195		- /* 100 */ 523, 523, 523, 523, 523, 523, 523, 307, 523, 523,
98196		- /* 110 */ 1110, 678, 1033, 965, 962, 891, 814, 813, 744, 771,
98197		- /* 120 */ 691, 607, 522, 743, 686, 740, 328, 418, 670, 666,
98198		- /* 130 */ 596, 527, 529, 583, 523, 523, 523, 523, 523, 593,
98199		- /* 140 */ 823, 738, 712, 892, 1199, 1185, 1176, 1171, 673, 673,
98200		- /* 150 */ 1168, 1167, 1162, 1159, 1148, 1145, 1139, 1117, 1111, 1107,
98201		- /* 160 */ 1084, 1066, 1049, 1011, 1010, 1006, 1002, 999, 998, 973,
98202		- /* 170 */ 972, 970, 966, 964, 895, 894, 892, 833, 822, 762,
98203		- /* 180 */ 761, 229, 811, 804, 803, 389, 688, 808, 807, 737,
98204		- /* 190 */ 460, 464, 572, 584, 1356, 1361, 1358, 1347, 1355, 1353,
98205		- /* 200 */ 1351, 1323, 1335, 1346, 1335, 1335, 1335, 1335, 1335, 1335,
98206		- /* 210 */ 1335, 1312, 1304, 1335, 1335, 1323, 1359, 1330, 1376, 1320,
98207		- /* 220 */ 1319, 1318, 1280, 1316, 1278, 1345, 1352, 1344, 1350, 1340,
98208		- /* 230 */ 1332, 1336, 1303, 1334, 1333, 1281, 1273, 1271, 1337, 1310,
98209		- /* 240 */ 1309, 1349, 1261, 1342, 1341, 1257, 1252, 1339, 1275, 1302,
98210		- /* 250 */ 1294, 1300, 1298, 1297, 1296, 1329, 1286, 1264, 1292, 1289,
98211		- /* 260 */ 1322, 1321, 1235, 1226, 1315, 1314, 1311, 1308, 1307, 1305,
98212		- /* 270 */ 1299, 1279, 1277, 1276, 1270, 1258, 1211, 1209, 1250, 1259,
98213		- /* 280 */ 1255, 1242, 1243, 1241, 1201, 1200, 1184, 1186, 1182, 1178,
98214		- /* 290 */ 1165, 1206, 1204, 1113, 1135, 1095, 1124, 1105, 1102, 1096,
98215		- /* 300 */ 1112, 1140, 1136, 1121, 1116, 1115, 1089, 985, 961, 987,
98216		- /* 310 */ 1061, 1038, 1053,
	98413	+ /* 0 */ -141, 994, 1118, 223, 157, -53, 93, 89, 83, 375,
	98414	+ /* 10 */ 386, 381, 379, 308, 295, 325, -47, 27, 1240, 1234,
	98415	+ /* 20 */ 1228, 1221, 1208, 1187, 1151, 1111, 1109, 1077, 1054, 1022,
	98416	+ /* 30 */ 1016, 1000, 911, 908, 906, 890, 888, 874, 834, 816,
	98417	+ /* 40 */ 800, 760, 758, 755, 742, 739, 726, 685, 672, 668,
	98418	+ /* 50 */ 665, 652, 611, 609, 607, 604, 591, 578, 526, 519,
	98419	+ /* 60 */ 453, 474, 454, 461, 443, 245, 442, 473, 484, 484,
	98420	+ /* 70 */ 484, 484, 484, 484, 484, 484, 484, 484, 484, 484,
	98421	+ /* 80 */ 484, 484, 484, 484, 484, 484, 484, 484, 484, 484,
	98422	+ /* 90 */ 484, 484, 484, 484, 484, 484, 484, 484, 484, 484,
	98423	+ /* 100 */ 484, 484, 484, 484, 484, 484, 484, 130, 484, 484,
	98424	+ /* 110 */ 1145, 909, 1110, 1088, 1084, 1033, 1002, 965, 820, 837,
	98425	+ /* 120 */ 746, 686, 612, 817, 610, 919, 221, 563, 814, 813,
	98426	+ /* 130 */ 744, 669, 470, 543, 484, 484, 484, 484, 484, 291,
	98427	+ /* 140 */ 569, 671, 658, 970, 1290, 1287, 1286, 1282, 518, 518,
	98428	+ /* 150 */ 1280, 1279, 1277, 1270, 1268, 1263, 1261, 1260, 1256, 1251,
	98429	+ /* 160 */ 1247, 1227, 1185, 1168, 1167, 1159, 1148, 1139, 1117, 1066,
	98430	+ /* 170 */ 1049, 1006, 998, 996, 995, 973, 970, 966, 964, 892,
	98431	+ /* 180 */ 762, -52, 881, 932, 802, 731, 619, 812, 664, 660,
	98432	+ /* 190 */ 627, 392, 331, 124, 1358, 1357, 1356, 1354, 1352, 1351,
	98433	+ /* 200 */ 1349, 1319, 1334, 1346, 1334, 1334, 1334, 1334, 1334, 1334,
	98434	+ /* 210 */ 1334, 1320, 1304, 1334, 1334, 1319, 1360, 1325, 1369, 1326,
	98435	+ /* 220 */ 1315, 1311, 1301, 1324, 1300, 1335, 1350, 1345, 1348, 1342,
	98436	+ /* 230 */ 1333, 1341, 1303, 1332, 1331, 1284, 1278, 1274, 1339, 1309,
	98437	+ /* 240 */ 1308, 1347, 1258, 1344, 1340, 1257, 1253, 1337, 1273, 1302,
	98438	+ /* 250 */ 1299, 1298, 1297, 1296, 1295, 1328, 1294, 1264, 1292, 1291,
	98439	+ /* 260 */ 1322, 1321, 1238, 1232, 1318, 1317, 1316, 1314, 1312, 1310,
	98440	+ /* 270 */ 1307, 1283, 1289, 1288, 1285, 1276, 1229, 1224, 1267, 1281,
	98441	+ /* 280 */ 1265, 1262, 1235, 1255, 1205, 1183, 1179, 1177, 1162, 1140,
	98442	+ /* 290 */ 1153, 1184, 1182, 1102, 1124, 1103, 1095, 1090, 1089, 1093,
	98443	+ /* 300 */ 1112, 1115, 1086, 1105, 1092, 1087, 1068, 962, 955, 957,
	98444	+ /* 310 */ 1031, 1023, 1030,
98217	98445	};
98218	98446	static const YYACTIONTYPE yy_default[] = {
98219		- /* 0 */ 636, 872, 961, 961, 961, 872, 901, 901, 961, 760,
98220		- /* 10 */ 961, 961, 961, 961, 870, 961, 961, 935, 961, 961,
98221		- /* 20 */ 961, 961, 961, 961, 961, 961, 961, 961, 961, 961,
98222		- /* 30 */ 961, 961, 961, 961, 961, 961, 961, 961, 961, 961,
98223		- /* 40 */ 961, 961, 961, 961, 961, 961, 961, 961, 961, 961,
98224		- /* 50 */ 961, 961, 961, 961, 961, 961, 961, 961, 961, 961,
98225		- /* 60 */ 961, 844, 961, 961, 961, 901, 901, 675, 764, 795,
98226		- /* 70 */ 961, 961, 961, 961, 961, 961, 961, 961, 934, 936,
98227		- /* 80 */ 810, 809, 803, 802, 914, 775, 800, 793, 786, 797,
98228		- /* 90 */ 873, 866, 867, 865, 869, 874, 961, 796, 832, 850,
98229		- /* 100 */ 831, 849, 856, 848, 834, 843, 833, 667, 835, 836,
98230		- /* 110 */ 961, 961, 961, 961, 961, 961, 961, 961, 961, 961,
98231		- /* 120 */ 961, 961, 961, 961, 961, 961, 662, 729, 961, 961,
98232		- /* 130 */ 961, 961, 961, 961, 837, 838, 853, 852, 851, 961,
98233		- /* 140 */ 961, 961, 961, 961, 961, 961, 961, 961, 961, 961,
98234		- /* 150 */ 961, 941, 939, 961, 885, 961, 961, 961, 961, 961,
98235		- /* 160 */ 961, 961, 961, 961, 961, 961, 961, 961, 961, 961,
98236		- /* 170 */ 961, 961, 961, 961, 961, 961, 961, 961, 961, 961,
98237		- /* 180 */ 961, 642, 961, 760, 760, 760, 636, 961, 961, 961,
98238		- /* 190 */ 961, 953, 764, 754, 720, 961, 961, 961, 961, 961,
98239		- /* 200 */ 961, 961, 961, 961, 961, 961, 961, 805, 743, 924,
98240		- /* 210 */ 926, 961, 907, 741, 664, 762, 677, 752, 644, 799,
98241		- /* 220 */ 777, 777, 919, 799, 919, 701, 961, 789, 961, 789,
98242		- /* 230 */ 698, 789, 777, 789, 789, 868, 961, 961, 961, 761,
98243		- /* 240 */ 752, 961, 946, 768, 768, 938, 938, 768, 811, 733,
98244		- /* 250 */ 799, 740, 740, 740, 740, 768, 799, 811, 733, 733,
98245		- /* 260 */ 768, 659, 913, 911, 768, 768, 659, 768, 659, 768,
98246		- /* 270 */ 659, 878, 731, 731, 731, 716, 882, 882, 878, 731,
98247		- /* 280 */ 701, 731, 716, 731, 731, 781, 776, 781, 776, 781,
98248		- /* 290 */ 776, 768, 768, 961, 794, 782, 792, 790, 799, 961,
98249		- /* 300 */ 719, 652, 652, 641, 641, 641, 641, 958, 958, 953,
98250		- /* 310 */ 703, 703, 685, 961, 961, 961, 961, 961, 961, 961,
98251		- /* 320 */ 887, 961, 961, 961, 961, 961, 961, 961, 961, 961,
98252		- /* 330 */ 961, 961, 961, 961, 637, 948, 961, 961, 945, 961,
98253		- /* 340 */ 961, 961, 961, 961, 961, 961, 961, 961, 961, 961,
98254		- /* 350 */ 961, 961, 961, 961, 961, 961, 961, 961, 961, 917,
98255		- /* 360 */ 961, 961, 961, 961, 961, 961, 910, 909, 961, 961,
98256		- /* 370 */ 961, 961, 961, 961, 961, 961, 961, 961, 961, 961,
98257		- /* 380 */ 961, 961, 961, 961, 961, 961, 961, 961, 961, 961,
98258		- /* 390 */ 961, 961, 961, 961, 791, 961, 783, 961, 871, 961,
98259		- /* 400 */ 961, 961, 961, 961, 961, 961, 961, 961, 961, 746,
98260		- /* 410 */ 820, 961, 819, 823, 818, 669, 961, 650, 961, 633,
98261		- /* 420 */ 638, 957, 960, 959, 956, 955, 954, 949, 947, 944,
98262		- /* 430 */ 943, 942, 940, 937, 933, 891, 889, 896, 895, 894,
98263		- /* 440 */ 893, 892, 890, 888, 886, 806, 804, 801, 798, 932,
98264		- /* 450 */ 884, 742, 739, 738, 658, 950, 916, 925, 923, 812,
98265		- /* 460 */ 922, 921, 920, 918, 915, 902, 808, 807, 734, 876,
98266		- /* 470 */ 875, 661, 906, 905, 904, 908, 912, 903, 770, 660,
98267		- /* 480 */ 657, 666, 723, 722, 730, 728, 727, 726, 725, 724,
98268		- /* 490 */ 721, 668, 676, 687, 715, 700, 699, 881, 883, 880,
98269		- /* 500 */ 879, 708, 707, 713, 712, 711, 710, 709, 706, 705,
98270		- /* 510 */ 704, 697, 696, 702, 695, 718, 717, 714, 694, 737,
98271		- /* 520 */ 736, 735, 732, 693, 692, 691, 823, 690, 689, 829,
98272		- /* 530 */ 828, 816, 860, 757, 756, 755, 767, 766, 779, 778,
98273		- /* 540 */ 814, 813, 780, 765, 759, 758, 774, 773, 772, 771,
98274		- /* 550 */ 763, 753, 785, 788, 787, 784, 845, 862, 769, 859,
98275		- /* 560 */ 931, 930, 929, 928, 927, 864, 863, 830, 827, 680,
98276		- /* 570 */ 681, 900, 898, 899, 897, 683, 682, 679, 678, 861,
98277		- /* 580 */ 748, 747, 857, 854, 846, 841, 858, 855, 847, 842,
98278		- /* 590 */ 840, 839, 825, 824, 822, 821, 817, 826, 671, 749,
98279		- /* 600 */ 745, 744, 815, 751, 750, 688, 686, 684, 665, 663,
98280		- /* 610 */ 656, 654, 653, 655, 651, 649, 648, 647, 646, 645,
98281		- /* 620 */ 674, 673, 672, 670, 669, 643, 640, 639, 635, 634,
98282		- /* 630 */ 632,
	98447	+ /* 0 */ 635, 870, 959, 959, 959, 870, 899, 899, 959, 759,
	98448	+ /* 10 */ 959, 959, 959, 959, 868, 959, 959, 933, 959, 959,
	98449	+ /* 20 */ 959, 959, 959, 959, 959, 959, 959, 959, 959, 959,
	98450	+ /* 30 */ 959, 959, 959, 959, 959, 959, 959, 959, 959, 959,
	98451	+ /* 40 */ 959, 959, 959, 959, 959, 959, 959, 959, 959, 959,
	98452	+ /* 50 */ 959, 959, 959, 959, 959, 959, 959, 959, 959, 959,
	98453	+ /* 60 */ 959, 959, 959, 959, 899, 899, 674, 763, 794, 959,
	98454	+ /* 70 */ 959, 959, 959, 959, 959, 959, 959, 932, 934, 809,
	98455	+ /* 80 */ 808, 802, 801, 912, 774, 799, 792, 785, 796, 871,
	98456	+ /* 90 */ 864, 865, 863, 867, 872, 959, 795, 831, 848, 830,
	98457	+ /* 100 */ 842, 847, 854, 846, 843, 833, 832, 666, 834, 835,
	98458	+ /* 110 */ 959, 959, 959, 959, 959, 959, 959, 959, 959, 959,
	98459	+ /* 120 */ 959, 959, 959, 959, 959, 959, 661, 728, 959, 959,
	98460	+ /* 130 */ 959, 959, 959, 959, 836, 837, 851, 850, 849, 959,
	98461	+ /* 140 */ 959, 959, 959, 959, 959, 959, 959, 959, 959, 959,
	98462	+ /* 150 */ 959, 939, 937, 959, 883, 959, 959, 959, 959, 959,
	98463	+ /* 160 */ 959, 959, 959, 959, 959, 959, 959, 959, 959, 959,
	98464	+ /* 170 */ 959, 959, 959, 959, 959, 959, 959, 959, 959, 959,
	98465	+ /* 180 */ 959, 641, 959, 759, 759, 759, 635, 959, 959, 959,
	98466	+ /* 190 */ 959, 951, 763, 753, 719, 959, 959, 959, 959, 959,
	98467	+ /* 200 */ 959, 959, 959, 959, 959, 959, 959, 804, 742, 922,
	98468	+ /* 210 */ 924, 959, 905, 740, 663, 761, 676, 751, 643, 798,
	98469	+ /* 220 */ 776, 776, 917, 798, 917, 700, 959, 788, 959, 788,
	98470	+ /* 230 */ 697, 788, 776, 788, 788, 866, 959, 959, 959, 760,
	98471	+ /* 240 */ 751, 959, 944, 767, 767, 936, 936, 767, 810, 732,
	98472	+ /* 250 */ 798, 739, 739, 739, 739, 767, 798, 810, 732, 732,
	98473	+ /* 260 */ 767, 658, 911, 909, 767, 767, 658, 767, 658, 767,
	98474	+ /* 270 */ 658, 876, 730, 730, 730, 715, 880, 880, 876, 730,
	98475	+ /* 280 */ 700, 730, 715, 730, 730, 780, 775, 780, 775, 780,
	98476	+ /* 290 */ 775, 767, 767, 959, 793, 781, 791, 789, 798, 959,
	98477	+ /* 300 */ 718, 651, 651, 640, 640, 640, 640, 956, 956, 951,
	98478	+ /* 310 */ 702, 702, 684, 959, 959, 959, 959, 959, 959, 959,
	98479	+ /* 320 */ 885, 959, 959, 959, 959, 959, 959, 959, 959, 959,
	98480	+ /* 330 */ 959, 959, 959, 959, 636, 946, 959, 959, 943, 959,
	98481	+ /* 340 */ 959, 959, 959, 959, 959, 959, 959, 959, 959, 959,
	98482	+ /* 350 */ 959, 959, 959, 959, 959, 959, 959, 959, 959, 915,
	98483	+ /* 360 */ 959, 959, 959, 959, 959, 959, 908, 907, 959, 959,
	98484	+ /* 370 */ 959, 959, 959, 959, 959, 959, 959, 959, 959, 959,
	98485	+ /* 380 */ 959, 959, 959, 959, 959, 959, 959, 959, 959, 959,
	98486	+ /* 390 */ 959, 959, 959, 959, 790, 959, 782, 959, 869, 959,
	98487	+ /* 400 */ 959, 959, 959, 959, 959, 959, 959, 959, 959, 745,
	98488	+ /* 410 */ 819, 959, 818, 822, 817, 668, 959, 649, 959, 632,
	98489	+ /* 420 */ 637, 955, 958, 957, 954, 953, 952, 947, 945, 942,
	98490	+ /* 430 */ 941, 940, 938, 935, 931, 889, 887, 894, 893, 892,
	98491	+ /* 440 */ 891, 890, 888, 886, 884, 805, 803, 800, 797, 930,
	98492	+ /* 450 */ 882, 741, 738, 737, 657, 948, 914, 923, 921, 811,
	98493	+ /* 460 */ 920, 919, 918, 916, 913, 900, 807, 806, 733, 874,
	98494	+ /* 470 */ 873, 660, 904, 903, 902, 906, 910, 901, 769, 659,
	98495	+ /* 480 */ 656, 665, 722, 721, 729, 727, 726, 725, 724, 723,
	98496	+ /* 490 */ 720, 667, 675, 686, 714, 699, 698, 879, 881, 878,
	98497	+ /* 500 */ 877, 707, 706, 712, 711, 710, 709, 708, 705, 704,
	98498	+ /* 510 */ 703, 696, 695, 701, 694, 717, 716, 713, 693, 736,
	98499	+ /* 520 */ 735, 734, 731, 692, 691, 690, 822, 689, 688, 828,
	98500	+ /* 530 */ 827, 815, 858, 756, 755, 754, 766, 765, 778, 777,
	98501	+ /* 540 */ 813, 812, 779, 764, 758, 757, 773, 772, 771, 770,
	98502	+ /* 550 */ 762, 752, 784, 787, 786, 783, 860, 768, 857, 929,
	98503	+ /* 560 */ 928, 927, 926, 925, 862, 861, 829, 826, 679, 680,
	98504	+ /* 570 */ 898, 896, 897, 895, 682, 681, 678, 677, 859, 747,
	98505	+ /* 580 */ 746, 855, 852, 844, 840, 856, 853, 845, 841, 839,
	98506	+ /* 590 */ 838, 824, 823, 821, 820, 816, 825, 670, 748, 744,
	98507	+ /* 600 */ 743, 814, 750, 749, 687, 685, 683, 664, 662, 655,
	98508	+ /* 610 */ 653, 652, 654, 650, 648, 647, 646, 645, 644, 673,
	98509	+ /* 620 */ 672, 671, 669, 668, 642, 639, 638, 634, 633, 631,
98283	98510	};
98284	98511
98285	98512	/* The next table maps tokens into fallback tokens. If a construct
98286	98513	** like the following:
98287	98514	**
		@@ -98491,19 +98718,18 @@
98491	98718	"groupby_opt", "having_opt", "orderby_opt", "limit_opt",
98492	98719	"sclp", "as", "seltablist", "stl_prefix",
98493	98720	"joinop", "indexed_opt", "on_opt", "using_opt",
98494	98721	"joinop2", "inscollist", "sortlist", "sortitem",
98495	98722	"nexprlist", "setlist", "insert_cmd", "inscollist_opt",
98496		- "itemlist", "exprlist", "likeop", "escape",
98497		- "between_op", "in_op", "case_operand", "case_exprlist",
98498		- "case_else", "uniqueflag", "collate", "nmnum",
98499		- "plus_opt", "number", "trigger_decl", "trigger_cmd_list",
98500		- "trigger_time", "trigger_event", "foreach_clause", "when_clause",
98501		- "trigger_cmd", "trnm", "tridxby", "database_kw_opt",
98502		- "key_opt", "add_column_fullname", "kwcolumn_opt", "create_vtab",
98503		- "vtabarglist", "vtabarg", "vtabargtoken", "lp",
98504		- "anylist",
	98723	+ "itemlist", "exprlist", "likeop", "between_op",
	98724	+ "in_op", "case_operand", "case_exprlist", "case_else",
	98725	+ "uniqueflag", "collate", "nmnum", "plus_opt",
	98726	+ "number", "trigger_decl", "trigger_cmd_list", "trigger_time",
	98727	+ "trigger_event", "foreach_clause", "when_clause", "trigger_cmd",
	98728	+ "trnm", "tridxby", "database_kw_opt", "key_opt",
	98729	+ "add_column_fullname", "kwcolumn_opt", "create_vtab", "vtabarglist",
	98730	+ "vtabarg", "vtabargtoken", "lp", "anylist",
98505	98731	};
98506	98732	#endif /* NDEBUG */
98507	98733
98508	98734	#ifndef NDEBUG
98509	98735	/* For tracing reduce actions, the names of all rules are required.
		@@ -98719,128 +98945,127 @@
98719	98945	/* 207 */ "expr ::= expr CONCAT expr",
98720	98946	/* 208 */ "likeop ::= LIKE_KW",
98721	98947	/* 209 */ "likeop ::= NOT LIKE_KW",
98722	98948	/* 210 */ "likeop ::= MATCH",
98723	98949	/* 211 */ "likeop ::= NOT MATCH",
98724		- /* 212 */ "escape ::= ESCAPE expr",
98725		- /* 213 */ "escape ::=",
98726		- /* 214 */ "expr ::= expr likeop expr escape",
98727		- /* 215 */ "expr ::= expr ISNULL\|NOTNULL",
98728		- /* 216 */ "expr ::= expr NOT NULL",
98729		- /* 217 */ "expr ::= expr IS expr",
98730		- /* 218 */ "expr ::= expr IS NOT expr",
98731		- /* 219 */ "expr ::= NOT expr",
98732		- /* 220 */ "expr ::= BITNOT expr",
98733		- /* 221 */ "expr ::= MINUS expr",
98734		- /* 222 */ "expr ::= PLUS expr",
98735		- /* 223 */ "between_op ::= BETWEEN",
98736		- /* 224 */ "between_op ::= NOT BETWEEN",
98737		- /* 225 */ "expr ::= expr between_op expr AND expr",
98738		- /* 226 */ "in_op ::= IN",
98739		- /* 227 */ "in_op ::= NOT IN",
98740		- /* 228 */ "expr ::= expr in_op LP exprlist RP",
98741		- /* 229 */ "expr ::= LP select RP",
98742		- /* 230 */ "expr ::= expr in_op LP select RP",
98743		- /* 231 */ "expr ::= expr in_op nm dbnm",
98744		- /* 232 */ "expr ::= EXISTS LP select RP",
98745		- /* 233 */ "expr ::= CASE case_operand case_exprlist case_else END",
98746		- /* 234 */ "case_exprlist ::= case_exprlist WHEN expr THEN expr",
98747		- /* 235 */ "case_exprlist ::= WHEN expr THEN expr",
98748		- /* 236 */ "case_else ::= ELSE expr",
98749		- /* 237 */ "case_else ::=",
98750		- /* 238 */ "case_operand ::= expr",
98751		- /* 239 */ "case_operand ::=",
98752		- /* 240 */ "exprlist ::= nexprlist",
98753		- /* 241 */ "exprlist ::=",
98754		- /* 242 */ "nexprlist ::= nexprlist COMMA expr",
98755		- /* 243 */ "nexprlist ::= expr",
98756		- /* 244 */ "cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP idxlist RP",
98757		- /* 245 */ "uniqueflag ::= UNIQUE",
98758		- /* 246 */ "uniqueflag ::=",
98759		- /* 247 */ "idxlist_opt ::=",
98760		- /* 248 */ "idxlist_opt ::= LP idxlist RP",
98761		- /* 249 */ "idxlist ::= idxlist COMMA nm collate sortorder",
98762		- /* 250 */ "idxlist ::= nm collate sortorder",
98763		- /* 251 */ "collate ::=",
98764		- /* 252 */ "collate ::= COLLATE ids",
98765		- /* 253 */ "cmd ::= DROP INDEX ifexists fullname",
98766		- /* 254 */ "cmd ::= VACUUM",
98767		- /* 255 */ "cmd ::= VACUUM nm",
98768		- /* 256 */ "cmd ::= PRAGMA nm dbnm",
98769		- /* 257 */ "cmd ::= PRAGMA nm dbnm EQ nmnum",
98770		- /* 258 */ "cmd ::= PRAGMA nm dbnm LP nmnum RP",
98771		- /* 259 */ "cmd ::= PRAGMA nm dbnm EQ minus_num",
98772		- /* 260 */ "cmd ::= PRAGMA nm dbnm LP minus_num RP",
98773		- /* 261 */ "nmnum ::= plus_num",
98774		- /* 262 */ "nmnum ::= nm",
98775		- /* 263 */ "nmnum ::= ON",
98776		- /* 264 */ "nmnum ::= DELETE",
98777		- /* 265 */ "nmnum ::= DEFAULT",
98778		- /* 266 */ "plus_num ::= plus_opt number",
98779		- /* 267 */ "minus_num ::= MINUS number",
98780		- /* 268 */ "number ::= INTEGER\|FLOAT",
98781		- /* 269 */ "plus_opt ::= PLUS",
98782		- /* 270 */ "plus_opt ::=",
98783		- /* 271 */ "cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END",
98784		- /* 272 */ "trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause",
98785		- /* 273 */ "trigger_time ::= BEFORE",
98786		- /* 274 */ "trigger_time ::= AFTER",
98787		- /* 275 */ "trigger_time ::= INSTEAD OF",
98788		- /* 276 */ "trigger_time ::=",
98789		- /* 277 */ "trigger_event ::= DELETE\|INSERT",
98790		- /* 278 */ "trigger_event ::= UPDATE",
98791		- /* 279 */ "trigger_event ::= UPDATE OF inscollist",
98792		- /* 280 */ "foreach_clause ::=",
98793		- /* 281 */ "foreach_clause ::= FOR EACH ROW",
98794		- /* 282 */ "when_clause ::=",
98795		- /* 283 */ "when_clause ::= WHEN expr",
98796		- /* 284 */ "trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI",
98797		- /* 285 */ "trigger_cmd_list ::= trigger_cmd SEMI",
98798		- /* 286 */ "trnm ::= nm",
98799		- /* 287 */ "trnm ::= nm DOT nm",
98800		- /* 288 */ "tridxby ::=",
98801		- /* 289 */ "tridxby ::= INDEXED BY nm",
98802		- /* 290 */ "tridxby ::= NOT INDEXED",
98803		- /* 291 */ "trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist where_opt",
98804		- /* 292 */ "trigger_cmd ::= insert_cmd INTO trnm inscollist_opt VALUES LP itemlist RP",
98805		- /* 293 */ "trigger_cmd ::= insert_cmd INTO trnm inscollist_opt select",
98806		- /* 294 */ "trigger_cmd ::= DELETE FROM trnm tridxby where_opt",
98807		- /* 295 */ "trigger_cmd ::= select",
98808		- /* 296 */ "expr ::= RAISE LP IGNORE RP",
98809		- /* 297 */ "expr ::= RAISE LP raisetype COMMA nm RP",
98810		- /* 298 */ "raisetype ::= ROLLBACK",
98811		- /* 299 */ "raisetype ::= ABORT",
98812		- /* 300 */ "raisetype ::= FAIL",
98813		- /* 301 */ "cmd ::= DROP TRIGGER ifexists fullname",
98814		- /* 302 */ "cmd ::= ATTACH database_kw_opt expr AS expr key_opt",
98815		- /* 303 */ "cmd ::= DETACH database_kw_opt expr",
98816		- /* 304 */ "key_opt ::=",
98817		- /* 305 */ "key_opt ::= KEY expr",
98818		- /* 306 */ "database_kw_opt ::= DATABASE",
98819		- /* 307 */ "database_kw_opt ::=",
98820		- /* 308 */ "cmd ::= REINDEX",
98821		- /* 309 */ "cmd ::= REINDEX nm dbnm",
98822		- /* 310 */ "cmd ::= ANALYZE",
98823		- /* 311 */ "cmd ::= ANALYZE nm dbnm",
98824		- /* 312 */ "cmd ::= ALTER TABLE fullname RENAME TO nm",
98825		- /* 313 */ "cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt column",
98826		- /* 314 */ "add_column_fullname ::= fullname",
98827		- /* 315 */ "kwcolumn_opt ::=",
98828		- /* 316 */ "kwcolumn_opt ::= COLUMNKW",
98829		- /* 317 */ "cmd ::= create_vtab",
98830		- /* 318 */ "cmd ::= create_vtab LP vtabarglist RP",
98831		- /* 319 */ "create_vtab ::= createkw VIRTUAL TABLE nm dbnm USING nm",
98832		- /* 320 */ "vtabarglist ::= vtabarg",
98833		- /* 321 */ "vtabarglist ::= vtabarglist COMMA vtabarg",
98834		- /* 322 */ "vtabarg ::=",
98835		- /* 323 */ "vtabarg ::= vtabarg vtabargtoken",
98836		- /* 324 */ "vtabargtoken ::= ANY",
98837		- /* 325 */ "vtabargtoken ::= lp anylist RP",
98838		- /* 326 */ "lp ::= LP",
98839		- /* 327 */ "anylist ::=",
98840		- /* 328 */ "anylist ::= anylist LP anylist RP",
98841		- /* 329 */ "anylist ::= anylist ANY",
	98950	+ /* 212 */ "expr ::= expr likeop expr",
	98951	+ /* 213 */ "expr ::= expr likeop expr ESCAPE expr",
	98952	+ /* 214 */ "expr ::= expr ISNULL\|NOTNULL",
	98953	+ /* 215 */ "expr ::= expr NOT NULL",
	98954	+ /* 216 */ "expr ::= expr IS expr",
	98955	+ /* 217 */ "expr ::= expr IS NOT expr",
	98956	+ /* 218 */ "expr ::= NOT expr",
	98957	+ /* 219 */ "expr ::= BITNOT expr",
	98958	+ /* 220 */ "expr ::= MINUS expr",
	98959	+ /* 221 */ "expr ::= PLUS expr",
	98960	+ /* 222 */ "between_op ::= BETWEEN",
	98961	+ /* 223 */ "between_op ::= NOT BETWEEN",
	98962	+ /* 224 */ "expr ::= expr between_op expr AND expr",
	98963	+ /* 225 */ "in_op ::= IN",
	98964	+ /* 226 */ "in_op ::= NOT IN",
	98965	+ /* 227 */ "expr ::= expr in_op LP exprlist RP",
	98966	+ /* 228 */ "expr ::= LP select RP",
	98967	+ /* 229 */ "expr ::= expr in_op LP select RP",
	98968	+ /* 230 */ "expr ::= expr in_op nm dbnm",
	98969	+ /* 231 */ "expr ::= EXISTS LP select RP",
	98970	+ /* 232 */ "expr ::= CASE case_operand case_exprlist case_else END",
	98971	+ /* 233 */ "case_exprlist ::= case_exprlist WHEN expr THEN expr",
	98972	+ /* 234 */ "case_exprlist ::= WHEN expr THEN expr",
	98973	+ /* 235 */ "case_else ::= ELSE expr",
	98974	+ /* 236 */ "case_else ::=",
	98975	+ /* 237 */ "case_operand ::= expr",
	98976	+ /* 238 */ "case_operand ::=",
	98977	+ /* 239 */ "exprlist ::= nexprlist",
	98978	+ /* 240 */ "exprlist ::=",
	98979	+ /* 241 */ "nexprlist ::= nexprlist COMMA expr",
	98980	+ /* 242 */ "nexprlist ::= expr",
	98981	+ /* 243 */ "cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP idxlist RP",
	98982	+ /* 244 */ "uniqueflag ::= UNIQUE",
	98983	+ /* 245 */ "uniqueflag ::=",
	98984	+ /* 246 */ "idxlist_opt ::=",
	98985	+ /* 247 */ "idxlist_opt ::= LP idxlist RP",
	98986	+ /* 248 */ "idxlist ::= idxlist COMMA nm collate sortorder",
	98987	+ /* 249 */ "idxlist ::= nm collate sortorder",
	98988	+ /* 250 */ "collate ::=",
	98989	+ /* 251 */ "collate ::= COLLATE ids",
	98990	+ /* 252 */ "cmd ::= DROP INDEX ifexists fullname",
	98991	+ /* 253 */ "cmd ::= VACUUM",
	98992	+ /* 254 */ "cmd ::= VACUUM nm",
	98993	+ /* 255 */ "cmd ::= PRAGMA nm dbnm",
	98994	+ /* 256 */ "cmd ::= PRAGMA nm dbnm EQ nmnum",
	98995	+ /* 257 */ "cmd ::= PRAGMA nm dbnm LP nmnum RP",
	98996	+ /* 258 */ "cmd ::= PRAGMA nm dbnm EQ minus_num",
	98997	+ /* 259 */ "cmd ::= PRAGMA nm dbnm LP minus_num RP",
	98998	+ /* 260 */ "nmnum ::= plus_num",
	98999	+ /* 261 */ "nmnum ::= nm",
	99000	+ /* 262 */ "nmnum ::= ON",
	99001	+ /* 263 */ "nmnum ::= DELETE",
	99002	+ /* 264 */ "nmnum ::= DEFAULT",
	99003	+ /* 265 */ "plus_num ::= plus_opt number",
	99004	+ /* 266 */ "minus_num ::= MINUS number",
	99005	+ /* 267 */ "number ::= INTEGER\|FLOAT",
	99006	+ /* 268 */ "plus_opt ::= PLUS",
	99007	+ /* 269 */ "plus_opt ::=",
	99008	+ /* 270 */ "cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END",
	99009	+ /* 271 */ "trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause",
	99010	+ /* 272 */ "trigger_time ::= BEFORE",
	99011	+ /* 273 */ "trigger_time ::= AFTER",
	99012	+ /* 274 */ "trigger_time ::= INSTEAD OF",
	99013	+ /* 275 */ "trigger_time ::=",
	99014	+ /* 276 */ "trigger_event ::= DELETE\|INSERT",
	99015	+ /* 277 */ "trigger_event ::= UPDATE",
	99016	+ /* 278 */ "trigger_event ::= UPDATE OF inscollist",
	99017	+ /* 279 */ "foreach_clause ::=",
	99018	+ /* 280 */ "foreach_clause ::= FOR EACH ROW",
	99019	+ /* 281 */ "when_clause ::=",
	99020	+ /* 282 */ "when_clause ::= WHEN expr",
	99021	+ /* 283 */ "trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI",
	99022	+ /* 284 */ "trigger_cmd_list ::= trigger_cmd SEMI",
	99023	+ /* 285 */ "trnm ::= nm",
	99024	+ /* 286 */ "trnm ::= nm DOT nm",
	99025	+ /* 287 */ "tridxby ::=",
	99026	+ /* 288 */ "tridxby ::= INDEXED BY nm",
	99027	+ /* 289 */ "tridxby ::= NOT INDEXED",
	99028	+ /* 290 */ "trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist where_opt",
	99029	+ /* 291 */ "trigger_cmd ::= insert_cmd INTO trnm inscollist_opt VALUES LP itemlist RP",
	99030	+ /* 292 */ "trigger_cmd ::= insert_cmd INTO trnm inscollist_opt select",
	99031	+ /* 293 */ "trigger_cmd ::= DELETE FROM trnm tridxby where_opt",
	99032	+ /* 294 */ "trigger_cmd ::= select",
	99033	+ /* 295 */ "expr ::= RAISE LP IGNORE RP",
	99034	+ /* 296 */ "expr ::= RAISE LP raisetype COMMA nm RP",
	99035	+ /* 297 */ "raisetype ::= ROLLBACK",
	99036	+ /* 298 */ "raisetype ::= ABORT",
	99037	+ /* 299 */ "raisetype ::= FAIL",
	99038	+ /* 300 */ "cmd ::= DROP TRIGGER ifexists fullname",
	99039	+ /* 301 */ "cmd ::= ATTACH database_kw_opt expr AS expr key_opt",
	99040	+ /* 302 */ "cmd ::= DETACH database_kw_opt expr",
	99041	+ /* 303 */ "key_opt ::=",
	99042	+ /* 304 */ "key_opt ::= KEY expr",
	99043	+ /* 305 */ "database_kw_opt ::= DATABASE",
	99044	+ /* 306 */ "database_kw_opt ::=",
	99045	+ /* 307 */ "cmd ::= REINDEX",
	99046	+ /* 308 */ "cmd ::= REINDEX nm dbnm",
	99047	+ /* 309 */ "cmd ::= ANALYZE",
	99048	+ /* 310 */ "cmd ::= ANALYZE nm dbnm",
	99049	+ /* 311 */ "cmd ::= ALTER TABLE fullname RENAME TO nm",
	99050	+ /* 312 */ "cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt column",
	99051	+ /* 313 */ "add_column_fullname ::= fullname",
	99052	+ /* 314 */ "kwcolumn_opt ::=",
	99053	+ /* 315 */ "kwcolumn_opt ::= COLUMNKW",
	99054	+ /* 316 */ "cmd ::= create_vtab",
	99055	+ /* 317 */ "cmd ::= create_vtab LP vtabarglist RP",
	99056	+ /* 318 */ "create_vtab ::= createkw VIRTUAL TABLE nm dbnm USING nm",
	99057	+ /* 319 */ "vtabarglist ::= vtabarg",
	99058	+ /* 320 */ "vtabarglist ::= vtabarglist COMMA vtabarg",
	99059	+ /* 321 */ "vtabarg ::=",
	99060	+ /* 322 */ "vtabarg ::= vtabarg vtabargtoken",
	99061	+ /* 323 */ "vtabargtoken ::= ANY",
	99062	+ /* 324 */ "vtabargtoken ::= lp anylist RP",
	99063	+ /* 325 */ "lp ::= LP",
	99064	+ /* 326 */ "anylist ::=",
	99065	+ /* 327 */ "anylist ::= anylist LP anylist RP",
	99066	+ /* 328 */ "anylist ::= anylist ANY",
98842	99067	};
98843	99068	#endif /* NDEBUG */
98844	99069
98845	99070
98846	99071	#if YYSTACKDEPTH<=0
		@@ -98918,18 +99143,17 @@
98918	99143	** inside the C code.
98919	99144	*/
98920	99145	case 160: /* select */
98921	99146	case 194: /* oneselect */
98922	99147	{
98923		-sqlite3SelectDelete(pParse->db, (yypminor->yy3));
	99148	+sqlite3SelectDelete(pParse->db, (yypminor->yy387));
98924	99149	}
98925	99150	break;
98926	99151	case 174: /* term */
98927	99152	case 175: /* expr */
98928		- case 223: /* escape */
98929	99153	{
98930		-sqlite3ExprDelete(pParse->db, (yypminor->yy346).pExpr);
	99154	+sqlite3ExprDelete(pParse->db, (yypminor->yy118).pExpr);
98931	99155	}
98932	99156	break;
98933	99157	case 179: /* idxlist_opt */
98934	99158	case 187: /* idxlist */
98935	99159	case 197: /* selcollist */
		@@ -98939,51 +99163,51 @@
98939	99163	case 214: /* sortlist */
98940	99164	case 216: /* nexprlist */
98941	99165	case 217: /* setlist */
98942	99166	case 220: /* itemlist */
98943	99167	case 221: /* exprlist */
98944		- case 227: /* case_exprlist */
	99168	+ case 226: /* case_exprlist */
98945	99169	{
98946		-sqlite3ExprListDelete(pParse->db, (yypminor->yy14));
	99170	+sqlite3ExprListDelete(pParse->db, (yypminor->yy322));
98947	99171	}
98948	99172	break;
98949	99173	case 193: /* fullname */
98950	99174	case 198: /* from */
98951	99175	case 206: /* seltablist */
98952	99176	case 207: /* stl_prefix */
98953	99177	{
98954		-sqlite3SrcListDelete(pParse->db, (yypminor->yy65));
	99178	+sqlite3SrcListDelete(pParse->db, (yypminor->yy259));
98955	99179	}
98956	99180	break;
98957	99181	case 199: /* where_opt */
98958	99182	case 201: /* having_opt */
98959	99183	case 210: /* on_opt */
98960	99184	case 215: /* sortitem */
98961		- case 226: /* case_operand */
98962		- case 228: /* case_else */
98963		- case 239: /* when_clause */
98964		- case 244: /* key_opt */
	99185	+ case 225: /* case_operand */
	99186	+ case 227: /* case_else */
	99187	+ case 238: /* when_clause */
	99188	+ case 243: /* key_opt */
98965	99189	{
98966		-sqlite3ExprDelete(pParse->db, (yypminor->yy132));
	99190	+sqlite3ExprDelete(pParse->db, (yypminor->yy314));
98967	99191	}
98968	99192	break;
98969	99193	case 211: /* using_opt */
98970	99194	case 213: /* inscollist */
98971	99195	case 219: /* inscollist_opt */
98972	99196	{
98973		-sqlite3IdListDelete(pParse->db, (yypminor->yy408));
	99197	+sqlite3IdListDelete(pParse->db, (yypminor->yy384));
98974	99198	}
98975	99199	break;
98976		- case 235: /* trigger_cmd_list */
98977		- case 240: /* trigger_cmd */
	99200	+ case 234: /* trigger_cmd_list */
	99201	+ case 239: /* trigger_cmd */
98978	99202	{
98979		-sqlite3DeleteTriggerStep(pParse->db, (yypminor->yy473));
	99203	+sqlite3DeleteTriggerStep(pParse->db, (yypminor->yy203));
98980	99204	}
98981	99205	break;
98982		- case 237: /* trigger_event */
	99206	+ case 236: /* trigger_event */
98983	99207	{
98984		-sqlite3IdListDelete(pParse->db, (yypminor->yy378).b);
	99208	+sqlite3IdListDelete(pParse->db, (yypminor->yy90).b);
98985	99209	}
98986	99210	break;
98987	99211	default: break; /* If no destructor action specified: do nothing */
98988	99212	}
98989	99213	}
		@@ -99437,128 +99661,127 @@
99437	99661	{ 175, 3 },
99438	99662	{ 222, 1 },
99439	99663	{ 222, 2 },
99440	99664	{ 222, 1 },
99441	99665	{ 222, 2 },
99442		- { 223, 2 },
99443		- { 223, 0 },
99444		- { 175, 4 },
	99666	+ { 175, 3 },
	99667	+ { 175, 5 },
99445	99668	{ 175, 2 },
99446	99669	{ 175, 3 },
99447	99670	{ 175, 3 },
99448	99671	{ 175, 4 },
99449	99672	{ 175, 2 },
99450	99673	{ 175, 2 },
99451	99674	{ 175, 2 },
99452	99675	{ 175, 2 },
	99676	+ { 223, 1 },
	99677	+ { 223, 2 },
	99678	+ { 175, 5 },
99453	99679	{ 224, 1 },
99454	99680	{ 224, 2 },
99455		- { 175, 5 },
99456		- { 225, 1 },
99457		- { 225, 2 },
99458	99681	{ 175, 5 },
99459	99682	{ 175, 3 },
99460	99683	{ 175, 5 },
99461	99684	{ 175, 4 },
99462	99685	{ 175, 4 },
99463	99686	{ 175, 5 },
99464		- { 227, 5 },
99465		- { 227, 4 },
99466		- { 228, 2 },
99467		- { 228, 0 },
99468		- { 226, 1 },
99469		- { 226, 0 },
	99687	+ { 226, 5 },
	99688	+ { 226, 4 },
	99689	+ { 227, 2 },
	99690	+ { 227, 0 },
	99691	+ { 225, 1 },
	99692	+ { 225, 0 },
99470	99693	{ 221, 1 },
99471	99694	{ 221, 0 },
99472	99695	{ 216, 3 },
99473	99696	{ 216, 1 },
99474	99697	{ 147, 11 },
99475		- { 229, 1 },
99476		- { 229, 0 },
	99698	+ { 228, 1 },
	99699	+ { 228, 0 },
99477	99700	{ 179, 0 },
99478	99701	{ 179, 3 },
99479	99702	{ 187, 5 },
99480	99703	{ 187, 3 },
99481		- { 230, 0 },
99482		- { 230, 2 },
	99704	+ { 229, 0 },
	99705	+ { 229, 2 },
99483	99706	{ 147, 4 },
99484	99707	{ 147, 1 },
99485	99708	{ 147, 2 },
99486	99709	{ 147, 3 },
99487	99710	{ 147, 5 },
99488	99711	{ 147, 6 },
99489	99712	{ 147, 5 },
99490	99713	{ 147, 6 },
99491		- { 231, 1 },
99492		- { 231, 1 },
99493		- { 231, 1 },
99494		- { 231, 1 },
99495		- { 231, 1 },
	99714	+ { 230, 1 },
	99715	+ { 230, 1 },
	99716	+ { 230, 1 },
	99717	+ { 230, 1 },
	99718	+ { 230, 1 },
99496	99719	{ 170, 2 },
99497	99720	{ 171, 2 },
99498		- { 233, 1 },
99499	99721	{ 232, 1 },
99500		- { 232, 0 },
	99722	+ { 231, 1 },
	99723	+ { 231, 0 },
99501	99724	{ 147, 5 },
99502		- { 234, 11 },
	99725	+ { 233, 11 },
	99726	+ { 235, 1 },
	99727	+ { 235, 1 },
	99728	+ { 235, 2 },
	99729	+ { 235, 0 },
99503	99730	{ 236, 1 },
99504	99731	{ 236, 1 },
99505		- { 236, 2 },
99506		- { 236, 0 },
99507		- { 237, 1 },
99508		- { 237, 1 },
	99732	+ { 236, 3 },
	99733	+ { 237, 0 },
99509	99734	{ 237, 3 },
99510	99735	{ 238, 0 },
99511		- { 238, 3 },
99512		- { 239, 0 },
99513		- { 239, 2 },
99514		- { 235, 3 },
99515		- { 235, 2 },
99516		- { 241, 1 },
	99736	+ { 238, 2 },
	99737	+ { 234, 3 },
	99738	+ { 234, 2 },
	99739	+ { 240, 1 },
	99740	+ { 240, 3 },
	99741	+ { 241, 0 },
99517	99742	{ 241, 3 },
99518		- { 242, 0 },
99519		- { 242, 3 },
99520		- { 242, 2 },
99521		- { 240, 7 },
99522		- { 240, 8 },
99523		- { 240, 5 },
99524		- { 240, 5 },
99525		- { 240, 1 },
	99743	+ { 241, 2 },
	99744	+ { 239, 7 },
	99745	+ { 239, 8 },
	99746	+ { 239, 5 },
	99747	+ { 239, 5 },
	99748	+ { 239, 1 },
99526	99749	{ 175, 4 },
99527	99750	{ 175, 6 },
99528	99751	{ 191, 1 },
99529	99752	{ 191, 1 },
99530	99753	{ 191, 1 },
99531	99754	{ 147, 4 },
99532	99755	{ 147, 6 },
99533	99756	{ 147, 3 },
99534		- { 244, 0 },
99535		- { 244, 2 },
99536		- { 243, 1 },
99537	99757	{ 243, 0 },
	99758	+ { 243, 2 },
	99759	+ { 242, 1 },
	99760	+ { 242, 0 },
99538	99761	{ 147, 1 },
99539	99762	{ 147, 3 },
99540	99763	{ 147, 1 },
99541	99764	{ 147, 3 },
99542	99765	{ 147, 6 },
99543	99766	{ 147, 6 },
	99767	+ { 244, 1 },
	99768	+ { 245, 0 },
99544	99769	{ 245, 1 },
99545		- { 246, 0 },
99546		- { 246, 1 },
99547	99770	{ 147, 1 },
99548	99771	{ 147, 4 },
99549		- { 247, 7 },
99550		- { 248, 1 },
99551		- { 248, 3 },
99552		- { 249, 0 },
99553		- { 249, 2 },
	99772	+ { 246, 7 },
	99773	+ { 247, 1 },
	99774	+ { 247, 3 },
	99775	+ { 248, 0 },
	99776	+ { 248, 2 },
	99777	+ { 249, 1 },
	99778	+ { 249, 3 },
99554	99779	{ 250, 1 },
99555		- { 250, 3 },
99556		- { 251, 1 },
99557		- { 252, 0 },
99558		- { 252, 4 },
99559		- { 252, 2 },
	99780	+ { 251, 0 },
	99781	+ { 251, 4 },
	99782	+ { 251, 2 },
99560	99783	};
99561	99784
99562	99785	static void yy_accept(yyParser); / Forward Declaration */
99563	99786
99564	99787	/*
		@@ -99622,21 +99845,21 @@
99622	99845	break;
99623	99846	case 8: /* cmdx ::= cmd */
99624	99847	{ sqlite3FinishCoding(pParse); }
99625	99848	break;
99626	99849	case 9: /* cmd ::= BEGIN transtype trans_opt */
99627		-{sqlite3BeginTransaction(pParse, yymsp[-1].minor.yy328);}
	99850	+{sqlite3BeginTransaction(pParse, yymsp[-1].minor.yy4);}
99628	99851	break;
99629	99852	case 13: /* transtype ::= */
99630		-{yygotominor.yy328 = TK_DEFERRED;}
	99853	+{yygotominor.yy4 = TK_DEFERRED;}
99631	99854	break;
99632	99855	case 14: /* transtype ::= DEFERRED */
99633	99856	case 15: /* transtype ::= IMMEDIATE */ yytestcase(yyruleno==15);
99634	99857	case 16: /* transtype ::= EXCLUSIVE */ yytestcase(yyruleno==16);
99635	99858	case 115: /* multiselect_op ::= UNION */ yytestcase(yyruleno==115);
99636	99859	case 117: /* multiselect_op ::= EXCEPT\|INTERSECT */ yytestcase(yyruleno==117);
99637		-{yygotominor.yy328 = yymsp[0].major;}
	99860	+{yygotominor.yy4 = yymsp[0].major;}
99638	99861	break;
99639	99862	case 17: /* cmd ::= COMMIT trans_opt */
99640	99863	case 18: /* cmd ::= END trans_opt */ yytestcase(yyruleno==18);
99641	99864	{sqlite3CommitTransaction(pParse);}
99642	99865	break;
		@@ -99658,11 +99881,11 @@
99658	99881	sqlite3Savepoint(pParse, SAVEPOINT_ROLLBACK, &yymsp[0].minor.yy0);
99659	99882	}
99660	99883	break;
99661	99884	case 26: /* create_table ::= createkw temp TABLE ifnotexists nm dbnm */
99662	99885	{
99663		- sqlite3StartTable(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,yymsp[-4].minor.yy328,0,0,yymsp[-2].minor.yy328);
	99886	+ sqlite3StartTable(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,yymsp[-4].minor.yy4,0,0,yymsp[-2].minor.yy4);
99664	99887	}
99665	99888	break;
99666	99889	case 27: /* createkw ::= CREATE */
99667	99890	{
99668	99891	pParse->db->lookaside.bEnabled = 0;
		@@ -99677,33 +99900,33 @@
99677	99900	case 87: /* init_deferred_pred_opt ::= INITIALLY IMMEDIATE */ yytestcase(yyruleno==87);
99678	99901	case 98: /* defer_subclause_opt ::= */ yytestcase(yyruleno==98);
99679	99902	case 109: /* ifexists ::= */ yytestcase(yyruleno==109);
99680	99903	case 120: /* distinct ::= ALL */ yytestcase(yyruleno==120);
99681	99904	case 121: /* distinct ::= */ yytestcase(yyruleno==121);
99682		- case 223: /* between_op ::= BETWEEN */ yytestcase(yyruleno==223);
99683		- case 226: /* in_op ::= IN */ yytestcase(yyruleno==226);
99684		-{yygotominor.yy328 = 0;}
	99905	+ case 222: /* between_op ::= BETWEEN */ yytestcase(yyruleno==222);
	99906	+ case 225: /* in_op ::= IN */ yytestcase(yyruleno==225);
	99907	+{yygotominor.yy4 = 0;}
99685	99908	break;
99686	99909	case 29: /* ifnotexists ::= IF NOT EXISTS */
99687	99910	case 30: /* temp ::= TEMP */ yytestcase(yyruleno==30);
99688	99911	case 71: /* autoinc ::= AUTOINCR */ yytestcase(yyruleno==71);
99689	99912	case 86: /* init_deferred_pred_opt ::= INITIALLY DEFERRED */ yytestcase(yyruleno==86);
99690	99913	case 108: /* ifexists ::= IF EXISTS */ yytestcase(yyruleno==108);
99691	99914	case 119: /* distinct ::= DISTINCT */ yytestcase(yyruleno==119);
99692		- case 224: /* between_op ::= NOT BETWEEN */ yytestcase(yyruleno==224);
99693		- case 227: /* in_op ::= NOT IN */ yytestcase(yyruleno==227);
99694		-{yygotominor.yy328 = 1;}
	99915	+ case 223: /* between_op ::= NOT BETWEEN */ yytestcase(yyruleno==223);
	99916	+ case 226: /* in_op ::= NOT IN */ yytestcase(yyruleno==226);
	99917	+{yygotominor.yy4 = 1;}
99695	99918	break;
99696	99919	case 32: /* create_table_args ::= LP columnlist conslist_opt RP */
99697	99920	{
99698	99921	sqlite3EndTable(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,0);
99699	99922	}
99700	99923	break;
99701	99924	case 33: /* create_table_args ::= AS select */
99702	99925	{
99703		- sqlite3EndTable(pParse,0,0,yymsp[0].minor.yy3);
99704		- sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy3);
	99926	+ sqlite3EndTable(pParse,0,0,yymsp[0].minor.yy387);
	99927	+ sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy387);
99705	99928	}
99706	99929	break;
99707	99930	case 36: /* column ::= columnid type carglist */
99708	99931	{
99709	99932	yygotominor.yy0.z = yymsp[-2].minor.yy0.z;
		@@ -99726,20 +99949,20 @@
99726	99949	case 49: /* typename ::= ids */ yytestcase(yyruleno==49);
99727	99950	case 127: /* as ::= AS nm */ yytestcase(yyruleno==127);
99728	99951	case 128: /* as ::= ids */ yytestcase(yyruleno==128);
99729	99952	case 138: /* dbnm ::= DOT nm */ yytestcase(yyruleno==138);
99730	99953	case 147: /* indexed_opt ::= INDEXED BY nm */ yytestcase(yyruleno==147);
99731		- case 252: /* collate ::= COLLATE ids */ yytestcase(yyruleno==252);
99732		- case 261: /* nmnum ::= plus_num */ yytestcase(yyruleno==261);
99733		- case 262: /* nmnum ::= nm */ yytestcase(yyruleno==262);
99734		- case 263: /* nmnum ::= ON */ yytestcase(yyruleno==263);
99735		- case 264: /* nmnum ::= DELETE */ yytestcase(yyruleno==264);
99736		- case 265: /* nmnum ::= DEFAULT */ yytestcase(yyruleno==265);
99737		- case 266: /* plus_num ::= plus_opt number */ yytestcase(yyruleno==266);
99738		- case 267: /* minus_num ::= MINUS number */ yytestcase(yyruleno==267);
99739		- case 268: /* number ::= INTEGER\|FLOAT */ yytestcase(yyruleno==268);
99740		- case 286: /* trnm ::= nm */ yytestcase(yyruleno==286);
	99954	+ case 251: /* collate ::= COLLATE ids */ yytestcase(yyruleno==251);
	99955	+ case 260: /* nmnum ::= plus_num */ yytestcase(yyruleno==260);
	99956	+ case 261: /* nmnum ::= nm */ yytestcase(yyruleno==261);
	99957	+ case 262: /* nmnum ::= ON */ yytestcase(yyruleno==262);
	99958	+ case 263: /* nmnum ::= DELETE */ yytestcase(yyruleno==263);
	99959	+ case 264: /* nmnum ::= DEFAULT */ yytestcase(yyruleno==264);
	99960	+ case 265: /* plus_num ::= plus_opt number */ yytestcase(yyruleno==265);
	99961	+ case 266: /* minus_num ::= MINUS number */ yytestcase(yyruleno==266);
	99962	+ case 267: /* number ::= INTEGER\|FLOAT */ yytestcase(yyruleno==267);
	99963	+ case 285: /* trnm ::= nm */ yytestcase(yyruleno==285);
99741	99964	{yygotominor.yy0 = yymsp[0].minor.yy0;}
99742	99965	break;
99743	99966	case 45: /* type ::= typetoken */
99744	99967	{sqlite3AddColumnType(pParse,&yymsp[0].minor.yy0);}
99745	99968	break;
		@@ -99758,21 +99981,21 @@
99758	99981	case 50: /* typename ::= typename ids */
99759	99982	{yygotominor.yy0.z=yymsp[-1].minor.yy0.z; yygotominor.yy0.n=yymsp[0].minor.yy0.n+(int)(yymsp[0].minor.yy0.z-yymsp[-1].minor.yy0.z);}
99760	99983	break;
99761	99984	case 57: /* ccons ::= DEFAULT term */
99762	99985	case 59: /* ccons ::= DEFAULT PLUS term */ yytestcase(yyruleno==59);
99763		-{sqlite3AddDefaultValue(pParse,&yymsp[0].minor.yy346);}
	99986	+{sqlite3AddDefaultValue(pParse,&yymsp[0].minor.yy118);}
99764	99987	break;
99765	99988	case 58: /* ccons ::= DEFAULT LP expr RP */
99766		-{sqlite3AddDefaultValue(pParse,&yymsp[-1].minor.yy346);}
	99989	+{sqlite3AddDefaultValue(pParse,&yymsp[-1].minor.yy118);}
99767	99990	break;
99768	99991	case 60: /* ccons ::= DEFAULT MINUS term */
99769	99992	{
99770	99993	ExprSpan v;
99771		- v.pExpr = sqlite3PExpr(pParse, TK_UMINUS, yymsp[0].minor.yy346.pExpr, 0, 0);
	99994	+ v.pExpr = sqlite3PExpr(pParse, TK_UMINUS, yymsp[0].minor.yy118.pExpr, 0, 0);
99772	99995	v.zStart = yymsp[-1].minor.yy0.z;
99773		- v.zEnd = yymsp[0].minor.yy346.zEnd;
	99996	+ v.zEnd = yymsp[0].minor.yy118.zEnd;
99774	99997	sqlite3AddDefaultValue(pParse,&v);
99775	99998	}
99776	99999	break;
99777	100000	case 61: /* ccons ::= DEFAULT id */
99778	100001	{
		@@ -99780,454 +100003,453 @@
99780	100003	spanExpr(&v, pParse, TK_STRING, &yymsp[0].minor.yy0);
99781	100004	sqlite3AddDefaultValue(pParse,&v);
99782	100005	}
99783	100006	break;
99784	100007	case 63: /* ccons ::= NOT NULL onconf */
99785		-{sqlite3AddNotNull(pParse, yymsp[0].minor.yy328);}
	100008	+{sqlite3AddNotNull(pParse, yymsp[0].minor.yy4);}
99786	100009	break;
99787	100010	case 64: /* ccons ::= PRIMARY KEY sortorder onconf autoinc */
99788		-{sqlite3AddPrimaryKey(pParse,0,yymsp[-1].minor.yy328,yymsp[0].minor.yy328,yymsp[-2].minor.yy328);}
	100011	+{sqlite3AddPrimaryKey(pParse,0,yymsp[-1].minor.yy4,yymsp[0].minor.yy4,yymsp[-2].minor.yy4);}
99789	100012	break;
99790	100013	case 65: /* ccons ::= UNIQUE onconf */
99791		-{sqlite3CreateIndex(pParse,0,0,0,0,yymsp[0].minor.yy328,0,0,0,0);}
	100014	+{sqlite3CreateIndex(pParse,0,0,0,0,yymsp[0].minor.yy4,0,0,0,0);}
99792	100015	break;
99793	100016	case 66: /* ccons ::= CHECK LP expr RP */
99794		-{sqlite3AddCheckConstraint(pParse,yymsp[-1].minor.yy346.pExpr);}
	100017	+{sqlite3AddCheckConstraint(pParse,yymsp[-1].minor.yy118.pExpr);}
99795	100018	break;
99796	100019	case 67: /* ccons ::= REFERENCES nm idxlist_opt refargs */
99797		-{sqlite3CreateForeignKey(pParse,0,&yymsp[-2].minor.yy0,yymsp[-1].minor.yy14,yymsp[0].minor.yy328);}
	100020	+{sqlite3CreateForeignKey(pParse,0,&yymsp[-2].minor.yy0,yymsp[-1].minor.yy322,yymsp[0].minor.yy4);}
99798	100021	break;
99799	100022	case 68: /* ccons ::= defer_subclause */
99800		-{sqlite3DeferForeignKey(pParse,yymsp[0].minor.yy328);}
	100023	+{sqlite3DeferForeignKey(pParse,yymsp[0].minor.yy4);}
99801	100024	break;
99802	100025	case 69: /* ccons ::= COLLATE ids */
99803	100026	{sqlite3AddCollateType(pParse, &yymsp[0].minor.yy0);}
99804	100027	break;
99805	100028	case 72: /* refargs ::= */
99806		-{ yygotominor.yy328 = OE_None0x0101; / EV: R-19803-45884 */}
	100029	+{ yygotominor.yy4 = OE_None0x0101; / EV: R-19803-45884 */}
99807	100030	break;
99808	100031	case 73: /* refargs ::= refargs refarg */
99809		-{ yygotominor.yy328 = (yymsp[-1].minor.yy328 & ~yymsp[0].minor.yy429.mask) \| yymsp[0].minor.yy429.value; }
	100032	+{ yygotominor.yy4 = (yymsp[-1].minor.yy4 & ~yymsp[0].minor.yy215.mask) \| yymsp[0].minor.yy215.value; }
99810	100033	break;
99811	100034	case 74: /* refarg ::= MATCH nm */
99812	100035	case 75: /* refarg ::= ON INSERT refact */ yytestcase(yyruleno==75);
99813		-{ yygotominor.yy429.value = 0; yygotominor.yy429.mask = 0x000000; }
	100036	+{ yygotominor.yy215.value = 0; yygotominor.yy215.mask = 0x000000; }
99814	100037	break;
99815	100038	case 76: /* refarg ::= ON DELETE refact */
99816		-{ yygotominor.yy429.value = yymsp[0].minor.yy328; yygotominor.yy429.mask = 0x0000ff; }
	100039	+{ yygotominor.yy215.value = yymsp[0].minor.yy4; yygotominor.yy215.mask = 0x0000ff; }
99817	100040	break;
99818	100041	case 77: /* refarg ::= ON UPDATE refact */
99819		-{ yygotominor.yy429.value = yymsp[0].minor.yy328<<8; yygotominor.yy429.mask = 0x00ff00; }
	100042	+{ yygotominor.yy215.value = yymsp[0].minor.yy4<<8; yygotominor.yy215.mask = 0x00ff00; }
99820	100043	break;
99821	100044	case 78: /* refact ::= SET NULL */
99822		-{ yygotominor.yy328 = OE_SetNull; /* EV: R-33326-45252 */}
	100045	+{ yygotominor.yy4 = OE_SetNull; /* EV: R-33326-45252 */}
99823	100046	break;
99824	100047	case 79: /* refact ::= SET DEFAULT */
99825		-{ yygotominor.yy328 = OE_SetDflt; /* EV: R-33326-45252 */}
	100048	+{ yygotominor.yy4 = OE_SetDflt; /* EV: R-33326-45252 */}
99826	100049	break;
99827	100050	case 80: /* refact ::= CASCADE */
99828		-{ yygotominor.yy328 = OE_Cascade; /* EV: R-33326-45252 */}
	100051	+{ yygotominor.yy4 = OE_Cascade; /* EV: R-33326-45252 */}
99829	100052	break;
99830	100053	case 81: /* refact ::= RESTRICT */
99831		-{ yygotominor.yy328 = OE_Restrict; /* EV: R-33326-45252 */}
	100054	+{ yygotominor.yy4 = OE_Restrict; /* EV: R-33326-45252 */}
99832	100055	break;
99833	100056	case 82: /* refact ::= NO ACTION */
99834		-{ yygotominor.yy328 = OE_None; /* EV: R-33326-45252 */}
	100057	+{ yygotominor.yy4 = OE_None; /* EV: R-33326-45252 */}
99835	100058	break;
99836	100059	case 84: /* defer_subclause ::= DEFERRABLE init_deferred_pred_opt */
99837	100060	case 99: /* defer_subclause_opt ::= defer_subclause */ yytestcase(yyruleno==99);
99838	100061	case 101: /* onconf ::= ON CONFLICT resolvetype */ yytestcase(yyruleno==101);
99839	100062	case 104: /* resolvetype ::= raisetype */ yytestcase(yyruleno==104);
99840		-{yygotominor.yy328 = yymsp[0].minor.yy328;}
	100063	+{yygotominor.yy4 = yymsp[0].minor.yy4;}
99841	100064	break;
99842	100065	case 88: /* conslist_opt ::= */
99843	100066	{yygotominor.yy0.n = 0; yygotominor.yy0.z = 0;}
99844	100067	break;
99845	100068	case 89: /* conslist_opt ::= COMMA conslist */
99846	100069	{yygotominor.yy0 = yymsp[-1].minor.yy0;}
99847	100070	break;
99848	100071	case 94: /* tcons ::= PRIMARY KEY LP idxlist autoinc RP onconf */
99849		-{sqlite3AddPrimaryKey(pParse,yymsp[-3].minor.yy14,yymsp[0].minor.yy328,yymsp[-2].minor.yy328,0);}
	100072	+{sqlite3AddPrimaryKey(pParse,yymsp[-3].minor.yy322,yymsp[0].minor.yy4,yymsp[-2].minor.yy4,0);}
99850	100073	break;
99851	100074	case 95: /* tcons ::= UNIQUE LP idxlist RP onconf */
99852		-{sqlite3CreateIndex(pParse,0,0,0,yymsp[-2].minor.yy14,yymsp[0].minor.yy328,0,0,0,0);}
	100075	+{sqlite3CreateIndex(pParse,0,0,0,yymsp[-2].minor.yy322,yymsp[0].minor.yy4,0,0,0,0);}
99853	100076	break;
99854	100077	case 96: /* tcons ::= CHECK LP expr RP onconf */
99855		-{sqlite3AddCheckConstraint(pParse,yymsp[-2].minor.yy346.pExpr);}
	100078	+{sqlite3AddCheckConstraint(pParse,yymsp[-2].minor.yy118.pExpr);}
99856	100079	break;
99857	100080	case 97: /* tcons ::= FOREIGN KEY LP idxlist RP REFERENCES nm idxlist_opt refargs defer_subclause_opt */
99858	100081	{
99859		- sqlite3CreateForeignKey(pParse, yymsp[-6].minor.yy14, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy14, yymsp[-1].minor.yy328);
99860		- sqlite3DeferForeignKey(pParse, yymsp[0].minor.yy328);
	100082	+ sqlite3CreateForeignKey(pParse, yymsp[-6].minor.yy322, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy322, yymsp[-1].minor.yy4);
	100083	+ sqlite3DeferForeignKey(pParse, yymsp[0].minor.yy4);
99861	100084	}
99862	100085	break;
99863	100086	case 100: /* onconf ::= */
99864		-{yygotominor.yy328 = OE_Default;}
	100087	+{yygotominor.yy4 = OE_Default;}
99865	100088	break;
99866	100089	case 102: /* orconf ::= */
99867		-{yygotominor.yy186 = OE_Default;}
	100090	+{yygotominor.yy210 = OE_Default;}
99868	100091	break;
99869	100092	case 103: /* orconf ::= OR resolvetype */
99870		-{yygotominor.yy186 = (u8)yymsp[0].minor.yy328;}
	100093	+{yygotominor.yy210 = (u8)yymsp[0].minor.yy4;}
99871	100094	break;
99872	100095	case 105: /* resolvetype ::= IGNORE */
99873		-{yygotominor.yy328 = OE_Ignore;}
	100096	+{yygotominor.yy4 = OE_Ignore;}
99874	100097	break;
99875	100098	case 106: /* resolvetype ::= REPLACE */
99876		-{yygotominor.yy328 = OE_Replace;}
	100099	+{yygotominor.yy4 = OE_Replace;}
99877	100100	break;
99878	100101	case 107: /* cmd ::= DROP TABLE ifexists fullname */
99879	100102	{
99880		- sqlite3DropTable(pParse, yymsp[0].minor.yy65, 0, yymsp[-1].minor.yy328);
	100103	+ sqlite3DropTable(pParse, yymsp[0].minor.yy259, 0, yymsp[-1].minor.yy4);
99881	100104	}
99882	100105	break;
99883	100106	case 110: /* cmd ::= createkw temp VIEW ifnotexists nm dbnm AS select */
99884	100107	{
99885		- sqlite3CreateView(pParse, &yymsp[-7].minor.yy0, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0, yymsp[0].minor.yy3, yymsp[-6].minor.yy328, yymsp[-4].minor.yy328);
	100108	+ sqlite3CreateView(pParse, &yymsp[-7].minor.yy0, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0, yymsp[0].minor.yy387, yymsp[-6].minor.yy4, yymsp[-4].minor.yy4);
99886	100109	}
99887	100110	break;
99888	100111	case 111: /* cmd ::= DROP VIEW ifexists fullname */
99889	100112	{
99890		- sqlite3DropTable(pParse, yymsp[0].minor.yy65, 1, yymsp[-1].minor.yy328);
	100113	+ sqlite3DropTable(pParse, yymsp[0].minor.yy259, 1, yymsp[-1].minor.yy4);
99891	100114	}
99892	100115	break;
99893	100116	case 112: /* cmd ::= select */
99894	100117	{
99895	100118	SelectDest dest = {SRT_Output, 0, 0, 0, 0};
99896		- sqlite3Select(pParse, yymsp[0].minor.yy3, &dest);
99897		- sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy3);
	100119	+ sqlite3Select(pParse, yymsp[0].minor.yy387, &dest);
	100120	+ sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy387);
99898	100121	}
99899	100122	break;
99900	100123	case 113: /* select ::= oneselect */
99901		-{yygotominor.yy3 = yymsp[0].minor.yy3;}
	100124	+{yygotominor.yy387 = yymsp[0].minor.yy387;}
99902	100125	break;
99903	100126	case 114: /* select ::= select multiselect_op oneselect */
99904	100127	{
99905		- if( yymsp[0].minor.yy3 ){
99906		- yymsp[0].minor.yy3->op = (u8)yymsp[-1].minor.yy328;
99907		- yymsp[0].minor.yy3->pPrior = yymsp[-2].minor.yy3;
	100128	+ if( yymsp[0].minor.yy387 ){
	100129	+ yymsp[0].minor.yy387->op = (u8)yymsp[-1].minor.yy4;
	100130	+ yymsp[0].minor.yy387->pPrior = yymsp[-2].minor.yy387;
99908	100131	}else{
99909		- sqlite3SelectDelete(pParse->db, yymsp[-2].minor.yy3);
	100132	+ sqlite3SelectDelete(pParse->db, yymsp[-2].minor.yy387);
99910	100133	}
99911		- yygotominor.yy3 = yymsp[0].minor.yy3;
	100134	+ yygotominor.yy387 = yymsp[0].minor.yy387;
99912	100135	}
99913	100136	break;
99914	100137	case 116: /* multiselect_op ::= UNION ALL */
99915		-{yygotominor.yy328 = TK_ALL;}
	100138	+{yygotominor.yy4 = TK_ALL;}
99916	100139	break;
99917	100140	case 118: /* oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */
99918	100141	{
99919		- yygotominor.yy3 = sqlite3SelectNew(pParse,yymsp[-6].minor.yy14,yymsp[-5].minor.yy65,yymsp[-4].minor.yy132,yymsp[-3].minor.yy14,yymsp[-2].minor.yy132,yymsp[-1].minor.yy14,yymsp[-7].minor.yy328,yymsp[0].minor.yy476.pLimit,yymsp[0].minor.yy476.pOffset);
	100142	+ yygotominor.yy387 = sqlite3SelectNew(pParse,yymsp[-6].minor.yy322,yymsp[-5].minor.yy259,yymsp[-4].minor.yy314,yymsp[-3].minor.yy322,yymsp[-2].minor.yy314,yymsp[-1].minor.yy322,yymsp[-7].minor.yy4,yymsp[0].minor.yy292.pLimit,yymsp[0].minor.yy292.pOffset);
99920	100143	}
99921	100144	break;
99922	100145	case 122: /* sclp ::= selcollist COMMA */
99923		- case 248: /* idxlist_opt ::= LP idxlist RP */ yytestcase(yyruleno==248);
99924		-{yygotominor.yy14 = yymsp[-1].minor.yy14;}
	100146	+ case 247: /* idxlist_opt ::= LP idxlist RP */ yytestcase(yyruleno==247);
	100147	+{yygotominor.yy322 = yymsp[-1].minor.yy322;}
99925	100148	break;
99926	100149	case 123: /* sclp ::= */
99927	100150	case 151: /* orderby_opt ::= */ yytestcase(yyruleno==151);
99928	100151	case 159: /* groupby_opt ::= */ yytestcase(yyruleno==159);
99929		- case 241: /* exprlist ::= */ yytestcase(yyruleno==241);
99930		- case 247: /* idxlist_opt ::= */ yytestcase(yyruleno==247);
99931		-{yygotominor.yy14 = 0;}
	100152	+ case 240: /* exprlist ::= */ yytestcase(yyruleno==240);
	100153	+ case 246: /* idxlist_opt ::= */ yytestcase(yyruleno==246);
	100154	+{yygotominor.yy322 = 0;}
99932	100155	break;
99933	100156	case 124: /* selcollist ::= sclp expr as */
99934	100157	{
99935		- yygotominor.yy14 = sqlite3ExprListAppend(pParse, yymsp[-2].minor.yy14, yymsp[-1].minor.yy346.pExpr);
99936		- if( yymsp[0].minor.yy0.n>0 ) sqlite3ExprListSetName(pParse, yygotominor.yy14, &yymsp[0].minor.yy0, 1);
99937		- sqlite3ExprListSetSpan(pParse,yygotominor.yy14,&yymsp[-1].minor.yy346);
	100158	+ yygotominor.yy322 = sqlite3ExprListAppend(pParse, yymsp[-2].minor.yy322, yymsp[-1].minor.yy118.pExpr);
	100159	+ if( yymsp[0].minor.yy0.n>0 ) sqlite3ExprListSetName(pParse, yygotominor.yy322, &yymsp[0].minor.yy0, 1);
	100160	+ sqlite3ExprListSetSpan(pParse,yygotominor.yy322,&yymsp[-1].minor.yy118);
99938	100161	}
99939	100162	break;
99940	100163	case 125: /* selcollist ::= sclp STAR */
99941	100164	{
99942	100165	Expr *p = sqlite3Expr(pParse->db, TK_ALL, 0);
99943		- yygotominor.yy14 = sqlite3ExprListAppend(pParse, yymsp[-1].minor.yy14, p);
	100166	+ yygotominor.yy322 = sqlite3ExprListAppend(pParse, yymsp[-1].minor.yy322, p);
99944	100167	}
99945	100168	break;
99946	100169	case 126: /* selcollist ::= sclp nm DOT STAR */
99947	100170	{
99948	100171	Expr *pRight = sqlite3PExpr(pParse, TK_ALL, 0, 0, &yymsp[0].minor.yy0);
99949	100172	Expr *pLeft = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[-2].minor.yy0);
99950	100173	Expr *pDot = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight, 0);
99951		- yygotominor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy14, pDot);
	100174	+ yygotominor.yy322 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy322, pDot);
99952	100175	}
99953	100176	break;
99954	100177	case 129: /* as ::= */
99955	100178	{yygotominor.yy0.n = 0;}
99956	100179	break;
99957	100180	case 130: /* from ::= */
99958		-{yygotominor.yy65 = sqlite3DbMallocZero(pParse->db, sizeof(*yygotominor.yy65));}
	100181	+{yygotominor.yy259 = sqlite3DbMallocZero(pParse->db, sizeof(*yygotominor.yy259));}
99959	100182	break;
99960	100183	case 131: /* from ::= FROM seltablist */
99961	100184	{
99962		- yygotominor.yy65 = yymsp[0].minor.yy65;
99963		- sqlite3SrcListShiftJoinType(yygotominor.yy65);
	100185	+ yygotominor.yy259 = yymsp[0].minor.yy259;
	100186	+ sqlite3SrcListShiftJoinType(yygotominor.yy259);
99964	100187	}
99965	100188	break;
99966	100189	case 132: /* stl_prefix ::= seltablist joinop */
99967	100190	{
99968		- yygotominor.yy65 = yymsp[-1].minor.yy65;
99969		- if( ALWAYS(yygotominor.yy65 && yygotominor.yy65->nSrc>0) ) yygotominor.yy65->a[yygotominor.yy65->nSrc-1].jointype = (u8)yymsp[0].minor.yy328;
	100191	+ yygotominor.yy259 = yymsp[-1].minor.yy259;
	100192	+ if( ALWAYS(yygotominor.yy259 && yygotominor.yy259->nSrc>0) ) yygotominor.yy259->a[yygotominor.yy259->nSrc-1].jointype = (u8)yymsp[0].minor.yy4;
99970	100193	}
99971	100194	break;
99972	100195	case 133: /* stl_prefix ::= */
99973		-{yygotominor.yy65 = 0;}
	100196	+{yygotominor.yy259 = 0;}
99974	100197	break;
99975	100198	case 134: /* seltablist ::= stl_prefix nm dbnm as indexed_opt on_opt using_opt */
99976	100199	{
99977		- yygotominor.yy65 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy65,&yymsp[-5].minor.yy0,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,0,yymsp[-1].minor.yy132,yymsp[0].minor.yy408);
99978		- sqlite3SrcListIndexedBy(pParse, yygotominor.yy65, &yymsp[-2].minor.yy0);
	100200	+ yygotominor.yy259 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy259,&yymsp[-5].minor.yy0,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,0,yymsp[-1].minor.yy314,yymsp[0].minor.yy384);
	100201	+ sqlite3SrcListIndexedBy(pParse, yygotominor.yy259, &yymsp[-2].minor.yy0);
99979	100202	}
99980	100203	break;
99981	100204	case 135: /* seltablist ::= stl_prefix LP select RP as on_opt using_opt */
99982	100205	{
99983		- yygotominor.yy65 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy65,0,0,&yymsp[-2].minor.yy0,yymsp[-4].minor.yy3,yymsp[-1].minor.yy132,yymsp[0].minor.yy408);
	100206	+ yygotominor.yy259 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy259,0,0,&yymsp[-2].minor.yy0,yymsp[-4].minor.yy387,yymsp[-1].minor.yy314,yymsp[0].minor.yy384);
99984	100207	}
99985	100208	break;
99986	100209	case 136: /* seltablist ::= stl_prefix LP seltablist RP as on_opt using_opt */
99987	100210	{
99988		- if( yymsp[-6].minor.yy65==0 && yymsp[-2].minor.yy0.n==0 && yymsp[-1].minor.yy132==0 && yymsp[0].minor.yy408==0 ){
99989		- yygotominor.yy65 = yymsp[-4].minor.yy65;
	100211	+ if( yymsp[-6].minor.yy259==0 && yymsp[-2].minor.yy0.n==0 && yymsp[-1].minor.yy314==0 && yymsp[0].minor.yy384==0 ){
	100212	+ yygotominor.yy259 = yymsp[-4].minor.yy259;
99990	100213	}else{
99991	100214	Select *pSubquery;
99992		- sqlite3SrcListShiftJoinType(yymsp[-4].minor.yy65);
99993		- pSubquery = sqlite3SelectNew(pParse,0,yymsp[-4].minor.yy65,0,0,0,0,0,0,0);
99994		- yygotominor.yy65 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy65,0,0,&yymsp[-2].minor.yy0,pSubquery,yymsp[-1].minor.yy132,yymsp[0].minor.yy408);
	100215	+ sqlite3SrcListShiftJoinType(yymsp[-4].minor.yy259);
	100216	+ pSubquery = sqlite3SelectNew(pParse,0,yymsp[-4].minor.yy259,0,0,0,0,0,0,0);
	100217	+ yygotominor.yy259 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy259,0,0,&yymsp[-2].minor.yy0,pSubquery,yymsp[-1].minor.yy314,yymsp[0].minor.yy384);
99995	100218	}
99996	100219	}
99997	100220	break;
99998	100221	case 137: /* dbnm ::= */
99999	100222	case 146: /* indexed_opt ::= */ yytestcase(yyruleno==146);
100000	100223	{yygotominor.yy0.z=0; yygotominor.yy0.n=0;}
100001	100224	break;
100002	100225	case 139: /* fullname ::= nm dbnm */
100003		-{yygotominor.yy65 = sqlite3SrcListAppend(pParse->db,0,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0);}
	100226	+{yygotominor.yy259 = sqlite3SrcListAppend(pParse->db,0,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0);}
100004	100227	break;
100005	100228	case 140: /* joinop ::= COMMA\|JOIN */
100006		-{ yygotominor.yy328 = JT_INNER; }
	100229	+{ yygotominor.yy4 = JT_INNER; }
100007	100230	break;
100008	100231	case 141: /* joinop ::= JOIN_KW JOIN */
100009		-{ yygotominor.yy328 = sqlite3JoinType(pParse,&yymsp[-1].minor.yy0,0,0); }
	100232	+{ yygotominor.yy4 = sqlite3JoinType(pParse,&yymsp[-1].minor.yy0,0,0); }
100010	100233	break;
100011	100234	case 142: /* joinop ::= JOIN_KW nm JOIN */
100012		-{ yygotominor.yy328 = sqlite3JoinType(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,0); }
	100235	+{ yygotominor.yy4 = sqlite3JoinType(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,0); }
100013	100236	break;
100014	100237	case 143: /* joinop ::= JOIN_KW nm nm JOIN */
100015		-{ yygotominor.yy328 = sqlite3JoinType(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0); }
	100238	+{ yygotominor.yy4 = sqlite3JoinType(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0); }
100016	100239	break;
100017	100240	case 144: /* on_opt ::= ON expr */
100018	100241	case 155: /* sortitem ::= expr */ yytestcase(yyruleno==155);
100019	100242	case 162: /* having_opt ::= HAVING expr */ yytestcase(yyruleno==162);
100020	100243	case 169: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==169);
100021		- case 236: /* case_else ::= ELSE expr */ yytestcase(yyruleno==236);
100022		- case 238: /* case_operand ::= expr */ yytestcase(yyruleno==238);
100023		-{yygotominor.yy132 = yymsp[0].minor.yy346.pExpr;}
	100244	+ case 235: /* case_else ::= ELSE expr */ yytestcase(yyruleno==235);
	100245	+ case 237: /* case_operand ::= expr */ yytestcase(yyruleno==237);
	100246	+{yygotominor.yy314 = yymsp[0].minor.yy118.pExpr;}
100024	100247	break;
100025	100248	case 145: /* on_opt ::= */
100026	100249	case 161: /* having_opt ::= */ yytestcase(yyruleno==161);
100027	100250	case 168: /* where_opt ::= */ yytestcase(yyruleno==168);
100028		- case 237: /* case_else ::= */ yytestcase(yyruleno==237);
100029		- case 239: /* case_operand ::= */ yytestcase(yyruleno==239);
100030		-{yygotominor.yy132 = 0;}
	100251	+ case 236: /* case_else ::= */ yytestcase(yyruleno==236);
	100252	+ case 238: /* case_operand ::= */ yytestcase(yyruleno==238);
	100253	+{yygotominor.yy314 = 0;}
100031	100254	break;
100032	100255	case 148: /* indexed_opt ::= NOT INDEXED */
100033	100256	{yygotominor.yy0.z=0; yygotominor.yy0.n=1;}
100034	100257	break;
100035	100258	case 149: /* using_opt ::= USING LP inscollist RP */
100036	100259	case 181: /* inscollist_opt ::= LP inscollist RP */ yytestcase(yyruleno==181);
100037		-{yygotominor.yy408 = yymsp[-1].minor.yy408;}
	100260	+{yygotominor.yy384 = yymsp[-1].minor.yy384;}
100038	100261	break;
100039	100262	case 150: /* using_opt ::= */
100040	100263	case 180: /* inscollist_opt ::= */ yytestcase(yyruleno==180);
100041		-{yygotominor.yy408 = 0;}
	100264	+{yygotominor.yy384 = 0;}
100042	100265	break;
100043	100266	case 152: /* orderby_opt ::= ORDER BY sortlist */
100044	100267	case 160: /* groupby_opt ::= GROUP BY nexprlist */ yytestcase(yyruleno==160);
100045		- case 240: /* exprlist ::= nexprlist */ yytestcase(yyruleno==240);
100046		-{yygotominor.yy14 = yymsp[0].minor.yy14;}
	100268	+ case 239: /* exprlist ::= nexprlist */ yytestcase(yyruleno==239);
	100269	+{yygotominor.yy322 = yymsp[0].minor.yy322;}
100047	100270	break;
100048	100271	case 153: /* sortlist ::= sortlist COMMA sortitem sortorder */
100049	100272	{
100050		- yygotominor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy14,yymsp[-1].minor.yy132);
100051		- if( yygotominor.yy14 ) yygotominor.yy14->a[yygotominor.yy14->nExpr-1].sortOrder = (u8)yymsp[0].minor.yy328;
	100273	+ yygotominor.yy322 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy322,yymsp[-1].minor.yy314);
	100274	+ if( yygotominor.yy322 ) yygotominor.yy322->a[yygotominor.yy322->nExpr-1].sortOrder = (u8)yymsp[0].minor.yy4;
100052	100275	}
100053	100276	break;
100054	100277	case 154: /* sortlist ::= sortitem sortorder */
100055	100278	{
100056		- yygotominor.yy14 = sqlite3ExprListAppend(pParse,0,yymsp[-1].minor.yy132);
100057		- if( yygotominor.yy14 && ALWAYS(yygotominor.yy14->a) ) yygotominor.yy14->a[0].sortOrder = (u8)yymsp[0].minor.yy328;
	100279	+ yygotominor.yy322 = sqlite3ExprListAppend(pParse,0,yymsp[-1].minor.yy314);
	100280	+ if( yygotominor.yy322 && ALWAYS(yygotominor.yy322->a) ) yygotominor.yy322->a[0].sortOrder = (u8)yymsp[0].minor.yy4;
100058	100281	}
100059	100282	break;
100060	100283	case 156: /* sortorder ::= ASC */
100061	100284	case 158: /* sortorder ::= */ yytestcase(yyruleno==158);
100062		-{yygotominor.yy328 = SQLITE_SO_ASC;}
	100285	+{yygotominor.yy4 = SQLITE_SO_ASC;}
100063	100286	break;
100064	100287	case 157: /* sortorder ::= DESC */
100065		-{yygotominor.yy328 = SQLITE_SO_DESC;}
	100288	+{yygotominor.yy4 = SQLITE_SO_DESC;}
100066	100289	break;
100067	100290	case 163: /* limit_opt ::= */
100068		-{yygotominor.yy476.pLimit = 0; yygotominor.yy476.pOffset = 0;}
	100291	+{yygotominor.yy292.pLimit = 0; yygotominor.yy292.pOffset = 0;}
100069	100292	break;
100070	100293	case 164: /* limit_opt ::= LIMIT expr */
100071		-{yygotominor.yy476.pLimit = yymsp[0].minor.yy346.pExpr; yygotominor.yy476.pOffset = 0;}
	100294	+{yygotominor.yy292.pLimit = yymsp[0].minor.yy118.pExpr; yygotominor.yy292.pOffset = 0;}
100072	100295	break;
100073	100296	case 165: /* limit_opt ::= LIMIT expr OFFSET expr */
100074		-{yygotominor.yy476.pLimit = yymsp[-2].minor.yy346.pExpr; yygotominor.yy476.pOffset = yymsp[0].minor.yy346.pExpr;}
	100297	+{yygotominor.yy292.pLimit = yymsp[-2].minor.yy118.pExpr; yygotominor.yy292.pOffset = yymsp[0].minor.yy118.pExpr;}
100075	100298	break;
100076	100299	case 166: /* limit_opt ::= LIMIT expr COMMA expr */
100077		-{yygotominor.yy476.pOffset = yymsp[-2].minor.yy346.pExpr; yygotominor.yy476.pLimit = yymsp[0].minor.yy346.pExpr;}
	100300	+{yygotominor.yy292.pOffset = yymsp[-2].minor.yy118.pExpr; yygotominor.yy292.pLimit = yymsp[0].minor.yy118.pExpr;}
100078	100301	break;
100079	100302	case 167: /* cmd ::= DELETE FROM fullname indexed_opt where_opt */
100080	100303	{
100081		- sqlite3SrcListIndexedBy(pParse, yymsp[-2].minor.yy65, &yymsp[-1].minor.yy0);
100082		- sqlite3DeleteFrom(pParse,yymsp[-2].minor.yy65,yymsp[0].minor.yy132);
	100304	+ sqlite3SrcListIndexedBy(pParse, yymsp[-2].minor.yy259, &yymsp[-1].minor.yy0);
	100305	+ sqlite3DeleteFrom(pParse,yymsp[-2].minor.yy259,yymsp[0].minor.yy314);
100083	100306	}
100084	100307	break;
100085	100308	case 170: /* cmd ::= UPDATE orconf fullname indexed_opt SET setlist where_opt */
100086	100309	{
100087		- sqlite3SrcListIndexedBy(pParse, yymsp[-4].minor.yy65, &yymsp[-3].minor.yy0);
100088		- sqlite3ExprListCheckLength(pParse,yymsp[-1].minor.yy14,"set list");
100089		- sqlite3Update(pParse,yymsp[-4].minor.yy65,yymsp[-1].minor.yy14,yymsp[0].minor.yy132,yymsp[-5].minor.yy186);
	100310	+ sqlite3SrcListIndexedBy(pParse, yymsp[-4].minor.yy259, &yymsp[-3].minor.yy0);
	100311	+ sqlite3ExprListCheckLength(pParse,yymsp[-1].minor.yy322,"set list");
	100312	+ sqlite3Update(pParse,yymsp[-4].minor.yy259,yymsp[-1].minor.yy322,yymsp[0].minor.yy314,yymsp[-5].minor.yy210);
100090	100313	}
100091	100314	break;
100092	100315	case 171: /* setlist ::= setlist COMMA nm EQ expr */
100093	100316	{
100094		- yygotominor.yy14 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy14, yymsp[0].minor.yy346.pExpr);
100095		- sqlite3ExprListSetName(pParse, yygotominor.yy14, &yymsp[-2].minor.yy0, 1);
	100317	+ yygotominor.yy322 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy322, yymsp[0].minor.yy118.pExpr);
	100318	+ sqlite3ExprListSetName(pParse, yygotominor.yy322, &yymsp[-2].minor.yy0, 1);
100096	100319	}
100097	100320	break;
100098	100321	case 172: /* setlist ::= nm EQ expr */
100099	100322	{
100100		- yygotominor.yy14 = sqlite3ExprListAppend(pParse, 0, yymsp[0].minor.yy346.pExpr);
100101		- sqlite3ExprListSetName(pParse, yygotominor.yy14, &yymsp[-2].minor.yy0, 1);
	100323	+ yygotominor.yy322 = sqlite3ExprListAppend(pParse, 0, yymsp[0].minor.yy118.pExpr);
	100324	+ sqlite3ExprListSetName(pParse, yygotominor.yy322, &yymsp[-2].minor.yy0, 1);
100102	100325	}
100103	100326	break;
100104	100327	case 173: /* cmd ::= insert_cmd INTO fullname inscollist_opt VALUES LP itemlist RP */
100105		-{sqlite3Insert(pParse, yymsp[-5].minor.yy65, yymsp[-1].minor.yy14, 0, yymsp[-4].minor.yy408, yymsp[-7].minor.yy186);}
	100328	+{sqlite3Insert(pParse, yymsp[-5].minor.yy259, yymsp[-1].minor.yy322, 0, yymsp[-4].minor.yy384, yymsp[-7].minor.yy210);}
100106	100329	break;
100107	100330	case 174: /* cmd ::= insert_cmd INTO fullname inscollist_opt select */
100108		-{sqlite3Insert(pParse, yymsp[-2].minor.yy65, 0, yymsp[0].minor.yy3, yymsp[-1].minor.yy408, yymsp[-4].minor.yy186);}
	100331	+{sqlite3Insert(pParse, yymsp[-2].minor.yy259, 0, yymsp[0].minor.yy387, yymsp[-1].minor.yy384, yymsp[-4].minor.yy210);}
100109	100332	break;
100110	100333	case 175: /* cmd ::= insert_cmd INTO fullname inscollist_opt DEFAULT VALUES */
100111		-{sqlite3Insert(pParse, yymsp[-3].minor.yy65, 0, 0, yymsp[-2].minor.yy408, yymsp[-5].minor.yy186);}
	100334	+{sqlite3Insert(pParse, yymsp[-3].minor.yy259, 0, 0, yymsp[-2].minor.yy384, yymsp[-5].minor.yy210);}
100112	100335	break;
100113	100336	case 176: /* insert_cmd ::= INSERT orconf */
100114		-{yygotominor.yy186 = yymsp[0].minor.yy186;}
	100337	+{yygotominor.yy210 = yymsp[0].minor.yy210;}
100115	100338	break;
100116	100339	case 177: /* insert_cmd ::= REPLACE */
100117		-{yygotominor.yy186 = OE_Replace;}
	100340	+{yygotominor.yy210 = OE_Replace;}
100118	100341	break;
100119	100342	case 178: /* itemlist ::= itemlist COMMA expr */
100120		- case 242: /* nexprlist ::= nexprlist COMMA expr */ yytestcase(yyruleno==242);
100121		-{yygotominor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy14,yymsp[0].minor.yy346.pExpr);}
	100343	+ case 241: /* nexprlist ::= nexprlist COMMA expr */ yytestcase(yyruleno==241);
	100344	+{yygotominor.yy322 = sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy322,yymsp[0].minor.yy118.pExpr);}
100122	100345	break;
100123	100346	case 179: /* itemlist ::= expr */
100124		- case 243: /* nexprlist ::= expr */ yytestcase(yyruleno==243);
100125		-{yygotominor.yy14 = sqlite3ExprListAppend(pParse,0,yymsp[0].minor.yy346.pExpr);}
	100347	+ case 242: /* nexprlist ::= expr */ yytestcase(yyruleno==242);
	100348	+{yygotominor.yy322 = sqlite3ExprListAppend(pParse,0,yymsp[0].minor.yy118.pExpr);}
100126	100349	break;
100127	100350	case 182: /* inscollist ::= inscollist COMMA nm */
100128		-{yygotominor.yy408 = sqlite3IdListAppend(pParse->db,yymsp[-2].minor.yy408,&yymsp[0].minor.yy0);}
	100351	+{yygotominor.yy384 = sqlite3IdListAppend(pParse->db,yymsp[-2].minor.yy384,&yymsp[0].minor.yy0);}
100129	100352	break;
100130	100353	case 183: /* inscollist ::= nm */
100131		-{yygotominor.yy408 = sqlite3IdListAppend(pParse->db,0,&yymsp[0].minor.yy0);}
	100354	+{yygotominor.yy384 = sqlite3IdListAppend(pParse->db,0,&yymsp[0].minor.yy0);}
100132	100355	break;
100133	100356	case 184: /* expr ::= term */
100134		- case 212: /* escape ::= ESCAPE expr */ yytestcase(yyruleno==212);
100135		-{yygotominor.yy346 = yymsp[0].minor.yy346;}
	100357	+{yygotominor.yy118 = yymsp[0].minor.yy118;}
100136	100358	break;
100137	100359	case 185: /* expr ::= LP expr RP */
100138		-{yygotominor.yy346.pExpr = yymsp[-1].minor.yy346.pExpr; spanSet(&yygotominor.yy346,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0);}
	100360	+{yygotominor.yy118.pExpr = yymsp[-1].minor.yy118.pExpr; spanSet(&yygotominor.yy118,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0);}
100139	100361	break;
100140	100362	case 186: /* term ::= NULL */
100141	100363	case 191: /* term ::= INTEGER\|FLOAT\|BLOB */ yytestcase(yyruleno==191);
100142	100364	case 192: /* term ::= STRING */ yytestcase(yyruleno==192);
100143		-{spanExpr(&yygotominor.yy346, pParse, yymsp[0].major, &yymsp[0].minor.yy0);}
	100365	+{spanExpr(&yygotominor.yy118, pParse, yymsp[0].major, &yymsp[0].minor.yy0);}
100144	100366	break;
100145	100367	case 187: /* expr ::= id */
100146	100368	case 188: /* expr ::= JOIN_KW */ yytestcase(yyruleno==188);
100147		-{spanExpr(&yygotominor.yy346, pParse, TK_ID, &yymsp[0].minor.yy0);}
	100369	+{spanExpr(&yygotominor.yy118, pParse, TK_ID, &yymsp[0].minor.yy0);}
100148	100370	break;
100149	100371	case 189: /* expr ::= nm DOT nm */
100150	100372	{
100151	100373	Expr *temp1 = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[-2].minor.yy0);
100152	100374	Expr *temp2 = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[0].minor.yy0);
100153		- yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_DOT, temp1, temp2, 0);
100154		- spanSet(&yygotominor.yy346,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0);
	100375	+ yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_DOT, temp1, temp2, 0);
	100376	+ spanSet(&yygotominor.yy118,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0);
100155	100377	}
100156	100378	break;
100157	100379	case 190: /* expr ::= nm DOT nm DOT nm */
100158	100380	{
100159	100381	Expr *temp1 = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[-4].minor.yy0);
100160	100382	Expr *temp2 = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[-2].minor.yy0);
100161	100383	Expr *temp3 = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[0].minor.yy0);
100162	100384	Expr *temp4 = sqlite3PExpr(pParse, TK_DOT, temp2, temp3, 0);
100163		- yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_DOT, temp1, temp4, 0);
100164		- spanSet(&yygotominor.yy346,&yymsp[-4].minor.yy0,&yymsp[0].minor.yy0);
	100385	+ yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_DOT, temp1, temp4, 0);
	100386	+ spanSet(&yygotominor.yy118,&yymsp[-4].minor.yy0,&yymsp[0].minor.yy0);
100165	100387	}
100166	100388	break;
100167	100389	case 193: /* expr ::= REGISTER */
100168	100390	{
100169	100391	/* When doing a nested parse, one can include terms in an expression
100170	100392	** that look like this: #1 #2 ... These terms refer to registers
100171	100393	** in the virtual machine. #N is the N-th register. */
100172	100394	if( pParse->nested==0 ){
100173	100395	sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", &yymsp[0].minor.yy0);
100174		- yygotominor.yy346.pExpr = 0;
	100396	+ yygotominor.yy118.pExpr = 0;
100175	100397	}else{
100176		- yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_REGISTER, 0, 0, &yymsp[0].minor.yy0);
100177		- if( yygotominor.yy346.pExpr ) sqlite3GetInt32(&yymsp[0].minor.yy0.z[1], &yygotominor.yy346.pExpr->iTable);
	100398	+ yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_REGISTER, 0, 0, &yymsp[0].minor.yy0);
	100399	+ if( yygotominor.yy118.pExpr ) sqlite3GetInt32(&yymsp[0].minor.yy0.z[1], &yygotominor.yy118.pExpr->iTable);
100178	100400	}
100179		- spanSet(&yygotominor.yy346, &yymsp[0].minor.yy0, &yymsp[0].minor.yy0);
	100401	+ spanSet(&yygotominor.yy118, &yymsp[0].minor.yy0, &yymsp[0].minor.yy0);
100180	100402	}
100181	100403	break;
100182	100404	case 194: /* expr ::= VARIABLE */
100183	100405	{
100184		- spanExpr(&yygotominor.yy346, pParse, TK_VARIABLE, &yymsp[0].minor.yy0);
100185		- sqlite3ExprAssignVarNumber(pParse, yygotominor.yy346.pExpr);
100186		- spanSet(&yygotominor.yy346, &yymsp[0].minor.yy0, &yymsp[0].minor.yy0);
	100406	+ spanExpr(&yygotominor.yy118, pParse, TK_VARIABLE, &yymsp[0].minor.yy0);
	100407	+ sqlite3ExprAssignVarNumber(pParse, yygotominor.yy118.pExpr);
	100408	+ spanSet(&yygotominor.yy118, &yymsp[0].minor.yy0, &yymsp[0].minor.yy0);
100187	100409	}
100188	100410	break;
100189	100411	case 195: /* expr ::= expr COLLATE ids */
100190	100412	{
100191		- yygotominor.yy346.pExpr = sqlite3ExprSetColl(pParse, yymsp[-2].minor.yy346.pExpr, &yymsp[0].minor.yy0);
100192		- yygotominor.yy346.zStart = yymsp[-2].minor.yy346.zStart;
100193		- yygotominor.yy346.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
	100413	+ yygotominor.yy118.pExpr = sqlite3ExprSetColl(pParse, yymsp[-2].minor.yy118.pExpr, &yymsp[0].minor.yy0);
	100414	+ yygotominor.yy118.zStart = yymsp[-2].minor.yy118.zStart;
	100415	+ yygotominor.yy118.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
100194	100416	}
100195	100417	break;
100196	100418	case 196: /* expr ::= CAST LP expr AS typetoken RP */
100197	100419	{
100198		- yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_CAST, yymsp[-3].minor.yy346.pExpr, 0, &yymsp[-1].minor.yy0);
100199		- spanSet(&yygotominor.yy346,&yymsp[-5].minor.yy0,&yymsp[0].minor.yy0);
	100420	+ yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_CAST, yymsp[-3].minor.yy118.pExpr, 0, &yymsp[-1].minor.yy0);
	100421	+ spanSet(&yygotominor.yy118,&yymsp[-5].minor.yy0,&yymsp[0].minor.yy0);
100200	100422	}
100201	100423	break;
100202	100424	case 197: /* expr ::= ID LP distinct exprlist RP */
100203	100425	{
100204		- if( yymsp[-1].minor.yy14 && yymsp[-1].minor.yy14->nExpr>pParse->db->aLimit[SQLITE_LIMIT_FUNCTION_ARG] ){
	100426	+ if( yymsp[-1].minor.yy322 && yymsp[-1].minor.yy322->nExpr>pParse->db->aLimit[SQLITE_LIMIT_FUNCTION_ARG] ){
100205	100427	sqlite3ErrorMsg(pParse, "too many arguments on function %T", &yymsp[-4].minor.yy0);
100206	100428	}
100207		- yygotominor.yy346.pExpr = sqlite3ExprFunction(pParse, yymsp[-1].minor.yy14, &yymsp[-4].minor.yy0);
100208		- spanSet(&yygotominor.yy346,&yymsp[-4].minor.yy0,&yymsp[0].minor.yy0);
100209		- if( yymsp[-2].minor.yy328 && yygotominor.yy346.pExpr ){
100210		- yygotominor.yy346.pExpr->flags \|= EP_Distinct;
	100429	+ yygotominor.yy118.pExpr = sqlite3ExprFunction(pParse, yymsp[-1].minor.yy322, &yymsp[-4].minor.yy0);
	100430	+ spanSet(&yygotominor.yy118,&yymsp[-4].minor.yy0,&yymsp[0].minor.yy0);
	100431	+ if( yymsp[-2].minor.yy4 && yygotominor.yy118.pExpr ){
	100432	+ yygotominor.yy118.pExpr->flags \|= EP_Distinct;
100211	100433	}
100212	100434	}
100213	100435	break;
100214	100436	case 198: /* expr ::= ID LP STAR RP */
100215	100437	{
100216		- yygotominor.yy346.pExpr = sqlite3ExprFunction(pParse, 0, &yymsp[-3].minor.yy0);
100217		- spanSet(&yygotominor.yy346,&yymsp[-3].minor.yy0,&yymsp[0].minor.yy0);
	100438	+ yygotominor.yy118.pExpr = sqlite3ExprFunction(pParse, 0, &yymsp[-3].minor.yy0);
	100439	+ spanSet(&yygotominor.yy118,&yymsp[-3].minor.yy0,&yymsp[0].minor.yy0);
100218	100440	}
100219	100441	break;
100220	100442	case 199: /* term ::= CTIME_KW */
100221	100443	{
100222	100444	/* The CURRENT_TIME, CURRENT_DATE, and CURRENT_TIMESTAMP values are
100223	100445	** treated as functions that return constants */
100224		- yygotominor.yy346.pExpr = sqlite3ExprFunction(pParse, 0,&yymsp[0].minor.yy0);
100225		- if( yygotominor.yy346.pExpr ){
100226		- yygotominor.yy346.pExpr->op = TK_CONST_FUNC;
	100446	+ yygotominor.yy118.pExpr = sqlite3ExprFunction(pParse, 0,&yymsp[0].minor.yy0);
	100447	+ if( yygotominor.yy118.pExpr ){
	100448	+ yygotominor.yy118.pExpr->op = TK_CONST_FUNC;
100227	100449	}
100228		- spanSet(&yygotominor.yy346, &yymsp[0].minor.yy0, &yymsp[0].minor.yy0);
	100450	+ spanSet(&yygotominor.yy118, &yymsp[0].minor.yy0, &yymsp[0].minor.yy0);
100229	100451	}
100230	100452	break;
100231	100453	case 200: /* expr ::= expr AND expr */
100232	100454	case 201: /* expr ::= expr OR expr */ yytestcase(yyruleno==201);
100233	100455	case 202: /* expr ::= expr LT\|GT\|GE\|LE expr */ yytestcase(yyruleno==202);
		@@ -100234,421 +100456,441 @@
100234	100456	case 203: /* expr ::= expr EQ\|NE expr */ yytestcase(yyruleno==203);
100235	100457	case 204: /* expr ::= expr BITAND\|BITOR\|LSHIFT\|RSHIFT expr */ yytestcase(yyruleno==204);
100236	100458	case 205: /* expr ::= expr PLUS\|MINUS expr */ yytestcase(yyruleno==205);
100237	100459	case 206: /* expr ::= expr STAR\|SLASH\|REM expr */ yytestcase(yyruleno==206);
100238	100460	case 207: /* expr ::= expr CONCAT expr */ yytestcase(yyruleno==207);
100239		-{spanBinaryExpr(&yygotominor.yy346,pParse,yymsp[-1].major,&yymsp[-2].minor.yy346,&yymsp[0].minor.yy346);}
	100461	+{spanBinaryExpr(&yygotominor.yy118,pParse,yymsp[-1].major,&yymsp[-2].minor.yy118,&yymsp[0].minor.yy118);}
100240	100462	break;
100241	100463	case 208: /* likeop ::= LIKE_KW */
100242	100464	case 210: /* likeop ::= MATCH */ yytestcase(yyruleno==210);
100243		-{yygotominor.yy96.eOperator = yymsp[0].minor.yy0; yygotominor.yy96.not = 0;}
	100465	+{yygotominor.yy342.eOperator = yymsp[0].minor.yy0; yygotominor.yy342.not = 0;}
100244	100466	break;
100245	100467	case 209: /* likeop ::= NOT LIKE_KW */
100246	100468	case 211: /* likeop ::= NOT MATCH */ yytestcase(yyruleno==211);
100247		-{yygotominor.yy96.eOperator = yymsp[0].minor.yy0; yygotominor.yy96.not = 1;}
	100469	+{yygotominor.yy342.eOperator = yymsp[0].minor.yy0; yygotominor.yy342.not = 1;}
100248	100470	break;
100249		- case 213: /* escape ::= */
100250		-{memset(&yygotominor.yy346,0,sizeof(yygotominor.yy346));}
	100471	+ case 212: /* expr ::= expr likeop expr */
	100472	+{
	100473	+ ExprList *pList;
	100474	+ pList = sqlite3ExprListAppend(pParse,0, yymsp[0].minor.yy118.pExpr);
	100475	+ pList = sqlite3ExprListAppend(pParse,pList, yymsp[-2].minor.yy118.pExpr);
	100476	+ yygotominor.yy118.pExpr = sqlite3ExprFunction(pParse, pList, &yymsp[-1].minor.yy342.eOperator);
	100477	+ if( yymsp[-1].minor.yy342.not ) yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy118.pExpr, 0, 0);
	100478	+ yygotominor.yy118.zStart = yymsp[-2].minor.yy118.zStart;
	100479	+ yygotominor.yy118.zEnd = yymsp[0].minor.yy118.zEnd;
	100480	+ if( yygotominor.yy118.pExpr ) yygotominor.yy118.pExpr->flags \|= EP_InfixFunc;
	100481	+}
100251	100482	break;
100252		- case 214: /* expr ::= expr likeop expr escape */
	100483	+ case 213: /* expr ::= expr likeop expr ESCAPE expr */
100253	100484	{
100254	100485	ExprList *pList;
100255		- pList = sqlite3ExprListAppend(pParse,0, yymsp[-1].minor.yy346.pExpr);
100256		- pList = sqlite3ExprListAppend(pParse,pList, yymsp[-3].minor.yy346.pExpr);
100257		- if( yymsp[0].minor.yy346.pExpr ){
100258		- pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy346.pExpr);
100259		- }
100260		- yygotominor.yy346.pExpr = sqlite3ExprFunction(pParse, pList, &yymsp[-2].minor.yy96.eOperator);
100261		- if( yymsp[-2].minor.yy96.not ) yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy346.pExpr, 0, 0);
100262		- yygotominor.yy346.zStart = yymsp[-3].minor.yy346.zStart;
100263		- yygotominor.yy346.zEnd = yymsp[-1].minor.yy346.zEnd;
100264		- if( yygotominor.yy346.pExpr ) yygotominor.yy346.pExpr->flags \|= EP_InfixFunc;
100265		-}
100266		- break;
100267		- case 215: /* expr ::= expr ISNULL\|NOTNULL */
100268		-{spanUnaryPostfix(&yygotominor.yy346,pParse,yymsp[0].major,&yymsp[-1].minor.yy346,&yymsp[0].minor.yy0);}
100269		- break;
100270		- case 216: /* expr ::= expr NOT NULL */
100271		-{spanUnaryPostfix(&yygotominor.yy346,pParse,TK_NOTNULL,&yymsp[-2].minor.yy346,&yymsp[0].minor.yy0);}
100272		- break;
100273		- case 217: /* expr ::= expr IS expr */
100274		-{
100275		- spanBinaryExpr(&yygotominor.yy346,pParse,TK_IS,&yymsp[-2].minor.yy346,&yymsp[0].minor.yy346);
100276		- binaryToUnaryIfNull(pParse, yymsp[0].minor.yy346.pExpr, yygotominor.yy346.pExpr, TK_ISNULL);
100277		-}
100278		- break;
100279		- case 218: /* expr ::= expr IS NOT expr */
100280		-{
100281		- spanBinaryExpr(&yygotominor.yy346,pParse,TK_ISNOT,&yymsp[-3].minor.yy346,&yymsp[0].minor.yy346);
100282		- binaryToUnaryIfNull(pParse, yymsp[0].minor.yy346.pExpr, yygotominor.yy346.pExpr, TK_NOTNULL);
100283		-}
100284		- break;
100285		- case 219: /* expr ::= NOT expr */
100286		- case 220: /* expr ::= BITNOT expr */ yytestcase(yyruleno==220);
100287		-{spanUnaryPrefix(&yygotominor.yy346,pParse,yymsp[-1].major,&yymsp[0].minor.yy346,&yymsp[-1].minor.yy0);}
100288		- break;
100289		- case 221: /* expr ::= MINUS expr */
100290		-{spanUnaryPrefix(&yygotominor.yy346,pParse,TK_UMINUS,&yymsp[0].minor.yy346,&yymsp[-1].minor.yy0);}
100291		- break;
100292		- case 222: /* expr ::= PLUS expr */
100293		-{spanUnaryPrefix(&yygotominor.yy346,pParse,TK_UPLUS,&yymsp[0].minor.yy346,&yymsp[-1].minor.yy0);}
100294		- break;
100295		- case 225: /* expr ::= expr between_op expr AND expr */
100296		-{
100297		- ExprList *pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy346.pExpr);
100298		- pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy346.pExpr);
100299		- yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_BETWEEN, yymsp[-4].minor.yy346.pExpr, 0, 0);
100300		- if( yygotominor.yy346.pExpr ){
100301		- yygotominor.yy346.pExpr->x.pList = pList;
	100486	+ pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy118.pExpr);
	100487	+ pList = sqlite3ExprListAppend(pParse,pList, yymsp[-4].minor.yy118.pExpr);
	100488	+ pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy118.pExpr);
	100489	+ yygotominor.yy118.pExpr = sqlite3ExprFunction(pParse, pList, &yymsp[-3].minor.yy342.eOperator);
	100490	+ if( yymsp[-3].minor.yy342.not ) yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy118.pExpr, 0, 0);
	100491	+ yygotominor.yy118.zStart = yymsp[-4].minor.yy118.zStart;
	100492	+ yygotominor.yy118.zEnd = yymsp[0].minor.yy118.zEnd;
	100493	+ if( yygotominor.yy118.pExpr ) yygotominor.yy118.pExpr->flags \|= EP_InfixFunc;
	100494	+}
	100495	+ break;
	100496	+ case 214: /* expr ::= expr ISNULL\|NOTNULL */
	100497	+{spanUnaryPostfix(&yygotominor.yy118,pParse,yymsp[0].major,&yymsp[-1].minor.yy118,&yymsp[0].minor.yy0);}
	100498	+ break;
	100499	+ case 215: /* expr ::= expr NOT NULL */
	100500	+{spanUnaryPostfix(&yygotominor.yy118,pParse,TK_NOTNULL,&yymsp[-2].minor.yy118,&yymsp[0].minor.yy0);}
	100501	+ break;
	100502	+ case 216: /* expr ::= expr IS expr */
	100503	+{
	100504	+ spanBinaryExpr(&yygotominor.yy118,pParse,TK_IS,&yymsp[-2].minor.yy118,&yymsp[0].minor.yy118);
	100505	+ binaryToUnaryIfNull(pParse, yymsp[0].minor.yy118.pExpr, yygotominor.yy118.pExpr, TK_ISNULL);
	100506	+}
	100507	+ break;
	100508	+ case 217: /* expr ::= expr IS NOT expr */
	100509	+{
	100510	+ spanBinaryExpr(&yygotominor.yy118,pParse,TK_ISNOT,&yymsp[-3].minor.yy118,&yymsp[0].minor.yy118);
	100511	+ binaryToUnaryIfNull(pParse, yymsp[0].minor.yy118.pExpr, yygotominor.yy118.pExpr, TK_NOTNULL);
	100512	+}
	100513	+ break;
	100514	+ case 218: /* expr ::= NOT expr */
	100515	+ case 219: /* expr ::= BITNOT expr */ yytestcase(yyruleno==219);
	100516	+{spanUnaryPrefix(&yygotominor.yy118,pParse,yymsp[-1].major,&yymsp[0].minor.yy118,&yymsp[-1].minor.yy0);}
	100517	+ break;
	100518	+ case 220: /* expr ::= MINUS expr */
	100519	+{spanUnaryPrefix(&yygotominor.yy118,pParse,TK_UMINUS,&yymsp[0].minor.yy118,&yymsp[-1].minor.yy0);}
	100520	+ break;
	100521	+ case 221: /* expr ::= PLUS expr */
	100522	+{spanUnaryPrefix(&yygotominor.yy118,pParse,TK_UPLUS,&yymsp[0].minor.yy118,&yymsp[-1].minor.yy0);}
	100523	+ break;
	100524	+ case 224: /* expr ::= expr between_op expr AND expr */
	100525	+{
	100526	+ ExprList *pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy118.pExpr);
	100527	+ pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy118.pExpr);
	100528	+ yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_BETWEEN, yymsp[-4].minor.yy118.pExpr, 0, 0);
	100529	+ if( yygotominor.yy118.pExpr ){
	100530	+ yygotominor.yy118.pExpr->x.pList = pList;
100302	100531	}else{
100303	100532	sqlite3ExprListDelete(pParse->db, pList);
100304	100533	}
100305		- if( yymsp[-3].minor.yy328 ) yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy346.pExpr, 0, 0);
100306		- yygotominor.yy346.zStart = yymsp[-4].minor.yy346.zStart;
100307		- yygotominor.yy346.zEnd = yymsp[0].minor.yy346.zEnd;
100308		-}
100309		- break;
100310		- case 228: /* expr ::= expr in_op LP exprlist RP */
100311		-{
100312		- yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy346.pExpr, 0, 0);
100313		- if( yygotominor.yy346.pExpr ){
100314		- yygotominor.yy346.pExpr->x.pList = yymsp[-1].minor.yy14;
100315		- sqlite3ExprSetHeight(pParse, yygotominor.yy346.pExpr);
100316		- }else{
100317		- sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy14);
100318		- }
100319		- if( yymsp[-3].minor.yy328 ) yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy346.pExpr, 0, 0);
100320		- yygotominor.yy346.zStart = yymsp[-4].minor.yy346.zStart;
100321		- yygotominor.yy346.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
100322		- }
100323		- break;
100324		- case 229: /* expr ::= LP select RP */
100325		-{
100326		- yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_SELECT, 0, 0, 0);
100327		- if( yygotominor.yy346.pExpr ){
100328		- yygotominor.yy346.pExpr->x.pSelect = yymsp[-1].minor.yy3;
100329		- ExprSetProperty(yygotominor.yy346.pExpr, EP_xIsSelect);
100330		- sqlite3ExprSetHeight(pParse, yygotominor.yy346.pExpr);
100331		- }else{
100332		- sqlite3SelectDelete(pParse->db, yymsp[-1].minor.yy3);
100333		- }
100334		- yygotominor.yy346.zStart = yymsp[-2].minor.yy0.z;
100335		- yygotominor.yy346.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
100336		- }
100337		- break;
100338		- case 230: /* expr ::= expr in_op LP select RP */
100339		-{
100340		- yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy346.pExpr, 0, 0);
100341		- if( yygotominor.yy346.pExpr ){
100342		- yygotominor.yy346.pExpr->x.pSelect = yymsp[-1].minor.yy3;
100343		- ExprSetProperty(yygotominor.yy346.pExpr, EP_xIsSelect);
100344		- sqlite3ExprSetHeight(pParse, yygotominor.yy346.pExpr);
100345		- }else{
100346		- sqlite3SelectDelete(pParse->db, yymsp[-1].minor.yy3);
100347		- }
100348		- if( yymsp[-3].minor.yy328 ) yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy346.pExpr, 0, 0);
100349		- yygotominor.yy346.zStart = yymsp[-4].minor.yy346.zStart;
100350		- yygotominor.yy346.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
100351		- }
100352		- break;
100353		- case 231: /* expr ::= expr in_op nm dbnm */
	100534	+ if( yymsp[-3].minor.yy4 ) yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy118.pExpr, 0, 0);
	100535	+ yygotominor.yy118.zStart = yymsp[-4].minor.yy118.zStart;
	100536	+ yygotominor.yy118.zEnd = yymsp[0].minor.yy118.zEnd;
	100537	+}
	100538	+ break;
	100539	+ case 227: /* expr ::= expr in_op LP exprlist RP */
	100540	+{
	100541	+ if( yymsp[-1].minor.yy322==0 ){
	100542	+ /* Expressions of the form
	100543	+ **
	100544	+ ** expr1 IN ()
	100545	+ ** expr1 NOT IN ()
	100546	+ **
	100547	+ ** simplify to constants 0 (false) and 1 (true), respectively,
	100548	+ ** regardless of the value of expr1.
	100549	+ */
	100550	+ yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_INTEGER, 0, 0, &sqlite3IntTokens[yymsp[-3].minor.yy4]);
	100551	+ sqlite3ExprDelete(pParse->db, yymsp[-4].minor.yy118.pExpr);
	100552	+ }else{
	100553	+ yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy118.pExpr, 0, 0);
	100554	+ if( yygotominor.yy118.pExpr ){
	100555	+ yygotominor.yy118.pExpr->x.pList = yymsp[-1].minor.yy322;
	100556	+ sqlite3ExprSetHeight(pParse, yygotominor.yy118.pExpr);
	100557	+ }else{
	100558	+ sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy322);
	100559	+ }
	100560	+ if( yymsp[-3].minor.yy4 ) yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy118.pExpr, 0, 0);
	100561	+ }
	100562	+ yygotominor.yy118.zStart = yymsp[-4].minor.yy118.zStart;
	100563	+ yygotominor.yy118.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
	100564	+ }
	100565	+ break;
	100566	+ case 228: /* expr ::= LP select RP */
	100567	+{
	100568	+ yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_SELECT, 0, 0, 0);
	100569	+ if( yygotominor.yy118.pExpr ){
	100570	+ yygotominor.yy118.pExpr->x.pSelect = yymsp[-1].minor.yy387;
	100571	+ ExprSetProperty(yygotominor.yy118.pExpr, EP_xIsSelect);
	100572	+ sqlite3ExprSetHeight(pParse, yygotominor.yy118.pExpr);
	100573	+ }else{
	100574	+ sqlite3SelectDelete(pParse->db, yymsp[-1].minor.yy387);
	100575	+ }
	100576	+ yygotominor.yy118.zStart = yymsp[-2].minor.yy0.z;
	100577	+ yygotominor.yy118.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
	100578	+ }
	100579	+ break;
	100580	+ case 229: /* expr ::= expr in_op LP select RP */
	100581	+{
	100582	+ yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy118.pExpr, 0, 0);
	100583	+ if( yygotominor.yy118.pExpr ){
	100584	+ yygotominor.yy118.pExpr->x.pSelect = yymsp[-1].minor.yy387;
	100585	+ ExprSetProperty(yygotominor.yy118.pExpr, EP_xIsSelect);
	100586	+ sqlite3ExprSetHeight(pParse, yygotominor.yy118.pExpr);
	100587	+ }else{
	100588	+ sqlite3SelectDelete(pParse->db, yymsp[-1].minor.yy387);
	100589	+ }
	100590	+ if( yymsp[-3].minor.yy4 ) yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy118.pExpr, 0, 0);
	100591	+ yygotominor.yy118.zStart = yymsp[-4].minor.yy118.zStart;
	100592	+ yygotominor.yy118.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
	100593	+ }
	100594	+ break;
	100595	+ case 230: /* expr ::= expr in_op nm dbnm */
100354	100596	{
100355	100597	SrcList *pSrc = sqlite3SrcListAppend(pParse->db, 0,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0);
100356		- yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_IN, yymsp[-3].minor.yy346.pExpr, 0, 0);
100357		- if( yygotominor.yy346.pExpr ){
100358		- yygotominor.yy346.pExpr->x.pSelect = sqlite3SelectNew(pParse, 0,pSrc,0,0,0,0,0,0,0);
100359		- ExprSetProperty(yygotominor.yy346.pExpr, EP_xIsSelect);
100360		- sqlite3ExprSetHeight(pParse, yygotominor.yy346.pExpr);
	100598	+ yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_IN, yymsp[-3].minor.yy118.pExpr, 0, 0);
	100599	+ if( yygotominor.yy118.pExpr ){
	100600	+ yygotominor.yy118.pExpr->x.pSelect = sqlite3SelectNew(pParse, 0,pSrc,0,0,0,0,0,0,0);
	100601	+ ExprSetProperty(yygotominor.yy118.pExpr, EP_xIsSelect);
	100602	+ sqlite3ExprSetHeight(pParse, yygotominor.yy118.pExpr);
100361	100603	}else{
100362	100604	sqlite3SrcListDelete(pParse->db, pSrc);
100363	100605	}
100364		- if( yymsp[-2].minor.yy328 ) yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy346.pExpr, 0, 0);
100365		- yygotominor.yy346.zStart = yymsp[-3].minor.yy346.zStart;
100366		- yygotominor.yy346.zEnd = yymsp[0].minor.yy0.z ? &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n] : &yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n];
100367		- }
100368		- break;
100369		- case 232: /* expr ::= EXISTS LP select RP */
100370		-{
100371		- Expr *p = yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_EXISTS, 0, 0, 0);
	100606	+ if( yymsp[-2].minor.yy4 ) yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy118.pExpr, 0, 0);
	100607	+ yygotominor.yy118.zStart = yymsp[-3].minor.yy118.zStart;
	100608	+ yygotominor.yy118.zEnd = yymsp[0].minor.yy0.z ? &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n] : &yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n];
	100609	+ }
	100610	+ break;
	100611	+ case 231: /* expr ::= EXISTS LP select RP */
	100612	+{
	100613	+ Expr *p = yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_EXISTS, 0, 0, 0);
100372	100614	if( p ){
100373		- p->x.pSelect = yymsp[-1].minor.yy3;
	100615	+ p->x.pSelect = yymsp[-1].minor.yy387;
100374	100616	ExprSetProperty(p, EP_xIsSelect);
100375	100617	sqlite3ExprSetHeight(pParse, p);
100376	100618	}else{
100377		- sqlite3SelectDelete(pParse->db, yymsp[-1].minor.yy3);
100378		- }
100379		- yygotominor.yy346.zStart = yymsp[-3].minor.yy0.z;
100380		- yygotominor.yy346.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
100381		- }
100382		- break;
100383		- case 233: /* expr ::= CASE case_operand case_exprlist case_else END */
100384		-{
100385		- yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_CASE, yymsp[-3].minor.yy132, yymsp[-1].minor.yy132, 0);
100386		- if( yygotominor.yy346.pExpr ){
100387		- yygotominor.yy346.pExpr->x.pList = yymsp[-2].minor.yy14;
100388		- sqlite3ExprSetHeight(pParse, yygotominor.yy346.pExpr);
100389		- }else{
100390		- sqlite3ExprListDelete(pParse->db, yymsp[-2].minor.yy14);
100391		- }
100392		- yygotominor.yy346.zStart = yymsp[-4].minor.yy0.z;
100393		- yygotominor.yy346.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
100394		-}
100395		- break;
100396		- case 234: /* case_exprlist ::= case_exprlist WHEN expr THEN expr */
100397		-{
100398		- yygotominor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy14, yymsp[-2].minor.yy346.pExpr);
100399		- yygotominor.yy14 = sqlite3ExprListAppend(pParse,yygotominor.yy14, yymsp[0].minor.yy346.pExpr);
100400		-}
100401		- break;
100402		- case 235: /* case_exprlist ::= WHEN expr THEN expr */
100403		-{
100404		- yygotominor.yy14 = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy346.pExpr);
100405		- yygotominor.yy14 = sqlite3ExprListAppend(pParse,yygotominor.yy14, yymsp[0].minor.yy346.pExpr);
100406		-}
100407		- break;
100408		- case 244: /* cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP idxlist RP */
	100619	+ sqlite3SelectDelete(pParse->db, yymsp[-1].minor.yy387);
	100620	+ }
	100621	+ yygotominor.yy118.zStart = yymsp[-3].minor.yy0.z;
	100622	+ yygotominor.yy118.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
	100623	+ }
	100624	+ break;
	100625	+ case 232: /* expr ::= CASE case_operand case_exprlist case_else END */
	100626	+{
	100627	+ yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_CASE, yymsp[-3].minor.yy314, yymsp[-1].minor.yy314, 0);
	100628	+ if( yygotominor.yy118.pExpr ){
	100629	+ yygotominor.yy118.pExpr->x.pList = yymsp[-2].minor.yy322;
	100630	+ sqlite3ExprSetHeight(pParse, yygotominor.yy118.pExpr);
	100631	+ }else{
	100632	+ sqlite3ExprListDelete(pParse->db, yymsp[-2].minor.yy322);
	100633	+ }
	100634	+ yygotominor.yy118.zStart = yymsp[-4].minor.yy0.z;
	100635	+ yygotominor.yy118.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
	100636	+}
	100637	+ break;
	100638	+ case 233: /* case_exprlist ::= case_exprlist WHEN expr THEN expr */
	100639	+{
	100640	+ yygotominor.yy322 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy322, yymsp[-2].minor.yy118.pExpr);
	100641	+ yygotominor.yy322 = sqlite3ExprListAppend(pParse,yygotominor.yy322, yymsp[0].minor.yy118.pExpr);
	100642	+}
	100643	+ break;
	100644	+ case 234: /* case_exprlist ::= WHEN expr THEN expr */
	100645	+{
	100646	+ yygotominor.yy322 = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy118.pExpr);
	100647	+ yygotominor.yy322 = sqlite3ExprListAppend(pParse,yygotominor.yy322, yymsp[0].minor.yy118.pExpr);
	100648	+}
	100649	+ break;
	100650	+ case 243: /* cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP idxlist RP */
100409	100651	{
100410	100652	sqlite3CreateIndex(pParse, &yymsp[-6].minor.yy0, &yymsp[-5].minor.yy0,
100411		- sqlite3SrcListAppend(pParse->db,0,&yymsp[-3].minor.yy0,0), yymsp[-1].minor.yy14, yymsp[-9].minor.yy328,
100412		- &yymsp[-10].minor.yy0, &yymsp[0].minor.yy0, SQLITE_SO_ASC, yymsp[-7].minor.yy328);
	100653	+ sqlite3SrcListAppend(pParse->db,0,&yymsp[-3].minor.yy0,0), yymsp[-1].minor.yy322, yymsp[-9].minor.yy4,
	100654	+ &yymsp[-10].minor.yy0, &yymsp[0].minor.yy0, SQLITE_SO_ASC, yymsp[-7].minor.yy4);
100413	100655	}
100414	100656	break;
100415		- case 245: /* uniqueflag ::= UNIQUE */
100416		- case 299: /* raisetype ::= ABORT */ yytestcase(yyruleno==299);
100417		-{yygotominor.yy328 = OE_Abort;}
100418		- break;
100419		- case 246: /* uniqueflag ::= */
100420		-{yygotominor.yy328 = OE_None;}
100421		- break;
100422		- case 249: /* idxlist ::= idxlist COMMA nm collate sortorder */
	100657	+ case 244: /* uniqueflag ::= UNIQUE */
	100658	+ case 298: /* raisetype ::= ABORT */ yytestcase(yyruleno==298);
	100659	+{yygotominor.yy4 = OE_Abort;}
	100660	+ break;
	100661	+ case 245: /* uniqueflag ::= */
	100662	+{yygotominor.yy4 = OE_None;}
	100663	+ break;
	100664	+ case 248: /* idxlist ::= idxlist COMMA nm collate sortorder */
100423	100665	{
100424	100666	Expr *p = 0;
100425	100667	if( yymsp[-1].minor.yy0.n>0 ){
100426	100668	p = sqlite3Expr(pParse->db, TK_COLUMN, 0);
100427	100669	sqlite3ExprSetColl(pParse, p, &yymsp[-1].minor.yy0);
100428	100670	}
100429		- yygotominor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy14, p);
100430		- sqlite3ExprListSetName(pParse,yygotominor.yy14,&yymsp[-2].minor.yy0,1);
100431		- sqlite3ExprListCheckLength(pParse, yygotominor.yy14, "index");
100432		- if( yygotominor.yy14 ) yygotominor.yy14->a[yygotominor.yy14->nExpr-1].sortOrder = (u8)yymsp[0].minor.yy328;
	100671	+ yygotominor.yy322 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy322, p);
	100672	+ sqlite3ExprListSetName(pParse,yygotominor.yy322,&yymsp[-2].minor.yy0,1);
	100673	+ sqlite3ExprListCheckLength(pParse, yygotominor.yy322, "index");
	100674	+ if( yygotominor.yy322 ) yygotominor.yy322->a[yygotominor.yy322->nExpr-1].sortOrder = (u8)yymsp[0].minor.yy4;
100433	100675	}
100434	100676	break;
100435		- case 250: /* idxlist ::= nm collate sortorder */
	100677	+ case 249: /* idxlist ::= nm collate sortorder */
100436	100678	{
100437	100679	Expr *p = 0;
100438	100680	if( yymsp[-1].minor.yy0.n>0 ){
100439	100681	p = sqlite3PExpr(pParse, TK_COLUMN, 0, 0, 0);
100440	100682	sqlite3ExprSetColl(pParse, p, &yymsp[-1].minor.yy0);
100441	100683	}
100442		- yygotominor.yy14 = sqlite3ExprListAppend(pParse,0, p);
100443		- sqlite3ExprListSetName(pParse, yygotominor.yy14, &yymsp[-2].minor.yy0, 1);
100444		- sqlite3ExprListCheckLength(pParse, yygotominor.yy14, "index");
100445		- if( yygotominor.yy14 ) yygotominor.yy14->a[yygotominor.yy14->nExpr-1].sortOrder = (u8)yymsp[0].minor.yy328;
	100684	+ yygotominor.yy322 = sqlite3ExprListAppend(pParse,0, p);
	100685	+ sqlite3ExprListSetName(pParse, yygotominor.yy322, &yymsp[-2].minor.yy0, 1);
	100686	+ sqlite3ExprListCheckLength(pParse, yygotominor.yy322, "index");
	100687	+ if( yygotominor.yy322 ) yygotominor.yy322->a[yygotominor.yy322->nExpr-1].sortOrder = (u8)yymsp[0].minor.yy4;
100446	100688	}
100447	100689	break;
100448		- case 251: /* collate ::= */
	100690	+ case 250: /* collate ::= */
100449	100691	{yygotominor.yy0.z = 0; yygotominor.yy0.n = 0;}
100450	100692	break;
100451		- case 253: /* cmd ::= DROP INDEX ifexists fullname */
100452		-{sqlite3DropIndex(pParse, yymsp[0].minor.yy65, yymsp[-1].minor.yy328);}
	100693	+ case 252: /* cmd ::= DROP INDEX ifexists fullname */
	100694	+{sqlite3DropIndex(pParse, yymsp[0].minor.yy259, yymsp[-1].minor.yy4);}
100453	100695	break;
100454		- case 254: /* cmd ::= VACUUM */
100455		- case 255: /* cmd ::= VACUUM nm */ yytestcase(yyruleno==255);
	100696	+ case 253: /* cmd ::= VACUUM */
	100697	+ case 254: /* cmd ::= VACUUM nm */ yytestcase(yyruleno==254);
100456	100698	{sqlite3Vacuum(pParse);}
100457	100699	break;
100458		- case 256: /* cmd ::= PRAGMA nm dbnm */
	100700	+ case 255: /* cmd ::= PRAGMA nm dbnm */
100459	100701	{sqlite3Pragma(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,0,0);}
100460	100702	break;
100461		- case 257: /* cmd ::= PRAGMA nm dbnm EQ nmnum */
	100703	+ case 256: /* cmd ::= PRAGMA nm dbnm EQ nmnum */
100462	100704	{sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,0);}
100463	100705	break;
100464		- case 258: /* cmd ::= PRAGMA nm dbnm LP nmnum RP */
	100706	+ case 257: /* cmd ::= PRAGMA nm dbnm LP nmnum RP */
100465	100707	{sqlite3Pragma(pParse,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,0);}
100466	100708	break;
100467		- case 259: /* cmd ::= PRAGMA nm dbnm EQ minus_num */
	100709	+ case 258: /* cmd ::= PRAGMA nm dbnm EQ minus_num */
100468	100710	{sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,1);}
100469	100711	break;
100470		- case 260: /* cmd ::= PRAGMA nm dbnm LP minus_num RP */
	100712	+ case 259: /* cmd ::= PRAGMA nm dbnm LP minus_num RP */
100471	100713	{sqlite3Pragma(pParse,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,1);}
100472	100714	break;
100473		- case 271: /* cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
	100715	+ case 270: /* cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
100474	100716	{
100475	100717	Token all;
100476	100718	all.z = yymsp[-3].minor.yy0.z;
100477	100719	all.n = (int)(yymsp[0].minor.yy0.z - yymsp[-3].minor.yy0.z) + yymsp[0].minor.yy0.n;
100478		- sqlite3FinishTrigger(pParse, yymsp[-1].minor.yy473, &all);
	100720	+ sqlite3FinishTrigger(pParse, yymsp[-1].minor.yy203, &all);
100479	100721	}
100480	100722	break;
100481		- case 272: /* trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
	100723	+ case 271: /* trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
100482	100724	{
100483		- sqlite3BeginTrigger(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0, yymsp[-5].minor.yy328, yymsp[-4].minor.yy378.a, yymsp[-4].minor.yy378.b, yymsp[-2].minor.yy65, yymsp[0].minor.yy132, yymsp[-10].minor.yy328, yymsp[-8].minor.yy328);
	100725	+ sqlite3BeginTrigger(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0, yymsp[-5].minor.yy4, yymsp[-4].minor.yy90.a, yymsp[-4].minor.yy90.b, yymsp[-2].minor.yy259, yymsp[0].minor.yy314, yymsp[-10].minor.yy4, yymsp[-8].minor.yy4);
100484	100726	yygotominor.yy0 = (yymsp[-6].minor.yy0.n==0?yymsp[-7].minor.yy0:yymsp[-6].minor.yy0);
100485	100727	}
100486	100728	break;
100487		- case 273: /* trigger_time ::= BEFORE */
100488		- case 276: /* trigger_time ::= */ yytestcase(yyruleno==276);
100489		-{ yygotominor.yy328 = TK_BEFORE; }
100490		- break;
100491		- case 274: /* trigger_time ::= AFTER */
100492		-{ yygotominor.yy328 = TK_AFTER; }
100493		- break;
100494		- case 275: /* trigger_time ::= INSTEAD OF */
100495		-{ yygotominor.yy328 = TK_INSTEAD;}
100496		- break;
100497		- case 277: /* trigger_event ::= DELETE\|INSERT */
100498		- case 278: /* trigger_event ::= UPDATE */ yytestcase(yyruleno==278);
100499		-{yygotominor.yy378.a = yymsp[0].major; yygotominor.yy378.b = 0;}
100500		- break;
100501		- case 279: /* trigger_event ::= UPDATE OF inscollist */
100502		-{yygotominor.yy378.a = TK_UPDATE; yygotominor.yy378.b = yymsp[0].minor.yy408;}
100503		- break;
100504		- case 282: /* when_clause ::= */
100505		- case 304: /* key_opt ::= */ yytestcase(yyruleno==304);
100506		-{ yygotominor.yy132 = 0; }
100507		- break;
100508		- case 283: /* when_clause ::= WHEN expr */
100509		- case 305: /* key_opt ::= KEY expr */ yytestcase(yyruleno==305);
100510		-{ yygotominor.yy132 = yymsp[0].minor.yy346.pExpr; }
100511		- break;
100512		- case 284: /* trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
100513		-{
100514		- assert( yymsp[-2].minor.yy473!=0 );
100515		- yymsp[-2].minor.yy473->pLast->pNext = yymsp[-1].minor.yy473;
100516		- yymsp[-2].minor.yy473->pLast = yymsp[-1].minor.yy473;
100517		- yygotominor.yy473 = yymsp[-2].minor.yy473;
100518		-}
100519		- break;
100520		- case 285: /* trigger_cmd_list ::= trigger_cmd SEMI */
100521		-{
100522		- assert( yymsp[-1].minor.yy473!=0 );
100523		- yymsp[-1].minor.yy473->pLast = yymsp[-1].minor.yy473;
100524		- yygotominor.yy473 = yymsp[-1].minor.yy473;
100525		-}
100526		- break;
100527		- case 287: /* trnm ::= nm DOT nm */
	100729	+ case 272: /* trigger_time ::= BEFORE */
	100730	+ case 275: /* trigger_time ::= */ yytestcase(yyruleno==275);
	100731	+{ yygotominor.yy4 = TK_BEFORE; }
	100732	+ break;
	100733	+ case 273: /* trigger_time ::= AFTER */
	100734	+{ yygotominor.yy4 = TK_AFTER; }
	100735	+ break;
	100736	+ case 274: /* trigger_time ::= INSTEAD OF */
	100737	+{ yygotominor.yy4 = TK_INSTEAD;}
	100738	+ break;
	100739	+ case 276: /* trigger_event ::= DELETE\|INSERT */
	100740	+ case 277: /* trigger_event ::= UPDATE */ yytestcase(yyruleno==277);
	100741	+{yygotominor.yy90.a = yymsp[0].major; yygotominor.yy90.b = 0;}
	100742	+ break;
	100743	+ case 278: /* trigger_event ::= UPDATE OF inscollist */
	100744	+{yygotominor.yy90.a = TK_UPDATE; yygotominor.yy90.b = yymsp[0].minor.yy384;}
	100745	+ break;
	100746	+ case 281: /* when_clause ::= */
	100747	+ case 303: /* key_opt ::= */ yytestcase(yyruleno==303);
	100748	+{ yygotominor.yy314 = 0; }
	100749	+ break;
	100750	+ case 282: /* when_clause ::= WHEN expr */
	100751	+ case 304: /* key_opt ::= KEY expr */ yytestcase(yyruleno==304);
	100752	+{ yygotominor.yy314 = yymsp[0].minor.yy118.pExpr; }
	100753	+ break;
	100754	+ case 283: /* trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
	100755	+{
	100756	+ assert( yymsp[-2].minor.yy203!=0 );
	100757	+ yymsp[-2].minor.yy203->pLast->pNext = yymsp[-1].minor.yy203;
	100758	+ yymsp[-2].minor.yy203->pLast = yymsp[-1].minor.yy203;
	100759	+ yygotominor.yy203 = yymsp[-2].minor.yy203;
	100760	+}
	100761	+ break;
	100762	+ case 284: /* trigger_cmd_list ::= trigger_cmd SEMI */
	100763	+{
	100764	+ assert( yymsp[-1].minor.yy203!=0 );
	100765	+ yymsp[-1].minor.yy203->pLast = yymsp[-1].minor.yy203;
	100766	+ yygotominor.yy203 = yymsp[-1].minor.yy203;
	100767	+}
	100768	+ break;
	100769	+ case 286: /* trnm ::= nm DOT nm */
100528	100770	{
100529	100771	yygotominor.yy0 = yymsp[0].minor.yy0;
100530	100772	sqlite3ErrorMsg(pParse,
100531	100773	"qualified table names are not allowed on INSERT, UPDATE, and DELETE "
100532	100774	"statements within triggers");
100533	100775	}
100534	100776	break;
100535		- case 289: /* tridxby ::= INDEXED BY nm */
	100777	+ case 288: /* tridxby ::= INDEXED BY nm */
100536	100778	{
100537	100779	sqlite3ErrorMsg(pParse,
100538	100780	"the INDEXED BY clause is not allowed on UPDATE or DELETE statements "
100539	100781	"within triggers");
100540	100782	}
100541	100783	break;
100542		- case 290: /* tridxby ::= NOT INDEXED */
	100784	+ case 289: /* tridxby ::= NOT INDEXED */
100543	100785	{
100544	100786	sqlite3ErrorMsg(pParse,
100545	100787	"the NOT INDEXED clause is not allowed on UPDATE or DELETE statements "
100546	100788	"within triggers");
100547	100789	}
100548	100790	break;
100549		- case 291: /* trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist where_opt */
100550		-{ yygotominor.yy473 = sqlite3TriggerUpdateStep(pParse->db, &yymsp[-4].minor.yy0, yymsp[-1].minor.yy14, yymsp[0].minor.yy132, yymsp[-5].minor.yy186); }
100551		- break;
100552		- case 292: /* trigger_cmd ::= insert_cmd INTO trnm inscollist_opt VALUES LP itemlist RP */
100553		-{yygotominor.yy473 = sqlite3TriggerInsertStep(pParse->db, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy408, yymsp[-1].minor.yy14, 0, yymsp[-7].minor.yy186);}
100554		- break;
100555		- case 293: /* trigger_cmd ::= insert_cmd INTO trnm inscollist_opt select */
100556		-{yygotominor.yy473 = sqlite3TriggerInsertStep(pParse->db, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy408, 0, yymsp[0].minor.yy3, yymsp[-4].minor.yy186);}
100557		- break;
100558		- case 294: /* trigger_cmd ::= DELETE FROM trnm tridxby where_opt */
100559		-{yygotominor.yy473 = sqlite3TriggerDeleteStep(pParse->db, &yymsp[-2].minor.yy0, yymsp[0].minor.yy132);}
100560		- break;
100561		- case 295: /* trigger_cmd ::= select */
100562		-{yygotominor.yy473 = sqlite3TriggerSelectStep(pParse->db, yymsp[0].minor.yy3); }
100563		- break;
100564		- case 296: /* expr ::= RAISE LP IGNORE RP */
100565		-{
100566		- yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_RAISE, 0, 0, 0);
100567		- if( yygotominor.yy346.pExpr ){
100568		- yygotominor.yy346.pExpr->affinity = OE_Ignore;
100569		- }
100570		- yygotominor.yy346.zStart = yymsp[-3].minor.yy0.z;
100571		- yygotominor.yy346.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
100572		-}
100573		- break;
100574		- case 297: /* expr ::= RAISE LP raisetype COMMA nm RP */
100575		-{
100576		- yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_RAISE, 0, 0, &yymsp[-1].minor.yy0);
100577		- if( yygotominor.yy346.pExpr ) {
100578		- yygotominor.yy346.pExpr->affinity = (char)yymsp[-3].minor.yy328;
100579		- }
100580		- yygotominor.yy346.zStart = yymsp[-5].minor.yy0.z;
100581		- yygotominor.yy346.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
100582		-}
100583		- break;
100584		- case 298: /* raisetype ::= ROLLBACK */
100585		-{yygotominor.yy328 = OE_Rollback;}
100586		- break;
100587		- case 300: /* raisetype ::= FAIL */
100588		-{yygotominor.yy328 = OE_Fail;}
100589		- break;
100590		- case 301: /* cmd ::= DROP TRIGGER ifexists fullname */
100591		-{
100592		- sqlite3DropTrigger(pParse,yymsp[0].minor.yy65,yymsp[-1].minor.yy328);
100593		-}
100594		- break;
100595		- case 302: /* cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
100596		-{
100597		- sqlite3Attach(pParse, yymsp[-3].minor.yy346.pExpr, yymsp[-1].minor.yy346.pExpr, yymsp[0].minor.yy132);
100598		-}
100599		- break;
100600		- case 303: /* cmd ::= DETACH database_kw_opt expr */
100601		-{
100602		- sqlite3Detach(pParse, yymsp[0].minor.yy346.pExpr);
100603		-}
100604		- break;
100605		- case 308: /* cmd ::= REINDEX */
	100791	+ case 290: /* trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist where_opt */
	100792	+{ yygotominor.yy203 = sqlite3TriggerUpdateStep(pParse->db, &yymsp[-4].minor.yy0, yymsp[-1].minor.yy322, yymsp[0].minor.yy314, yymsp[-5].minor.yy210); }
	100793	+ break;
	100794	+ case 291: /* trigger_cmd ::= insert_cmd INTO trnm inscollist_opt VALUES LP itemlist RP */
	100795	+{yygotominor.yy203 = sqlite3TriggerInsertStep(pParse->db, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy384, yymsp[-1].minor.yy322, 0, yymsp[-7].minor.yy210);}
	100796	+ break;
	100797	+ case 292: /* trigger_cmd ::= insert_cmd INTO trnm inscollist_opt select */
	100798	+{yygotominor.yy203 = sqlite3TriggerInsertStep(pParse->db, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy384, 0, yymsp[0].minor.yy387, yymsp[-4].minor.yy210);}
	100799	+ break;
	100800	+ case 293: /* trigger_cmd ::= DELETE FROM trnm tridxby where_opt */
	100801	+{yygotominor.yy203 = sqlite3TriggerDeleteStep(pParse->db, &yymsp[-2].minor.yy0, yymsp[0].minor.yy314);}
	100802	+ break;
	100803	+ case 294: /* trigger_cmd ::= select */
	100804	+{yygotominor.yy203 = sqlite3TriggerSelectStep(pParse->db, yymsp[0].minor.yy387); }
	100805	+ break;
	100806	+ case 295: /* expr ::= RAISE LP IGNORE RP */
	100807	+{
	100808	+ yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_RAISE, 0, 0, 0);
	100809	+ if( yygotominor.yy118.pExpr ){
	100810	+ yygotominor.yy118.pExpr->affinity = OE_Ignore;
	100811	+ }
	100812	+ yygotominor.yy118.zStart = yymsp[-3].minor.yy0.z;
	100813	+ yygotominor.yy118.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
	100814	+}
	100815	+ break;
	100816	+ case 296: /* expr ::= RAISE LP raisetype COMMA nm RP */
	100817	+{
	100818	+ yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_RAISE, 0, 0, &yymsp[-1].minor.yy0);
	100819	+ if( yygotominor.yy118.pExpr ) {
	100820	+ yygotominor.yy118.pExpr->affinity = (char)yymsp[-3].minor.yy4;
	100821	+ }
	100822	+ yygotominor.yy118.zStart = yymsp[-5].minor.yy0.z;
	100823	+ yygotominor.yy118.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
	100824	+}
	100825	+ break;
	100826	+ case 297: /* raisetype ::= ROLLBACK */
	100827	+{yygotominor.yy4 = OE_Rollback;}
	100828	+ break;
	100829	+ case 299: /* raisetype ::= FAIL */
	100830	+{yygotominor.yy4 = OE_Fail;}
	100831	+ break;
	100832	+ case 300: /* cmd ::= DROP TRIGGER ifexists fullname */
	100833	+{
	100834	+ sqlite3DropTrigger(pParse,yymsp[0].minor.yy259,yymsp[-1].minor.yy4);
	100835	+}
	100836	+ break;
	100837	+ case 301: /* cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
	100838	+{
	100839	+ sqlite3Attach(pParse, yymsp[-3].minor.yy118.pExpr, yymsp[-1].minor.yy118.pExpr, yymsp[0].minor.yy314);
	100840	+}
	100841	+ break;
	100842	+ case 302: /* cmd ::= DETACH database_kw_opt expr */
	100843	+{
	100844	+ sqlite3Detach(pParse, yymsp[0].minor.yy118.pExpr);
	100845	+}
	100846	+ break;
	100847	+ case 307: /* cmd ::= REINDEX */
100606	100848	{sqlite3Reindex(pParse, 0, 0);}
100607	100849	break;
100608		- case 309: /* cmd ::= REINDEX nm dbnm */
	100850	+ case 308: /* cmd ::= REINDEX nm dbnm */
100609	100851	{sqlite3Reindex(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);}
100610	100852	break;
100611		- case 310: /* cmd ::= ANALYZE */
	100853	+ case 309: /* cmd ::= ANALYZE */
100612	100854	{sqlite3Analyze(pParse, 0, 0);}
100613	100855	break;
100614		- case 311: /* cmd ::= ANALYZE nm dbnm */
	100856	+ case 310: /* cmd ::= ANALYZE nm dbnm */
100615	100857	{sqlite3Analyze(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);}
100616	100858	break;
100617		- case 312: /* cmd ::= ALTER TABLE fullname RENAME TO nm */
	100859	+ case 311: /* cmd ::= ALTER TABLE fullname RENAME TO nm */
100618	100860	{
100619		- sqlite3AlterRenameTable(pParse,yymsp[-3].minor.yy65,&yymsp[0].minor.yy0);
	100861	+ sqlite3AlterRenameTable(pParse,yymsp[-3].minor.yy259,&yymsp[0].minor.yy0);
100620	100862	}
100621	100863	break;
100622		- case 313: /* cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt column */
	100864	+ case 312: /* cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt column */
100623	100865	{
100624	100866	sqlite3AlterFinishAddColumn(pParse, &yymsp[0].minor.yy0);
100625	100867	}
100626	100868	break;
100627		- case 314: /* add_column_fullname ::= fullname */
	100869	+ case 313: /* add_column_fullname ::= fullname */
100628	100870	{
100629	100871	pParse->db->lookaside.bEnabled = 0;
100630		- sqlite3AlterBeginAddColumn(pParse, yymsp[0].minor.yy65);
	100872	+ sqlite3AlterBeginAddColumn(pParse, yymsp[0].minor.yy259);
100631	100873	}
100632	100874	break;
100633		- case 317: /* cmd ::= create_vtab */
	100875	+ case 316: /* cmd ::= create_vtab */
100634	100876	{sqlite3VtabFinishParse(pParse,0);}
100635	100877	break;
100636		- case 318: /* cmd ::= create_vtab LP vtabarglist RP */
	100878	+ case 317: /* cmd ::= create_vtab LP vtabarglist RP */
100637	100879	{sqlite3VtabFinishParse(pParse,&yymsp[0].minor.yy0);}
100638	100880	break;
100639		- case 319: /* create_vtab ::= createkw VIRTUAL TABLE nm dbnm USING nm */
	100881	+ case 318: /* create_vtab ::= createkw VIRTUAL TABLE nm dbnm USING nm */
100640	100882	{
100641	100883	sqlite3VtabBeginParse(pParse, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
100642	100884	}
100643	100885	break;
100644		- case 322: /* vtabarg ::= */
	100886	+ case 321: /* vtabarg ::= */
100645	100887	{sqlite3VtabArgInit(pParse);}
100646	100888	break;
100647		- case 324: /* vtabargtoken ::= ANY */
100648		- case 325: /* vtabargtoken ::= lp anylist RP */ yytestcase(yyruleno==325);
100649		- case 326: /* lp ::= LP */ yytestcase(yyruleno==326);
	100889	+ case 323: /* vtabargtoken ::= ANY */
	100890	+ case 324: /* vtabargtoken ::= lp anylist RP */ yytestcase(yyruleno==324);
	100891	+ case 325: /* lp ::= LP */ yytestcase(yyruleno==325);
100650	100892	{sqlite3VtabArgExtend(pParse,&yymsp[0].minor.yy0);}
100651	100893	break;
100652	100894	default:
100653	100895	/* (0) input ::= cmdlist */ yytestcase(yyruleno==0);
100654	100896	/* (1) cmdlist ::= cmdlist ecmd */ yytestcase(yyruleno==1);
		@@ -100673,25 +100915,25 @@
100673	100915	/* (62) ccons ::= NULL onconf */ yytestcase(yyruleno==62);
100674	100916	/* (90) conslist ::= conslist COMMA tcons */ yytestcase(yyruleno==90);
100675	100917	/* (91) conslist ::= conslist tcons */ yytestcase(yyruleno==91);
100676	100918	/* (92) conslist ::= tcons */ yytestcase(yyruleno==92);
100677	100919	/* (93) tcons ::= CONSTRAINT nm */ yytestcase(yyruleno==93);
100678		- /* (269) plus_opt ::= PLUS */ yytestcase(yyruleno==269);
100679		- /* (270) plus_opt ::= */ yytestcase(yyruleno==270);
100680		- /* (280) foreach_clause ::= */ yytestcase(yyruleno==280);
100681		- /* (281) foreach_clause ::= FOR EACH ROW */ yytestcase(yyruleno==281);
100682		- /* (288) tridxby ::= */ yytestcase(yyruleno==288);
100683		- /* (306) database_kw_opt ::= DATABASE */ yytestcase(yyruleno==306);
100684		- /* (307) database_kw_opt ::= */ yytestcase(yyruleno==307);
100685		- /* (315) kwcolumn_opt ::= */ yytestcase(yyruleno==315);
100686		- /* (316) kwcolumn_opt ::= COLUMNKW */ yytestcase(yyruleno==316);
100687		- /* (320) vtabarglist ::= vtabarg */ yytestcase(yyruleno==320);
100688		- /* (321) vtabarglist ::= vtabarglist COMMA vtabarg */ yytestcase(yyruleno==321);
100689		- /* (323) vtabarg ::= vtabarg vtabargtoken */ yytestcase(yyruleno==323);
100690		- /* (327) anylist ::= */ yytestcase(yyruleno==327);
100691		- /* (328) anylist ::= anylist LP anylist RP */ yytestcase(yyruleno==328);
100692		- /* (329) anylist ::= anylist ANY */ yytestcase(yyruleno==329);
	100920	+ /* (268) plus_opt ::= PLUS */ yytestcase(yyruleno==268);
	100921	+ /* (269) plus_opt ::= */ yytestcase(yyruleno==269);
	100922	+ /* (279) foreach_clause ::= */ yytestcase(yyruleno==279);
	100923	+ /* (280) foreach_clause ::= FOR EACH ROW */ yytestcase(yyruleno==280);
	100924	+ /* (287) tridxby ::= */ yytestcase(yyruleno==287);
	100925	+ /* (305) database_kw_opt ::= DATABASE */ yytestcase(yyruleno==305);
	100926	+ /* (306) database_kw_opt ::= */ yytestcase(yyruleno==306);
	100927	+ /* (314) kwcolumn_opt ::= */ yytestcase(yyruleno==314);
	100928	+ /* (315) kwcolumn_opt ::= COLUMNKW */ yytestcase(yyruleno==315);
	100929	+ /* (319) vtabarglist ::= vtabarg */ yytestcase(yyruleno==319);
	100930	+ /* (320) vtabarglist ::= vtabarglist COMMA vtabarg */ yytestcase(yyruleno==320);
	100931	+ /* (322) vtabarg ::= vtabarg vtabargtoken */ yytestcase(yyruleno==322);
	100932	+ /* (326) anylist ::= */ yytestcase(yyruleno==326);
	100933	+ /* (327) anylist ::= anylist LP anylist RP */ yytestcase(yyruleno==327);
	100934	+ /* (328) anylist ::= anylist ANY */ yytestcase(yyruleno==328);
100693	100935	break;
100694	100936	};
100695	100937	yygoto = yyRuleInfo[yyruleno].lhs;
100696	100938	yysize = yyRuleInfo[yyruleno].nrhs;
100697	100939	yypParser->yyidx -= yysize;
		@@ -107179,13 +107421,61 @@
107179	107421	** argument to sqlite3Fts3SegReaderIterate()
107180	107422	*/
107181	107423	typedef struct TermSelect TermSelect;
107182	107424	struct TermSelect {
107183	107425	int isReqPos;
107184		- char aOutput; / Malloc'd output buffer */
107185		- int nOutput; /* Size of output in bytes */
	107426	+ char aaOutput[16]; / Malloc'd output buffer */
	107427	+ int anOutput[16]; /* Size of output in bytes */
107186	107428	};
	107429	+
	107430	+/*
	107431	+** Merge all doclists in the TermSelect.aaOutput[] array into a single
	107432	+** doclist stored in TermSelect.aaOutput[0]. If successful, delete all
	107433	+** other doclists (except the aaOutput[0] one) and return SQLITE_OK.
	107434	+**
	107435	+** If an OOM error occurs, return SQLITE_NOMEM. In this case it is
	107436	+** the responsibility of the caller to free any doclists left in the
	107437	+** TermSelect.aaOutput[] array.
	107438	+*/
	107439	+static int fts3TermSelectMerge(TermSelect *pTS){
	107440	+ int mergetype = (pTS->isReqPos ? MERGE_POS_OR : MERGE_OR);
	107441	+ char *aOut = 0;
	107442	+ int nOut = 0;
	107443	+ int i;
	107444	+
	107445	+ /* Loop through the doclists in the aaOutput[] array. Merge them all
	107446	+ ** into a single doclist.
	107447	+ */
	107448	+ for(i=0; i<SizeofArray(pTS->aaOutput); i++){
	107449	+ if( pTS->aaOutput[i] ){
	107450	+ if( !aOut ){
	107451	+ aOut = pTS->aaOutput[i];
	107452	+ nOut = pTS->anOutput[i];
	107453	+ pTS->aaOutput[0] = 0;
	107454	+ }else{
	107455	+ int nNew = nOut + pTS->anOutput[i];
	107456	+ char *aNew = sqlite3_malloc(nNew);
	107457	+ if( !aNew ){
	107458	+ sqlite3_free(aOut);
	107459	+ return SQLITE_NOMEM;
	107460	+ }
	107461	+ fts3DoclistMerge(mergetype, 0, 0,
	107462	+ aNew, &nNew, pTS->aaOutput[i], pTS->anOutput[i], aOut, nOut
	107463	+ );
	107464	+ sqlite3_free(pTS->aaOutput[i]);
	107465	+ sqlite3_free(aOut);
	107466	+ pTS->aaOutput[i] = 0;
	107467	+ aOut = aNew;
	107468	+ nOut = nNew;
	107469	+ }
	107470	+ }
	107471	+ }
	107472	+
	107473	+ pTS->aaOutput[0] = aOut;
	107474	+ pTS->anOutput[0] = nOut;
	107475	+ return SQLITE_OK;
	107476	+}
107187	107477
107188	107478	/*
107189	107479	** This function is used as the sqlite3Fts3SegReaderIterate() callback when
107190	107480	** querying the full-text index for a doclist associated with a term or
107191	107481	** term-prefix.
		@@ -107197,42 +107487,67 @@
107197	107487	int nTerm,
107198	107488	char *aDoclist,
107199	107489	int nDoclist
107200	107490	){
107201	107491	TermSelect pTS = (TermSelect )pContext;
107202		- int nNew = pTS->nOutput + nDoclist;
107203		- char *aNew = sqlite3_malloc(nNew);
107204	107492
107205	107493	UNUSED_PARAMETER(p);
107206	107494	UNUSED_PARAMETER(zTerm);
107207	107495	UNUSED_PARAMETER(nTerm);
107208	107496
107209		- if( !aNew ){
107210		- return SQLITE_NOMEM;
107211		- }
107212		-
107213		- if( pTS->nOutput==0 ){
	107497	+ if( pTS->aaOutput[0]==0 ){
107214	107498	/* If this is the first term selected, copy the doclist to the output
107215	107499	** buffer using memcpy(). TODO: Add a way to transfer control of the
107216	107500	** aDoclist buffer from the caller so as to avoid the memcpy().
107217	107501	*/
107218		- memcpy(aNew, aDoclist, nDoclist);
	107502	+ pTS->aaOutput[0] = sqlite3_malloc(nDoclist);
	107503	+ pTS->anOutput[0] = nDoclist;
	107504	+ if( pTS->aaOutput[0] ){
	107505	+ memcpy(pTS->aaOutput[0], aDoclist, nDoclist);
	107506	+ }else{
	107507	+ return SQLITE_NOMEM;
	107508	+ }
107219	107509	}else{
107220		- /* The output buffer is not empty. Merge doclist aDoclist with the
107221		- ** existing output. This can only happen with prefix-searches (as
107222		- ** searches for exact terms return exactly one doclist).
107223		- */
107224	107510	int mergetype = (pTS->isReqPos ? MERGE_POS_OR : MERGE_OR);
107225		- fts3DoclistMerge(mergetype, 0, 0,
107226		- aNew, &nNew, pTS->aOutput, pTS->nOutput, aDoclist, nDoclist
107227		- );
107228		- }
107229		-
107230		- sqlite3_free(pTS->aOutput);
107231		- pTS->aOutput = aNew;
107232		- pTS->nOutput = nNew;
107233		-
	107511	+ char *aMerge = aDoclist;
	107512	+ int nMerge = nDoclist;
	107513	+ int iOut;
	107514	+
	107515	+ for(iOut=0; iOut<SizeofArray(pTS->aaOutput); iOut++){
	107516	+ char *aNew;
	107517	+ int nNew;
	107518	+ if( pTS->aaOutput[iOut]==0 ){
	107519	+ assert( iOut>0 );
	107520	+ pTS->aaOutput[iOut] = aMerge;
	107521	+ pTS->anOutput[iOut] = nMerge;
	107522	+ break;
	107523	+ }
	107524	+
	107525	+ nNew = nMerge + pTS->anOutput[iOut];
	107526	+ aNew = sqlite3_malloc(nNew);
	107527	+ if( !aNew ){
	107528	+ if( aMerge!=aDoclist ){
	107529	+ sqlite3_free(aMerge);
	107530	+ }
	107531	+ return SQLITE_NOMEM;
	107532	+ }
	107533	+ fts3DoclistMerge(mergetype, 0, 0,
	107534	+ aNew, &nNew, pTS->aaOutput[iOut], pTS->anOutput[iOut], aMerge, nMerge
	107535	+ );
	107536	+
	107537	+ if( iOut>0 ) sqlite3_free(aMerge);
	107538	+ sqlite3_free(pTS->aaOutput[iOut]);
	107539	+ pTS->aaOutput[iOut] = 0;
	107540	+
	107541	+ aMerge = aNew;
	107542	+ nMerge = nNew;
	107543	+ if( (iOut+1)==SizeofArray(pTS->aaOutput) ){
	107544	+ pTS->aaOutput[iOut] = aMerge;
	107545	+ pTS->anOutput[iOut] = nMerge;
	107546	+ }
	107547	+ }
	107548	+ }
107234	107549	return SQLITE_OK;
107235	107550	}
107236	107551
107237	107552	/*
107238	107553	** This function retreives the doclist for the specified term (or term
		@@ -107352,16 +107667,21 @@
107352	107667	filter.nTerm = nTerm;
107353	107668
107354	107669	rc = sqlite3Fts3SegReaderIterate(p, apSegment, nSegment, &filter,
107355	107670	fts3TermSelectCb, (void *)&tsc
107356	107671	);
	107672	+ if( rc==SQLITE_OK ){
	107673	+ rc = fts3TermSelectMerge(&tsc);
	107674	+ }
107357	107675
107358	107676	if( rc==SQLITE_OK ){
107359		- *ppOut = tsc.aOutput;
107360		- *pnOut = tsc.nOutput;
	107677	+ *ppOut = tsc.aaOutput[0];
	107678	+ *pnOut = tsc.anOutput[0];
107361	107679	}else{
107362		- sqlite3_free(tsc.aOutput);
	107680	+ for(i=0; i<SizeofArray(tsc.aaOutput); i++){
	107681	+ sqlite3_free(tsc.aaOutput[i]);
	107682	+ }
107363	107683	}
107364	107684
107365	107685	finished:
107366	107686	sqlite3_reset(pStmt);
107367	107687	for(i=0; i<nSegment; i++){
107368	107688

	--- src/sqlite3.c
	+++ src/sqlite3.c
	@@ -514,11 +514,11 @@
514	/*
515	** Return true (non-zero) if the input is a integer that is too large
516	** to fit in 32-bits. This macro is used inside of various testcase()
517	** macros to verify that we have tested SQLite for large-file support.
518	*/
519	#define IS_BIG_INT(X) (((X)&(i64)0xffffffff)!=0)
520
521	/*
522	** The macro unlikely() is a hint that surrounds a boolean
523	** expression that is usually false. Macro likely() surrounds
524	** a boolean expression that is usually true. GCC is able to
	@@ -643,11 +643,11 @@
643	** [sqlite3_libversion_number()], [sqlite3_sourceid()],
644	** [sqlite_version()] and [sqlite_source_id()].
645	*/
646	#define SQLITE_VERSION "3.7.0"
647	#define SQLITE_VERSION_NUMBER 3007000
648	#define SQLITE_SOURCE_ID "2010-07-08 17:40:38 e396184cd3bdb96e29ac33af5d1f631cac553341"
649
650	/*
651	** CAPI3REF: Run-Time Library Version Numbers
652	** KEYWORDS: sqlite3_version, sqlite3_sourceid
653	**
	@@ -1015,15 +1015,16 @@
1015	#define SQLITE_OPEN_MASTER_JOURNAL 0x00004000 /* VFS only */
1016	#define SQLITE_OPEN_NOMUTEX 0x00008000 /* Ok for sqlite3_open_v2() */
1017	#define SQLITE_OPEN_FULLMUTEX 0x00010000 /* Ok for sqlite3_open_v2() */
1018	#define SQLITE_OPEN_SHAREDCACHE 0x00020000 /* Ok for sqlite3_open_v2() */
1019	#define SQLITE_OPEN_PRIVATECACHE 0x00040000 /* Ok for sqlite3_open_v2() */

1020
1021	/*
1022	** CAPI3REF: Device Characteristics
1023	**
1024	** The xDeviceCapabilities method of the [sqlite3_io_methods]
1025	** object returns an integer which is a vector of the these
1026	** bit values expressing I/O characteristics of the mass storage
1027	** device that holds the file that the [sqlite3_io_methods]
1028	** refers to.
1029	**
	@@ -1199,15 +1200,14 @@
1199	int (xCheckReservedLock)(sqlite3_file, int *pResOut);
1200	int (xFileControl)(sqlite3_file, int op, void *pArg);
1201	int (xSectorSize)(sqlite3_file);
1202	int (xDeviceCharacteristics)(sqlite3_file);
1203	/* Methods above are valid for version 1 */
1204	int (xShmOpen)(sqlite3_file);
1205	int (xShmLock)(sqlite3_file, int offset, int n, int flags);
1206	int (xShmMap)(sqlite3_file, int iPage, int pgsz, int, void volatile**);
1207	void (xShmBarrier)(sqlite3_file);
1208	int (xShmClose)(sqlite3_file, int deleteFlag);
1209	/* Methods above are valid for version 2 */
1210	/* Additional methods may be added in future releases */
1211	};
1212
1213	/*
	@@ -1426,17 +1426,24 @@
1426	** the xAccess method of an [sqlite3_vfs] object. They determine
1427	** what kind of permissions the xAccess method is looking for.
1428	** With SQLITE_ACCESS_EXISTS, the xAccess method
1429	** simply checks whether the file exists.
1430	** With SQLITE_ACCESS_READWRITE, the xAccess method
1431	** checks whether the file is both readable and writable.





1432	** With SQLITE_ACCESS_READ, the xAccess method
1433	** checks whether the file is readable.


1434	*/
1435	#define SQLITE_ACCESS_EXISTS 0
1436	#define SQLITE_ACCESS_READWRITE 1
1437	#define SQLITE_ACCESS_READ 2
1438
1439	/*
1440	** CAPI3REF: Flags for the xShmLock VFS method
1441	**
1442	** These integer constants define the various locking operations
	@@ -5767,11 +5774,11 @@
5767	**
5768	** <dt>SQLITE_DBSTATUS_CACHE_USED</dt>
5769	** <dd>^This parameter returns the approximate number of of bytes of heap
5770	** memory used by all pager caches associated with the database connection.
5771	** ^The highwater mark associated with SQLITE_DBSTATUS_CACHE_USED is always 0.
5772	** checked out.</dd>)^
5773	** </dl>
5774	*/
5775	#define SQLITE_DBSTATUS_LOOKASIDE_USED 0
5776	#define SQLITE_DBSTATUS_CACHE_USED 1
5777	#define SQLITE_DBSTATUS_MAX 1 /* Largest defined DBSTATUS */
	@@ -8307,15 +8314,14 @@
8307	SQLITE_PRIVATE int sqlite3OsCheckReservedLock(sqlite3_file id, int pResOut);
8308	SQLITE_PRIVATE int sqlite3OsFileControl(sqlite3_file,int,void);
8309	#define SQLITE_FCNTL_DB_UNCHANGED 0xca093fa0
8310	SQLITE_PRIVATE int sqlite3OsSectorSize(sqlite3_file *id);
8311	SQLITE_PRIVATE int sqlite3OsDeviceCharacteristics(sqlite3_file *id);
8312	SQLITE_PRIVATE int sqlite3OsShmOpen(sqlite3_file *id);
8313	SQLITE_PRIVATE int sqlite3OsShmLock(sqlite3_file *id, int, int, int);
8314	SQLITE_PRIVATE void sqlite3OsShmBarrier(sqlite3_file *id);
8315	SQLITE_PRIVATE int sqlite3OsShmClose(sqlite3_file *id, int);
8316	SQLITE_PRIVATE int sqlite3OsShmMap(sqlite3_file ,int,int,int,void volatile *);
8317
8318	/*
8319	** Functions for accessing sqlite3_vfs methods
8320	*/
8321	SQLITE_PRIVATE int sqlite3OsOpen(sqlite3_vfs , const char , sqlite3_file, int, int );
	@@ -10665,10 +10671,11 @@
10665	SQLITE_PRIVATE void sqlite3ValueApplyAffinity(sqlite3_value *, u8, u8);
10666	#ifndef SQLITE_AMALGAMATION
10667	SQLITE_PRIVATE const unsigned char sqlite3OpcodeProperty[];
10668	SQLITE_PRIVATE const unsigned char sqlite3UpperToLower[];
10669	SQLITE_PRIVATE const unsigned char sqlite3CtypeMap[];

10670	SQLITE_PRIVATE SQLITE_WSD struct Sqlite3Config sqlite3Config;
10671	SQLITE_PRIVATE SQLITE_WSD FuncDefHash sqlite3GlobalFunctions;
10672	#ifndef SQLITE_OMIT_WSD
10673	SQLITE_PRIVATE int sqlite3PendingByte;
10674	#endif
	@@ -11110,10 +11117,19 @@
11110	** Hash table for global functions - functions common to all
11111	** database connections. After initialization, this table is
11112	** read-only.
11113	*/
11114	SQLITE_PRIVATE SQLITE_WSD FuncDefHash sqlite3GlobalFunctions;









11115
11116	/*
11117	** The value of the "pending" byte must be 0x40000000 (1 byte past the
11118	** 1-gibabyte boundary) in a compatible database. SQLite never uses
11119	** the database page that contains the pending byte. It never attempts
	@@ -12875,30 +12891,27 @@
12875	return (xSectorSize ? xSectorSize(id) : SQLITE_DEFAULT_SECTOR_SIZE);
12876	}
12877	SQLITE_PRIVATE int sqlite3OsDeviceCharacteristics(sqlite3_file *id){
12878	return id->pMethods->xDeviceCharacteristics(id);
12879	}
12880	SQLITE_PRIVATE int sqlite3OsShmOpen(sqlite3_file *id){
12881	return id->pMethods->xShmOpen(id);
12882	}
12883	SQLITE_PRIVATE int sqlite3OsShmLock(sqlite3_file *id, int offset, int n, int flags){
12884	return id->pMethods->xShmLock(id, offset, n, flags);
12885	}
12886	SQLITE_PRIVATE void sqlite3OsShmBarrier(sqlite3_file *id){
12887	id->pMethods->xShmBarrier(id);
12888	}
12889	SQLITE_PRIVATE int sqlite3OsShmClose(sqlite3_file *id, int deleteFlag){
12890	return id->pMethods->xShmClose(id, deleteFlag);
12891	}
12892	SQLITE_PRIVATE int sqlite3OsShmMap(
12893	sqlite3_file *id,
12894	int iPage,
12895	int pgsz,
12896	int isWrite,
12897	void volatile **pp
12898	){
12899	return id->pMethods->xShmMap(id, iPage, pgsz, isWrite, pp);
12900	}
12901
12902	/*
12903	** The next group of routines are convenience wrappers around the
12904	** VFS methods.
	@@ -12910,15 +12923,15 @@
12910	int flags,
12911	int *pFlagsOut
12912	){
12913	int rc;
12914	DO_OS_MALLOC_TEST(0);
12915	/* 0x7f3f is a mask of SQLITE_OPEN_ flags that are valid to be passed
12916	** down into the VFS layer. Some SQLITE_OPEN_ flags (for example,
12917	** SQLITE_OPEN_FULLMUTEX or SQLITE_OPEN_SHAREDCACHE) are blocked before
12918	** reaching the VFS. */
12919	rc = pVfs->xOpen(pVfs, zPath, pFile, flags & 0x7f3f, pFlagsOut);
12920	assert( rc==SQLITE_OK \|\| pFile->pMethods==0 );
12921	return rc;
12922	}
12923	SQLITE_PRIVATE int sqlite3OsDelete(sqlite3_vfs pVfs, const char zPath, int dirSync){
12924	return pVfs->xDelete(pVfs, zPath, dirSync);
	@@ -25708,74 +25721,100 @@
25708	sqlite3_free(p);
25709	}
25710	}
25711
25712	/*
25713	** Open a shared-memory area associated with open database file fd.
25714	** This particular implementation uses mmapped files.
25715	**
25716	** The file used to implement shared-memory is in the same directory
25717	** as the open database file and has the same name as the open database
25718	** file with the "-shm" suffix added. For example, if the database file
25719	** is "/home/user1/config.db" then the file that is created and mmapped
25720	** for shared memory will be called "/home/user1/config.db-shm". We
25721	** experimented with using files in /dev/tmp or an some other tmpfs mount.
25722	** But if a file in a different directory from the database file is used,
25723	** then differing access permissions or a chroot() might cause two different
25724	** processes on the same database to end up using different files for
25725	** shared memory - meaning that their memory would not really be shared -
25726	** resulting in database corruption.









25727	**
25728	** When opening a new shared-memory file, if no other instances of that
25729	** file are currently open, in this process or in other processes, then
25730	** the file must be truncated to zero length or have its header cleared.
25731	*/
25732	static int unixShmOpen(
25733	sqlite3_file fd / The file descriptor of the associated database */
25734	){
25735	struct unixShm p = 0; / The connection to be opened */
25736	struct unixShmNode pShmNode = 0; / The underlying mmapped file */
25737	int rc; /* Result code */
25738	struct unixFile pDbFd; / Underlying database file */
25739	unixInodeInfo pInode; / The inode of fd */
25740	char zShmFilename; / Name of the file used for SHM */
25741	int nShmFilename; /* Size of the SHM filename in bytes */
25742
25743	/* Allocate space for the new sqlite3_shm object.
25744	*/
25745	p = sqlite3_malloc( sizeof(*p) );
25746	if( p==0 ) return SQLITE_NOMEM;
25747	memset(p, 0, sizeof(*p));
25748	pDbFd = (struct unixFile*)fd;
25749	assert( pDbFd->pShm==0 );
25750
25751	/* Check to see if a unixShmNode object already exists. Reuse an existing
25752	** one if present. Create a new one if necessary.
25753	*/
25754	unixEnterMutex();
25755	pInode = pDbFd->pInode;
25756	pShmNode = pInode->pShmNode;
25757	if( pShmNode==0 ){















25758	nShmFilename = 5 + (int)strlen(pDbFd->zPath);

25759	pShmNode = sqlite3_malloc( sizeof(*pShmNode) + nShmFilename );
25760	if( pShmNode==0 ){
25761	rc = SQLITE_NOMEM;
25762	goto shm_open_err;
25763	}
25764	memset(pShmNode, 0, sizeof(*pShmNode));
25765	zShmFilename = pShmNode->zFilename = (char*)&pShmNode[1];





25766	sqlite3_snprintf(nShmFilename, zShmFilename, "%s-shm", pDbFd->zPath);

25767	pShmNode->h = -1;
25768	pDbFd->pInode->pShmNode = pShmNode;
25769	pShmNode->pInode = pDbFd->pInode;
25770	pShmNode->mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST);
25771	if( pShmNode->mutex==0 ){
25772	rc = SQLITE_NOMEM;
25773	goto shm_open_err;
25774	}
25775
25776	pShmNode->h = open(zShmFilename, O_RDWR\|O_CREAT, 0664);
25777	if( pShmNode->h<0 ){
25778	rc = SQLITE_CANTOPEN_BKPT;
25779	goto shm_open_err;
25780	}
25781
	@@ -25794,18 +25833,28 @@
25794	if( rc ) goto shm_open_err;
25795	}
25796
25797	/* Make the new connection a child of the unixShmNode */
25798	p->pShmNode = pShmNode;
25799	p->pNext = pShmNode->pFirst;
25800	#ifdef SQLITE_DEBUG
25801	p->id = pShmNode->nextShmId++;
25802	#endif
25803	pShmNode->pFirst = p;
25804	pShmNode->nRef++;
25805	pDbFd->pShm = p;
25806	unixLeaveMutex();












25807	return SQLITE_OK;
25808
25809	/* Jump here on any error */
25810	shm_open_err:
25811	unixShmPurge(pDbFd); /* This call frees pShmNode if required */
	@@ -25813,53 +25862,111 @@
25813	unixLeaveMutex();
25814	return rc;
25815	}
25816
25817	/*
25818	** Close a connection to shared-memory. Delete the underlying
25819	** storage if deleteFlag is true.















25820	*/
25821	static int unixShmClose(
25822	sqlite3_file fd, / The underlying database file */
25823	int deleteFlag /* Delete shared-memory if true */



25824	){
25825	unixShm p; / The connection to be closed */
25826	unixShmNode pShmNode; / The underlying shared-memory file */
25827	unixShm *pp; / For looping over sibling connections */
25828	unixFile pDbFd; / The underlying database file */
25829
25830	pDbFd = (unixFile*)fd;
25831	p = pDbFd->pShm;
25832	if( p==0 ) return SQLITE_OK;




25833	pShmNode = p->pShmNode;
25834
25835	assert( pShmNode==pDbFd->pInode->pShmNode );
25836	assert( pShmNode->pInode==pDbFd->pInode );
25837
25838	/* Remove connection p from the set of connections associated
25839	** with pShmNode */
25840	sqlite3_mutex_enter(pShmNode->mutex);
25841	for(pp=&pShmNode->pFirst; (pp)!=p; pp = &(pp)->pNext){}
25842	*pp = p->pNext;
25843
25844	/* Free the connection p */
25845	sqlite3_free(p);
25846	pDbFd->pShm = 0;























































25847	sqlite3_mutex_leave(pShmNode->mutex);
25848
25849	/* If pShmNode->nRef has reached 0, then close the underlying
25850	** shared-memory file, too */
25851	unixEnterMutex();
25852	assert( pShmNode->nRef>0 );
25853	pShmNode->nRef--;
25854	if( pShmNode->nRef==0 ){
25855	if( deleteFlag ) unlink(pShmNode->zFilename);
25856	unixShmPurge(pDbFd);
25857	}
25858	unixLeaveMutex();
25859
25860	return SQLITE_OK;
25861	}
25862
25863	/*
25864	** Change the lock state for a shared-memory segment.
25865	**
	@@ -25985,111 +26092,64 @@
25985	unixEnterMutex();
25986	unixLeaveMutex();
25987	}
25988
25989	/*
25990	** This function is called to obtain a pointer to region iRegion of the
25991	** shared-memory associated with the database file fd. Shared-memory regions
25992	** are numbered starting from zero. Each shared-memory region is szRegion
25993	** bytes in size.
25994	**
25995	** If an error occurs, an error code is returned and *pp is set to NULL.
25996	**
25997	** Otherwise, if the isWrite parameter is 0 and the requested shared-memory
25998	** region has not been allocated (by any client, including one running in a
25999	** separate process), then *pp is set to NULL and SQLITE_OK returned. If
26000	** isWrite is non-zero and the requested shared-memory region has not yet
26001	** been allocated, it is allocated by this function.
26002	**
26003	** If the shared-memory region has already been allocated or is allocated by
26004	** this call as described above, then it is mapped into this processes
26005	** address space (if it is not already), *pp is set to point to the mapped
26006	** memory and SQLITE_OK returned.
26007	*/
26008	static int unixShmMap(
26009	sqlite3_file fd, / Handle open on database file */
26010	int iRegion, /* Region to retrieve */
26011	int szRegion, /* Size of regions */
26012	int isWrite, /* True to extend file if necessary */
26013	void volatile *pp / OUT: Mapped memory */
26014	){
26015	unixFile pDbFd = (unixFile)fd;
26016	unixShm *p = pDbFd->pShm;
26017	unixShmNode *pShmNode = p->pShmNode;
26018	int rc = SQLITE_OK;
26019
26020	sqlite3_mutex_enter(pShmNode->mutex);
26021	assert( szRegion==pShmNode->szRegion \|\| pShmNode->nRegion==0 );
26022
26023	if( pShmNode->nRegion<=iRegion ){
26024	char *apNew; / New apRegion[] array */
26025	int nByte = (iRegion+1)szRegion; / Minimum required file size */
26026	struct stat sStat; /* Used by fstat() */
26027
26028	pShmNode->szRegion = szRegion;
26029
26030	/* The requested region is not mapped into this processes address space.
26031	** Check to see if it has been allocated (i.e. if the wal-index file is
26032	** large enough to contain the requested region).
26033	*/
26034	if( fstat(pShmNode->h, &sStat) ){
26035	rc = SQLITE_IOERR_SHMSIZE;
26036	goto shmpage_out;
26037	}
26038
26039	if( sStat.st_size<nByte ){
26040	/* The requested memory region does not exist. If isWrite is set to
26041	** zero, exit early. *pp will be set to NULL and SQLITE_OK returned.
26042	**
26043	** Alternatively, if isWrite is non-zero, use ftruncate() to allocate
26044	** the requested memory region.
26045	*/
26046	if( !isWrite ) goto shmpage_out;
26047	if( ftruncate(pShmNode->h, nByte) ){
26048	rc = SQLITE_IOERR_SHMSIZE;
26049	goto shmpage_out;
26050	}
26051	}
26052
26053	/* Map the requested memory region into this processes address space. */
26054	apNew = (char **)sqlite3_realloc(
26055	pShmNode->apRegion, (iRegion+1)sizeof(char )
26056	);
26057	if( !apNew ){
26058	rc = SQLITE_IOERR_NOMEM;
26059	goto shmpage_out;
26060	}
26061	pShmNode->apRegion = apNew;
26062	while(pShmNode->nRegion<=iRegion){
26063	void *pMem = mmap(0, szRegion, PROT_READ\|PROT_WRITE,
26064	MAP_SHARED, pShmNode->h, iRegion*szRegion
26065	);
26066	if( pMem==MAP_FAILED ){
26067	rc = SQLITE_IOERR;
26068	goto shmpage_out;
26069	}
26070	pShmNode->apRegion[pShmNode->nRegion] = pMem;
26071	pShmNode->nRegion++;
26072	}
26073	}
26074
26075	shmpage_out:
26076	if( pShmNode->nRegion>iRegion ){
26077	*pp = pShmNode->apRegion[iRegion];
26078	}else{
26079	*pp = 0;
26080	}
26081	sqlite3_mutex_leave(pShmNode->mutex);
26082	return rc;












26083	}

26084
26085	#else
26086	# define unixShmOpen 0
26087	# define unixShmLock 0
26088	# define unixShmMap 0
26089	# define unixShmBarrier 0
26090	# define unixShmClose 0
26091	#endif /* #ifndef SQLITE_OMIT_WAL */
26092
26093	/*
26094	** Here ends the implementation of all sqlite3_file methods.
26095	**
	@@ -26143,15 +26203,14 @@
26143	UNLOCK, /* xUnlock */ \
26144	CKLOCK, /* xCheckReservedLock */ \
26145	unixFileControl, /* xFileControl */ \
26146	unixSectorSize, /* xSectorSize */ \
26147	unixDeviceCharacteristics, /* xDeviceCapabilities */ \
26148	unixShmOpen, /* xShmOpen */ \
26149	unixShmLock, /* xShmLock */ \
26150	unixShmMap, /* xShmMap */ \
26151	unixShmBarrier, /* xShmBarrier */ \
26152	unixShmClose /* xShmClose */ \
26153	}; \
26154	static const sqlite3_io_methods FINDER##Impl(const char z, unixFile *p){ \
26155	UNUSED_PARAMETER(z); UNUSED_PARAMETER(p); \
26156	return &METHOD; \
26157	} \
	@@ -26164,29 +26223,29 @@
26164	** are also created.
26165	*/
26166	IOMETHODS(
26167	posixIoFinder, /* Finder function name */
26168	posixIoMethods, /* sqlite3_io_methods object name */
26169	2, /* ShmOpen is enabled */
26170	unixClose, /* xClose method */
26171	unixLock, /* xLock method */
26172	unixUnlock, /* xUnlock method */
26173	unixCheckReservedLock /* xCheckReservedLock method */
26174	)
26175	IOMETHODS(
26176	nolockIoFinder, /* Finder function name */
26177	nolockIoMethods, /* sqlite3_io_methods object name */
26178	1, /* ShmOpen is disabled */
26179	nolockClose, /* xClose method */
26180	nolockLock, /* xLock method */
26181	nolockUnlock, /* xUnlock method */
26182	nolockCheckReservedLock /* xCheckReservedLock method */
26183	)
26184	IOMETHODS(
26185	dotlockIoFinder, /* Finder function name */
26186	dotlockIoMethods, /* sqlite3_io_methods object name */
26187	1, /* ShmOpen is disabled */
26188	dotlockClose, /* xClose method */
26189	dotlockLock, /* xLock method */
26190	dotlockUnlock, /* xUnlock method */
26191	dotlockCheckReservedLock /* xCheckReservedLock method */
26192	)
	@@ -26193,11 +26252,11 @@
26193
26194	#if SQLITE_ENABLE_LOCKING_STYLE && !OS_VXWORKS
26195	IOMETHODS(
26196	flockIoFinder, /* Finder function name */
26197	flockIoMethods, /* sqlite3_io_methods object name */
26198	1, /* ShmOpen is disabled */
26199	flockClose, /* xClose method */
26200	flockLock, /* xLock method */
26201	flockUnlock, /* xUnlock method */
26202	flockCheckReservedLock /* xCheckReservedLock method */
26203	)
	@@ -26205,11 +26264,11 @@
26205
26206	#if OS_VXWORKS
26207	IOMETHODS(
26208	semIoFinder, /* Finder function name */
26209	semIoMethods, /* sqlite3_io_methods object name */
26210	1, /* ShmOpen is disabled */
26211	semClose, /* xClose method */
26212	semLock, /* xLock method */
26213	semUnlock, /* xUnlock method */
26214	semCheckReservedLock /* xCheckReservedLock method */
26215	)
	@@ -26217,11 +26276,11 @@
26217
26218	#if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE
26219	IOMETHODS(
26220	afpIoFinder, /* Finder function name */
26221	afpIoMethods, /* sqlite3_io_methods object name */
26222	1, /* ShmOpen is disabled */
26223	afpClose, /* xClose method */
26224	afpLock, /* xLock method */
26225	afpUnlock, /* xUnlock method */
26226	afpCheckReservedLock /* xCheckReservedLock method */
26227	)
	@@ -26242,11 +26301,11 @@
26242	static int proxyUnlock(sqlite3_file*, int);
26243	static int proxyCheckReservedLock(sqlite3_file, int);
26244	IOMETHODS(
26245	proxyIoFinder, /* Finder function name */
26246	proxyIoMethods, /* sqlite3_io_methods object name */
26247	1, /* ShmOpen is disabled */
26248	proxyClose, /* xClose method */
26249	proxyLock, /* xLock method */
26250	proxyUnlock, /* xUnlock method */
26251	proxyCheckReservedLock /* xCheckReservedLock method */
26252	)
	@@ -26255,11 +26314,11 @@
26255	/* nfs lockd on OSX 10.3+ doesn't clear write locks when a read lock is set */
26256	#if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE
26257	IOMETHODS(
26258	nfsIoFinder, /* Finder function name */
26259	nfsIoMethods, /* sqlite3_io_methods object name */
26260	1, /* ShmOpen is disabled */
26261	unixClose, /* xClose method */
26262	unixLock, /* xLock method */
26263	nfsUnlock, /* xUnlock method */
26264	unixCheckReservedLock /* xCheckReservedLock method */
26265	)
	@@ -26717,10 +26776,55 @@
26717	unixLeaveMutex();
26718	}
26719	#endif /* if !OS_VXWORKS */
26720	return pUnused;
26721	}













































26722
26723	/*
26724	** Open the file zPath.
26725	**
26726	** Previously, the SQLite OS layer used three functions in place of this
	@@ -26768,13 +26872,15 @@
26768
26769	/* If creating a master or main-file journal, this function will open
26770	** a file-descriptor on the directory too. The first time unixSync()
26771	** is called the directory file descriptor will be fsync()ed and close()d.
26772	*/
26773	int isOpenDirectory = (isCreate &&
26774	(eType==SQLITE_OPEN_MASTER_JOURNAL \|\| eType==SQLITE_OPEN_MAIN_JOURNAL)
26775	);


26776
26777	/* If argument zPath is a NULL pointer, this function is required to open
26778	** a temporary file. Use this buffer to store the file name in.
26779	*/
26780	char zTmpname[MAX_PATHNAME+1];
	@@ -26790,21 +26896,22 @@
26790	assert((isReadonly==0 \|\| isReadWrite==0) && (isReadWrite \|\| isReadonly));
26791	assert(isCreate==0 \|\| isReadWrite);
26792	assert(isExclusive==0 \|\| isCreate);
26793	assert(isDelete==0 \|\| isCreate);
26794
26795	/* The main DB, main journal, and master journal are never automatically
26796	** deleted. Nor are they ever temporary files. */
26797	assert( (!isDelete && zName) \|\| eType!=SQLITE_OPEN_MAIN_DB );
26798	assert( (!isDelete && zName) \|\| eType!=SQLITE_OPEN_MAIN_JOURNAL );
26799	assert( (!isDelete && zName) \|\| eType!=SQLITE_OPEN_MASTER_JOURNAL );

26800
26801	/* Assert that the upper layer has set one of the "file-type" flags. */
26802	assert( eType==SQLITE_OPEN_MAIN_DB \|\| eType==SQLITE_OPEN_TEMP_DB
26803	\|\| eType==SQLITE_OPEN_MAIN_JOURNAL \|\| eType==SQLITE_OPEN_TEMP_JOURNAL
26804	\|\| eType==SQLITE_OPEN_SUBJOURNAL \|\| eType==SQLITE_OPEN_MASTER_JOURNAL
26805	\|\| eType==SQLITE_OPEN_TRANSIENT_DB
26806	);
26807
26808	memset(p, 0, sizeof(unixFile));
26809
26810	if( eType==SQLITE_OPEN_MAIN_DB ){
	@@ -26838,11 +26945,17 @@
26838	if( isCreate ) openFlags \|= O_CREAT;
26839	if( isExclusive ) openFlags \|= (O_EXCL\|O_NOFOLLOW);
26840	openFlags \|= (O_LARGEFILE\|O_BINARY);
26841
26842	if( fd<0 ){
26843	mode_t openMode = (isDelete?0600:SQLITE_DEFAULT_FILE_PERMISSIONS);






26844	fd = open(zName, openFlags, openMode);
26845	OSTRACE(("OPENX %-3d %s 0%o\n", fd, zName, openFlags));
26846	if( fd<0 && errno!=EISDIR && isReadWrite && !isExclusive ){
26847	/* Failed to open the file for read/write access. Try read-only. */
26848	flags &= ~(SQLITE_OPEN_READWRITE\|SQLITE_OPEN_CREATE);
	@@ -26981,11 +27094,13 @@
26981	int dirSync /* If true, fsync() directory after deleting file */
26982	){
26983	int rc = SQLITE_OK;
26984	UNUSED_PARAMETER(NotUsed);
26985	SimulateIOError(return SQLITE_IOERR_DELETE);
26986	unlink(zPath);


26987	#ifndef SQLITE_DISABLE_DIRSYNC
26988	if( dirSync ){
26989	int fd;
26990	rc = openDirectory(zPath, &fd);
26991	if( rc==SQLITE_OK ){
	@@ -29959,15 +30074,10 @@
29959	static int winDeviceCharacteristics(sqlite3_file *id){
29960	UNUSED_PARAMETER(id);
29961	return SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN;
29962	}
29963
29964	/****************************************************************************
29965	******************************* Shared Memory ***************************
29966	**
29967	** The next subdivision of code manages the shared-memory primitives.
29968	*/
29969	#ifndef SQLITE_OMIT_WAL
29970
29971	/*
29972	** Helper functions to obtain and relinquish the global mutex. The
29973	** global mutex is used to protect the winLockInfo objects used by
	@@ -29977,11 +30087,11 @@
29977	** is held when required. This function is only used as part of assert()
29978	** statements. e.g.
29979	**
29980	** winShmEnterMutex()
29981	** assert( winShmMutexHeld() );
29982	** winEnterLeave()
29983	*/
29984	static void winShmEnterMutex(void){
29985	sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
29986	}
29987	static void winShmLeaveMutex(void){
	@@ -30013,15 +30123,10 @@
30013	**
30014	** Either winShmNode.mutex must be held or winShmNode.nRef==0 and
30015	** winShmMutexHeld() is true when reading or writing any other field
30016	** in this structure.
30017	**
30018	** To avoid deadlocks, mutex and mutexBuf are always released in the
30019	** reverse order that they are acquired. mutexBuf is always acquired
30020	** first and released last. This invariant is check by asserting
30021	** sqlite3_mutex_notheld() on mutex whenever mutexBuf is acquired or
30022	** released.
30023	*/
30024	struct winShmNode {
30025	sqlite3_mutex mutex; / Mutex to access this object */
30026	char zFilename; / Name of the file */
30027	winFile hFile; /* File handle from winOpen */
	@@ -30051,21 +30156,25 @@
30051
30052	/*
30053	** Structure used internally by this VFS to record the state of an
30054	** open shared memory connection.
30055	**
30056	** winShm.pFile->mutex must be held while reading or writing the
30057	** winShm.pNext and winShm.locks[] elements.
30058	**
30059	** The winShm.pFile element is initialized when the object is created
30060	** and is read-only thereafter.



30061	*/
30062	struct winShm {
30063	winShmNode pShmNode; / The underlying winShmNode object */
30064	winShm pNext; / Next winShm with the same winShmNode */
30065	u8 hasMutex; /* True if holding the winShmNode mutex */
30066	u8 hasMutexBuf; /* True if holding pFile->mutexBuf */

30067	#ifdef SQLITE_DEBUG
30068	u8 id; /* Id of this connection with its winShmNode */
30069	#endif
30070	};
30071
	@@ -30096,27 +30205,32 @@
30096
30097	/* Initialize the locking parameters */
30098	dwFlags = LOCKFILE_FAIL_IMMEDIATELY;
30099	if( lockType == _SHM_WRLCK ) dwFlags \|= LOCKFILE_EXCLUSIVE_LOCK;
30100
30101	/* Find the first bit in lockMask that is set */
30102	memset(&ovlp, 0, sizeof(OVERLAPPED));
30103	ovlp.Offset = ofst;
30104
30105	/* Release/Acquire the system-level lock */
30106	if( lockType==_SHM_UNLCK ){
30107	rc = UnlockFileEx(pFile->hFile.h, 0, nByte, 0, &ovlp);
30108	}else{
30109	rc = LockFileEx(pFile->hFile.h, dwFlags, 0, nByte, 0, &ovlp);
30110	}
30111	if( !rc ){
30112	OSTRACE(("SHM-LOCK %d %s ERROR 0x%08lx\n",
30113	pFile->hFile.h,
30114	lockType==_SHM_UNLCK ? "UnlockFileEx" : "LockFileEx",
30115	GetLastError()));

30116	}
30117	rc = (rc!=0) ? SQLITE_OK : SQLITE_BUSY;





30118
30119	return rc;
30120	}
30121
30122	/* Forward references to VFS methods */
	@@ -30160,35 +30274,23 @@
30160	}
30161	}
30162	}
30163
30164	/*
30165	** Open a shared-memory area. This particular implementation uses
30166	** mmapped files.
30167	**
30168	** zName is a filename used to identify the shared-memory area. The
30169	** implementation does not (and perhaps should not) use this name
30170	** directly, but rather use it as a template for finding an appropriate
30171	** name for the shared-memory storage. In this implementation, the
30172	** string "-index" is appended to zName and used as the name of the
30173	** mmapped file.
30174	**
30175	** When opening a new shared-memory file, if no other instances of that
30176	** file are currently open, in this process or in other processes, then
30177	** the file must be truncated to zero length or have its header cleared.
30178	*/
30179	static int winShmOpen(
30180	sqlite3_file fd / The file to which to attach shared memory */
30181	){
30182	struct winFile pDbFd; / Database to which to attach SHM */
30183	struct winShm p; / The connection to be opened */
30184	struct winShmNode pShmNode = 0; / The underlying mmapped file */
30185	int rc; /* Result code */
30186	struct winShmNode pNew; / Newly allocated winShmNode */
30187	int nName; /* Size of zName in bytes */
30188
30189	pDbFd = (winFile*)fd;
30190	assert( pDbFd->pShm==0 ); /* Not previously opened */
30191
30192	/* Allocate space for the new sqlite3_shm object. Also speculatively
30193	** allocate space for a new winShmNode and filename.
30194	*/
	@@ -30255,18 +30357,28 @@
30255	if( rc ) goto shm_open_err;
30256	}
30257
30258	/* Make the new connection a child of the winShmNode */
30259	p->pShmNode = pShmNode;
30260	p->pNext = pShmNode->pFirst;
30261	#ifdef SQLITE_DEBUG
30262	p->id = pShmNode->nextShmId++;
30263	#endif
30264	pShmNode->pFirst = p;
30265	pShmNode->nRef++;
30266	pDbFd->pShm = p;
30267	winShmLeaveMutex();












30268	return SQLITE_OK;
30269
30270	/* Jump here on any error */
30271	shm_open_err:
30272	winShmSystemLock(pShmNode, _SHM_UNLCK, WIN_SHM_DMS, 1);
	@@ -30279,11 +30391,11 @@
30279
30280	/*
30281	** Close a connection to shared-memory. Delete the underlying
30282	** storage if deleteFlag is true.
30283	*/
30284	static int winShmClose(
30285	sqlite3_file fd, / Database holding shared memory */
30286	int deleteFlag /* Delete after closing if true */
30287	){
30288	winFile pDbFd; / Database holding shared-memory */
30289	winShm p; / The connection to be closed */
	@@ -30290,10 +30402,11 @@
30290	winShmNode pShmNode; / The underlying shared-memory file */
30291	winShm *pp; / For looping over sibling connections */
30292
30293	pDbFd = (winFile*)fd;
30294	p = pDbFd->pShm;

30295	pShmNode = p->pShmNode;
30296
30297	/* Remove connection p from the set of connections associated
30298	** with pShmNode */
30299	sqlite3_mutex_enter(pShmNode->mutex);
	@@ -30315,10 +30428,131 @@
30315	}
30316	winShmLeaveMutex();
30317
30318	return SQLITE_OK;
30319	}

























































































































30320
30321	/*
30322	** This function is called to obtain a pointer to region iRegion of the
30323	** shared-memory associated with the database file fd. Shared-memory regions
30324	** are numbered starting from zero. Each shared-memory region is szRegion
	@@ -30344,13 +30578,20 @@
30344	int isWrite, /* True to extend file if necessary */
30345	void volatile *pp / OUT: Mapped memory */
30346	){
30347	winFile pDbFd = (winFile)fd;
30348	winShm *p = pDbFd->pShm;
30349	winShmNode *pShmNode = p->pShmNode;
30350	int rc = SQLITE_OK;
30351







30352	sqlite3_mutex_enter(pShmNode->mutex);
30353	assert( szRegion==pShmNode->szRegion \|\| pShmNode->nRegion==0 );
30354
30355	if( pShmNode->nRegion<=iRegion ){
30356	struct ShmRegion apNew; / New aRegion[] array */
	@@ -30363,10 +30604,11 @@
30363	** Check to see if it has been allocated (i.e. if the wal-index file is
30364	** large enough to contain the requested region).
30365	*/
30366	rc = winFileSize((sqlite3_file *)&pShmNode->hFile, &sz);
30367	if( rc!=SQLITE_OK ){

30368	goto shmpage_out;
30369	}
30370
30371	if( sz<nByte ){
30372	/* The requested memory region does not exist. If isWrite is set to
	@@ -30376,10 +30618,11 @@
30376	** the requested memory region.
30377	*/
30378	if( !isWrite ) goto shmpage_out;
30379	rc = winTruncate((sqlite3_file *)&pShmNode->hFile, nByte);
30380	if( rc!=SQLITE_OK ){

30381	goto shmpage_out;
30382	}
30383	}
30384
30385	/* Map the requested memory region into this processes address space. */
	@@ -30426,102 +30669,53 @@
30426	}
30427	sqlite3_mutex_leave(pShmNode->mutex);
30428	return rc;
30429	}
30430
30431	/*
30432	** Change the lock state for a shared-memory segment.
30433	*/
30434	static int winShmLock(
30435	sqlite3_file fd, / Database file holding the shared memory */
30436	int ofst, /* First lock to acquire or release */
30437	int n, /* Number of locks to acquire or release */
30438	int flags /* What to do with the lock */
30439	){
30440	winFile pDbFd = (winFile)fd;
30441	winShm *p = pDbFd->pShm;
30442	winShmNode *pShmNode = p->pShmNode;
30443	int rc = SQLITE_PROTOCOL;
30444
30445	assert( ofst>=0 && ofst+n<=SQLITE_SHM_NLOCK );
30446	assert( n>=1 );
30447	assert( flags==(SQLITE_SHM_LOCK \| SQLITE_SHM_SHARED)
30448	\|\| flags==(SQLITE_SHM_LOCK \| SQLITE_SHM_EXCLUSIVE)
30449	\|\| flags==(SQLITE_SHM_UNLOCK \| SQLITE_SHM_SHARED)
30450	\|\| flags==(SQLITE_SHM_UNLOCK \| SQLITE_SHM_EXCLUSIVE) );
30451	assert( n==1 \|\| (flags & SQLITE_SHM_EXCLUSIVE)!=0 );
30452
30453	sqlite3_mutex_enter(pShmNode->mutex);
30454	if( flags & SQLITE_SHM_UNLOCK ){
30455	rc = winShmSystemLock(pShmNode, _SHM_UNLCK, ofst+WIN_SHM_BASE, n);
30456	}else if( flags & SQLITE_SHM_SHARED ){
30457	rc = winShmSystemLock(pShmNode, _SHM_RDLCK, ofst+WIN_SHM_BASE, n);
30458	}else{
30459	rc = winShmSystemLock(pShmNode, _SHM_WRLCK, ofst+WIN_SHM_BASE, n);
30460	}
30461	sqlite3_mutex_leave(pShmNode->mutex);
30462	OSTRACE(("SHM-LOCK shmid-%d, pid-%d %s\n",
30463	p->id, (int)GetCurrentProcessId(), rc ? "failed" : "ok"));
30464	return rc;
30465	}
30466
30467	/*
30468	** Implement a memory barrier or memory fence on shared memory.
30469	**
30470	** All loads and stores begun before the barrier must complete before
30471	** any load or store begun after the barrier.
30472	*/
30473	static void winShmBarrier(
30474	sqlite3_file fd / Database holding the shared memory */
30475	){
30476	UNUSED_PARAMETER(fd);
30477	/* MemoryBarrier(); // does not work -- do not know why not */
30478	winShmEnterMutex();
30479	winShmLeaveMutex();
30480	}
30481
30482	#else
30483	# define winShmOpen 0
30484	# define winShmMap 0
30485	# define winShmLock 0
30486	# define winShmBarrier 0
30487	# define winShmClose 0
30488	#endif /* #ifndef SQLITE_OMIT_WAL */

30489	/*
30490	*************************** End Shared Memory ***************************
30491	****************************************************************************/


30492
30493	/*
30494	** This vector defines all the methods that can operate on an
30495	** sqlite3_file for win32.
30496	*/
30497	static const sqlite3_io_methods winIoMethod = {
30498	2, /* iVersion */
30499	winClose,
30500	winRead,
30501	winWrite,
30502	winTruncate,
30503	winSync,
30504	winFileSize,
30505	winLock,
30506	winUnlock,
30507	winCheckReservedLock,
30508	winFileControl,
30509	winSectorSize,
30510	winDeviceCharacteristics,
30511	winShmOpen, /* xShmOpen */
30512	winShmLock, /* xShmLock */
30513	winShmMap, /* xShmMap */
30514	winShmBarrier, /* xShmBarrier */
30515	winShmClose /* xShmClose */
30516	};
30517
30518	/***************************************************************************
30519	** Here ends the I/O methods that form the sqlite3_io_methods object.
30520	**
30521	** The next block of code implements the VFS methods.
30522	****************************************************************************/

30523
30524	/*
30525	** Convert a UTF-8 filename into whatever form the underlying
30526	** operating system wants filenames in. Space to hold the result
30527	** is obtained from malloc and must be freed by the calling
	@@ -30788,10 +30982,11 @@
30788	}
30789	OSTRACE(("OPEN %d %s 0x%lx %s\n",
30790	h, zName, dwDesiredAccess,
30791	h==INVALID_HANDLE_VALUE ? "failed" : "ok"));
30792	if( h==INVALID_HANDLE_VALUE ){

30793	free(zConverted);
30794	if( flags & SQLITE_OPEN_READWRITE ){
30795	return winOpen(pVfs, zName, id,
30796	((flags\|SQLITE_OPEN_READONLY)&~SQLITE_OPEN_READWRITE), pOutFlags);
30797	}else{
	@@ -39553,16 +39748,15 @@
39553	\|\| eMode==PAGER_JOURNALMODE_PERSIST
39554	\|\| eMode==PAGER_JOURNALMODE_OFF
39555	\|\| eMode==PAGER_JOURNALMODE_WAL
39556	\|\| eMode==PAGER_JOURNALMODE_MEMORY );
39557
39558	/* Do not allow the journalmode of a TEMP database to be changed to WAL


39559	*/
39560	if( pPager->tempFile && eMode==PAGER_JOURNALMODE_WAL ){
39561	assert( eOld!=PAGER_JOURNALMODE_WAL );
39562	eMode = eOld;
39563	}
39564
39565	/* Do allow the journalmode of an in-memory database to be set to
39566	** anything other than MEMORY or OFF
39567	*/
39568	if( MEMDB ){
	@@ -39697,11 +39891,11 @@
39697	** Return true if the underlying VFS for the given pager supports the
39698	** primitives necessary for write-ahead logging.
39699	*/
39700	SQLITE_PRIVATE int sqlite3PagerWalSupported(Pager *pPager){
39701	const sqlite3_io_methods *pMethods = pPager->fd->pMethods;
39702	return pMethods->iVersion>=2 && pMethods->xShmOpen!=0;
39703	}
39704
39705	/*
39706	** The caller must be holding a SHARED lock on the database file to call
39707	** this function.
	@@ -40229,13 +40423,13 @@
40229	int nWiData; /* Size of array apWiData */
40230	volatile u32 *apWiData; / Pointer to wal-index content in memory */
40231	u16 szPage; /* Database page size */
40232	i16 readLock; /* Which read lock is being held. -1 for none */
40233	u8 exclusiveMode; /* Non-zero if connection is in exclusive mode */
40234	u8 isWIndexOpen; /* True if ShmOpen() called on pDbFd */
40235	u8 writeLock; /* True if in a write transaction */
40236	u8 ckptLock; /* True if holding a checkpoint lock */

40237	WalIndexHdr hdr; /* Wal-index header for current transaction */
40238	const char zWalName; / Name of WAL file */
40239	u32 nCkpt; /* Checkpoint sequence counter in the wal-header */
40240	#ifdef SQLITE_DEBUG
40241	u8 lockError; /* True if a locking error has occurred */
	@@ -40311,18 +40505,19 @@
40311	static int walIndexPage(Wal pWal, int iPage, volatile u32 *ppPage){
40312	int rc = SQLITE_OK;
40313
40314	/* Enlarge the pWal->apWiData[] array if required */
40315	if( pWal->nWiData<=iPage ){
40316	int nByte = sizeof(u32 )(iPage+1);
40317	volatile u32 **apNew;
40318	apNew = (volatile u32 *)sqlite3_realloc((void )pWal->apWiData, nByte);
40319	if( !apNew ){
40320	*ppPage = 0;
40321	return SQLITE_NOMEM;
40322	}
40323	memset((void )&apNew[pWal->nWiData], 0, sizeof(u32 )*(iPage+1-pWal->nWiData));

40324	pWal->apWiData = apNew;
40325	pWal->nWiData = iPage+1;
40326	}
40327
40328	/* Request a pointer to the required page from the VFS */
	@@ -40494,13 +40689,14 @@
40494	pgno = sqlite3Get4byte(&aFrame[0]);
40495	if( pgno==0 ){
40496	return 0;
40497	}
40498
40499	/* A frame is only valid if a checksum of the first 16 bytes
40500	** of the frame-header, and the frame-data matches
40501	** the checksum in the last 8 bytes of the frame-header.

40502	*/
40503	nativeCksum = (pWal->hdr.bigEndCksum==SQLITE_BIGENDIAN);
40504	walChecksumBytes(nativeCksum, aFrame, 8, aCksum, aCksum);
40505	walChecksumBytes(nativeCksum, aData, pWal->szPage, aCksum, aCksum);
40506	if( aCksum[0]!=sqlite3Get4byte(&aFrame[16])
	@@ -40756,11 +40952,11 @@
40756	** page number array and hash table entry.
40757	*/
40758	if( rc==SQLITE_OK ){
40759	int iKey; /* Hash table key */
40760	int idx; /* Value to write to hash-table slot */
40761	TESTONLY( int nCollide = 0; /* Number of hash collisions */ )
40762
40763	idx = iFrame - iZero;
40764	assert( idx <= HASHTABLE_NSLOT/2 + 1 );
40765
40766	/* If this is the first entry to be added to this hash-table, zero the
	@@ -40781,12 +40977,13 @@
40781	walCleanupHash(pWal);
40782	assert( !aPgno[idx] );
40783	}
40784
40785	/* Write the aPgno[] array entry and the hash-table slot. */

40786	for(iKey=walHash(iPage); aHash[iKey]; iKey=walNextHash(iKey)){
40787	assert( nCollide++ < idx );
40788	}
40789	aPgno[idx] = iPage;
40790	aHash[iKey] = (ht_slot)idx;
40791
40792	#ifdef SQLITE_ENABLE_EXPENSIVE_ASSERT
	@@ -40981,14 +41178,11 @@
40981
40982	/*
40983	** Close an open wal-index.
40984	*/
40985	static void walIndexClose(Wal *pWal, int isDelete){
40986	if( pWal->isWIndexOpen ){
40987	sqlite3OsShmClose(pWal->pDbFd, isDelete);
40988	pWal->isWIndexOpen = 0;
40989	}
40990	}
40991
40992	/*
40993	** Open a connection to the WAL file zWalName. The database file must
40994	** already be opened on connection pDbFd. The buffer that zWalName points
	@@ -41039,17 +41233,16 @@
41039	pRet->pVfs = pVfs;
41040	pRet->pWalFd = (sqlite3_file *)&pRet[1];
41041	pRet->pDbFd = pDbFd;
41042	pRet->readLock = -1;
41043	pRet->zWalName = zWalName;
41044	rc = sqlite3OsShmOpen(pDbFd);
41045
41046	/* Open file handle on the write-ahead log file. */
41047	if( rc==SQLITE_OK ){
41048	pRet->isWIndexOpen = 1;
41049	flags = (SQLITE_OPEN_READWRITE\|SQLITE_OPEN_CREATE\|SQLITE_OPEN_MAIN_JOURNAL);
41050	rc = sqlite3OsOpen(pVfs, zWalName, pRet->pWalFd, flags, &flags);
41051	}
41052
41053	if( rc!=SQLITE_OK ){
41054	walIndexClose(pRet, 0);
41055	sqlite3OsClose(pRet->pWalFd);
	@@ -41268,11 +41461,15 @@
41268	int j; /* Counter variable */
41269	int nEntry; /* Number of entries in this segment */
41270	ht_slot aIndex; / Sorted index for this segment */
41271
41272	aPgno++;
41273	nEntry = (int)(((i+1)==nSegment)?(int)(iLast-iZero):(u32 )aHash-(u32 )aPgno);




41274	aIndex = &((ht_slot *)&p->aSegment[p->nSegment])[iZero];
41275	iZero++;
41276
41277	for(j=0; j<nEntry; j++){
41278	aIndex[j] = (ht_slot)j;
	@@ -41680,12 +41877,20 @@
41680	** which might cause WAL_RETRY to be returned even if BUSY_RECOVERY
41681	** would be technically correct. But the race is benign since with
41682	** WAL_RETRY this routine will be called again and will probably be
41683	** right on the second iteration.
41684	*/
41685	rc = walLockShared(pWal, WAL_RECOVER_LOCK);
41686	if( rc==SQLITE_OK ){








41687	walUnlockShared(pWal, WAL_RECOVER_LOCK);
41688	rc = WAL_RETRY;
41689	}else if( rc==SQLITE_BUSY ){
41690	rc = SQLITE_BUSY_RECOVERY;
41691	}
	@@ -41905,22 +42110,27 @@
41905	for(iHash=walFramePage(iLast); iHash>=0 && iRead==0; iHash--){
41906	volatile ht_slot aHash; / Pointer to hash table */
41907	volatile u32 aPgno; / Pointer to array of page numbers */
41908	u32 iZero; /* Frame number corresponding to aPgno[0] */
41909	int iKey; /* Hash slot index */
41910	int rc;

41911
41912	rc = walHashGet(pWal, iHash, &aHash, &aPgno, &iZero);
41913	if( rc!=SQLITE_OK ){
41914	return rc;
41915	}

41916	for(iKey=walHash(pgno); aHash[iKey]; iKey=walNextHash(iKey)){
41917	u32 iFrame = aHash[iKey] + iZero;
41918	if( iFrame<=iLast && aPgno[aHash[iKey]]==pgno ){
41919	assert( iFrame>iRead );
41920	iRead = iFrame;
41921	}



41922	}
41923	}
41924
41925	#ifdef SQLITE_ENABLE_EXPENSIVE_ASSERT
41926	/* If expensive assert() statements are available, do a linear search
	@@ -41980,10 +42190,14 @@
41980	int rc;
41981
41982	/* Cannot start a write transaction without first holding a read
41983	** transaction. */
41984	assert( pWal->readLock>=0 );




41985
41986	/* Only one writer allowed at a time. Get the write lock. Return
41987	** SQLITE_BUSY if unable.
41988	*/
41989	rc = walLockExclusive(pWal, WAL_WRITE_LOCK, 1);
	@@ -42008,12 +42222,14 @@
42008	/*
42009	** End a write transaction. The commit has already been done. This
42010	** routine merely releases the lock.
42011	*/
42012	SQLITE_PRIVATE int sqlite3WalEndWriteTransaction(Wal *pWal){
42013	walUnlockExclusive(pWal, WAL_WRITE_LOCK, 1);
42014	pWal->writeLock = 0;


42015	return SQLITE_OK;
42016	}
42017
42018	/*
42019	** If any data has been written (but not committed) to the log file, this
	@@ -63636,15 +63852,15 @@
63636
63637	#ifndef SQLITE_OMIT_WAL
63638	u.cd.zFilename = sqlite3PagerFilename(u.cd.pPager);
63639
63640	/* Do not allow a transition to journal_mode=WAL for a database
63641	** in temporary storage or if the VFS does not support xShmOpen.
63642	*/
63643	if( u.cd.eNew==PAGER_JOURNALMODE_WAL
63644	&& (u.cd.zFilename[0]==0 /* Temp file */
63645	\|\| !sqlite3PagerWalSupported(u.cd.pPager)) /* No xShmOpen support */
63646	){
63647	u.cd.eNew = u.cd.eOld;
63648	}
63649
63650	if( (u.cd.eNew!=u.cd.eOld)
	@@ -64882,15 +65098,14 @@
64882	0, /* xUnlock */
64883	0, /* xCheckReservedLock */
64884	0, /* xFileControl */
64885	0, /* xSectorSize */
64886	0, /* xDeviceCharacteristics */
64887	0, /* xShmOpen */
64888	0, /* xShmLock */
64889	0, /* xShmMap */
64890	0, /* xShmBarrier */
64891	0 /* xShmClose */
64892	};
64893
64894	/*
64895	** Open a journal file.
64896	*/
	@@ -65167,15 +65382,14 @@
65167	0, /* xUnlock */
65168	0, /* xCheckReservedLock */
65169	0, /* xFileControl */
65170	0, /* xSectorSize */
65171	0, /* xDeviceCharacteristics */
65172	0, /* xShmOpen */
65173	0, /* xShmLock */
65174	0, /* xShmMap */
65175	0, /* xShmBarrier */
65176	0 /* xShmClose */
65177	};
65178
65179	/*
65180	** Open a journal file.
65181	*/
	@@ -68178,11 +68392,11 @@
68178	pEList = pExpr->x.pSelect->pEList;
68179	if( ALWAYS(pEList!=0 && pEList->nExpr>0) ){
68180	keyInfo.aColl[0] = sqlite3BinaryCompareCollSeq(pParse, pExpr->pLeft,
68181	pEList->a[0].pExpr);
68182	}
68183	}else if( pExpr->x.pList!=0 ){
68184	/* Case 2: expr IN (exprlist)
68185	**
68186	** For each expression, build an index key from the evaluation and
68187	** store it in the temporary table. If <expr> is a column, then use
68188	** that columns affinity when building index keys. If <expr> is not
	@@ -68248,11 +68462,10 @@
68248	** value of this select in a memory cell and record the number
68249	** of the memory cell in iColumn. If this is an EXISTS, write
68250	** an integer 0 (not exists) or 1 (exists) into a memory cell
68251	** and record that memory cell in iColumn.
68252	*/
68253	static const Token one = { "1", 1 }; /* Token for literal value 1 */
68254	Select pSel; / SELECT statement to encode */
68255	SelectDest dest; /* How to deal with SELECt result */
68256
68257	testcase( pExpr->op==TK_EXISTS );
68258	testcase( pExpr->op==TK_SELECT );
	@@ -68269,11 +68482,12 @@
68269	dest.eDest = SRT_Exists;
68270	sqlite3VdbeAddOp2(v, OP_Integer, 0, dest.iParm);
68271	VdbeComment((v, "Init EXISTS result"));
68272	}
68273	sqlite3ExprDelete(pParse->db, pSel->pLimit);
68274	pSel->pLimit = sqlite3PExpr(pParse, TK_INTEGER, 0, 0, &one);

68275	if( sqlite3Select(pParse, pSel, &dest) ){
68276	return 0;
68277	}
68278	rReg = dest.iParm;
68279	ExprSetIrreducible(pExpr);
	@@ -68337,12 +68551,24 @@
68337	/* Code the LHS, the <expr> from "<expr> IN (...)".
68338	*/
68339	sqlite3ExprCachePush(pParse);
68340	r1 = sqlite3GetTempReg(pParse);
68341	sqlite3ExprCode(pParse, pExpr->pLeft, r1);
68342	sqlite3VdbeAddOp2(v, OP_IsNull, r1, destIfNull);
68343













68344
68345	if( eType==IN_INDEX_ROWID ){
68346	/* In this case, the RHS is the ROWID of table b-tree
68347	*/
68348	sqlite3VdbeAddOp2(v, OP_MustBeInt, r1, destIfFalse);
	@@ -95669,11 +95895,11 @@
95669	Expr *pExpr = pTerm->pExpr;
95670	wsFlags \|= WHERE_COLUMN_IN;
95671	if( ExprHasProperty(pExpr, EP_xIsSelect) ){
95672	nInMul *= 25;
95673	bInEst = 1;
95674	}else if( pExpr->x.pList ){
95675	nInMul *= pExpr->x.pList->nExpr + 1;
95676	}
95677	}else if( pTerm->eOperator & WO_ISNULL ){
95678	wsFlags \|= WHERE_COLUMN_NULL;
95679	}
	@@ -97713,40 +97939,40 @@
97713	** YYNRULE the number of rules in the grammar
97714	** YYERRORSYMBOL is the code number of the error symbol. If not
97715	** defined, then do no error processing.
97716	*/
97717	#define YYCODETYPE unsigned char
97718	#define YYNOCODE 254
97719	#define YYACTIONTYPE unsigned short int
97720	#define YYWILDCARD 67
97721	#define sqlite3ParserTOKENTYPE Token
97722	typedef union {
97723	int yyinit;
97724	sqlite3ParserTOKENTYPE yy0;
97725	Select* yy3;
97726	ExprList* yy14;
97727	SrcList* yy65;
97728	struct LikeOp yy96;
97729	Expr* yy132;
97730	u8 yy186;
97731	int yy328;
97732	ExprSpan yy346;
97733	struct TrigEvent yy378;
97734	IdList* yy408;
97735	struct {int value; int mask;} yy429;
97736	TriggerStep* yy473;
97737	struct LimitVal yy476;
97738	} YYMINORTYPE;
97739	#ifndef YYSTACKDEPTH
97740	#define YYSTACKDEPTH 100
97741	#endif
97742	#define sqlite3ParserARG_SDECL Parse *pParse;
97743	#define sqlite3ParserARG_PDECL ,Parse *pParse
97744	#define sqlite3ParserARG_FETCH Parse *pParse = yypParser->pParse
97745	#define sqlite3ParserARG_STORE yypParser->pParse = pParse
97746	#define YYNSTATE 631
97747	#define YYNRULE 330
97748	#define YYFALLBACK 1
97749	#define YY_NO_ACTION (YYNSTATE+YYNRULE+2)
97750	#define YY_ACCEPT_ACTION (YYNSTATE+YYNRULE+1)
97751	#define YY_ERROR_ACTION (YYNSTATE+YYNRULE)
97752
	@@ -97812,476 +98038,477 @@
97812	** shifting terminals.
97813	** yy_reduce_ofst[] For each state, the offset into yy_action for
97814	** shifting non-terminals after a reduce.
97815	** yy_default[] Default action for each state.
97816	*/
97817	#define YY_ACTTAB_COUNT (1550)
97818	static const YYACTIONTYPE yy_action[] = {
97819	/* 0 */ 313, 49, 556, 46, 147, 172, 628, 598, 55, 55,
97820	/* 10 */ 55, 55, 302, 53, 53, 53, 53, 52, 52, 51,
97821	/* 20 */ 51, 51, 50, 238, 603, 66, 624, 623, 604, 598,
97822	/* 30 */ 591, 585, 48, 53, 53, 53, 53, 52, 52, 51,
97823	/* 40 */ 51, 51, 50, 238, 51, 51, 51, 50, 238, 56,
97824	/* 50 */ 57, 47, 583, 582, 584, 584, 54, 54, 55, 55,
97825	/* 60 */ 55, 55, 609, 53, 53, 53, 53, 52, 52, 51,
97826	/* 70 */ 51, 51, 50, 238, 313, 598, 672, 330, 411, 217,
97827	/* 80 */ 32, 53, 53, 53, 53, 52, 52, 51, 51, 51,
97828	/* 90 */ 50, 238, 330, 414, 621, 620, 166, 598, 673, 382,
97829	/* 100 */ 379, 378, 602, 73, 591, 585, 307, 424, 166, 58,
97830	/* 110 */ 377, 382, 379, 378, 516, 515, 624, 623, 254, 200,
97831	/* 120 */ 199, 198, 377, 56, 57, 47, 583, 582, 584, 584,
97832	/* 130 */ 54, 54, 55, 55, 55, 55, 581, 53, 53, 53,
97833	/* 140 */ 53, 52, 52, 51, 51, 51, 50, 238, 313, 270,
97834	/* 150 */ 226, 422, 283, 133, 177, 139, 284, 385, 279, 384,
97835	/* 160 */ 169, 197, 251, 282, 253, 226, 411, 275, 440, 167,
97836	/* 170 */ 139, 284, 385, 279, 384, 169, 571, 236, 591, 585,
97837	/* 180 */ 240, 414, 275, 622, 621, 620, 674, 437, 441, 442,
97838	/* 190 */ 602, 88, 352, 266, 439, 268, 438, 56, 57, 47,
97839	/* 200 */ 583, 582, 584, 584, 54, 54, 55, 55, 55, 55,
97840	/* 210 */ 465, 53, 53, 53, 53, 52, 52, 51, 51, 51,
97841	/* 220 */ 50, 238, 313, 471, 52, 52, 51, 51, 51, 50,
97842	/* 230 */ 238, 234, 166, 491, 567, 382, 379, 378, 1, 440,
97843	/* 240 */ 252, 176, 624, 623, 608, 67, 377, 513, 622, 443,
97844	/* 250 */ 237, 577, 591, 585, 622, 172, 466, 598, 554, 441,
97845	/* 260 */ 340, 409, 526, 580, 580, 349, 596, 553, 194, 482,
97846	/* 270 */ 175, 56, 57, 47, 583, 582, 584, 584, 54, 54,
97847	/* 280 */ 55, 55, 55, 55, 562, 53, 53, 53, 53, 52,
97848	/* 290 */ 52, 51, 51, 51, 50, 238, 313, 594, 594, 594,
97849	/* 300 */ 561, 578, 469, 65, 259, 351, 258, 411, 624, 623,
97850	/* 310 */ 621, 620, 332, 576, 575, 240, 560, 568, 520, 411,
97851	/* 320 */ 341, 237, 414, 624, 623, 598, 591, 585, 542, 519,
97852	/* 330 */ 171, 602, 95, 68, 414, 624, 623, 624, 623, 38,
97853	/* 340 */ 877, 506, 507, 602, 88, 56, 57, 47, 583, 582,
97854	/* 350 */ 584, 584, 54, 54, 55, 55, 55, 55, 532, 53,
97855	/* 360 */ 53, 53, 53, 52, 52, 51, 51, 51, 50, 238,
97856	/* 370 */ 313, 411, 579, 398, 531, 237, 621, 620, 388, 625,
97857	/* 380 */ 500, 206, 167, 396, 233, 312, 414, 387, 569, 492,
97858	/* 390 */ 216, 621, 620, 566, 622, 602, 74, 533, 210, 491,
97859	/* 400 */ 591, 585, 548, 621, 620, 621, 620, 300, 598, 466,
97860	/* 410 */ 481, 67, 603, 35, 622, 601, 604, 547, 6, 56,
97861	/* 420 */ 57, 47, 583, 582, 584, 584, 54, 54, 55, 55,
97862	/* 430 */ 55, 55, 601, 53, 53, 53, 53, 52, 52, 51,
97863	/* 440 */ 51, 51, 50, 238, 313, 411, 184, 409, 528, 580,
97864	/* 450 */ 580, 551, 962, 186, 419, 2, 353, 259, 351, 258,
97865	/* 460 */ 414, 409, 411, 580, 580, 44, 411, 544, 240, 602,
97866	/* 470 */ 94, 190, 7, 62, 591, 585, 598, 414, 350, 607,
97867	/* 480 */ 493, 414, 409, 317, 580, 580, 602, 95, 496, 565,
97868	/* 490 */ 602, 80, 203, 56, 57, 47, 583, 582, 584, 584,
97869	/* 500 */ 54, 54, 55, 55, 55, 55, 535, 53, 53, 53,
97870	/* 510 */ 53, 52, 52, 51, 51, 51, 50, 238, 313, 202,
97871	/* 520 */ 564, 293, 511, 49, 562, 46, 147, 411, 394, 183,
97872	/* 530 */ 563, 549, 505, 549, 174, 409, 322, 580, 580, 39,
97873	/* 540 */ 561, 37, 414, 624, 623, 192, 473, 383, 591, 585,
97874	/* 550 */ 474, 602, 80, 601, 504, 544, 560, 364, 402, 210,
97875	/* 560 */ 421, 952, 361, 952, 365, 201, 144, 56, 57, 47,
97876	/* 570 */ 583, 582, 584, 584, 54, 54, 55, 55, 55, 55,
97877	/* 580 */ 559, 53, 53, 53, 53, 52, 52, 51, 51, 51,
97878	/* 590 */ 50, 238, 313, 601, 232, 264, 272, 321, 374, 484,
97879	/* 600 */ 510, 146, 342, 146, 328, 425, 485, 407, 576, 575,
97880	/* 610 */ 622, 621, 620, 49, 168, 46, 147, 353, 546, 491,
97881	/* 620 */ 204, 240, 591, 585, 421, 951, 549, 951, 549, 168,
97882	/* 630 */ 429, 67, 390, 343, 622, 434, 307, 423, 338, 360,
97883	/* 640 */ 391, 56, 57, 47, 583, 582, 584, 584, 54, 54,
97884	/* 650 */ 55, 55, 55, 55, 601, 53, 53, 53, 53, 52,
97885	/* 660 */ 52, 51, 51, 51, 50, 238, 313, 34, 318, 425,
97886	/* 670 */ 237, 21, 359, 273, 411, 167, 411, 276, 411, 540,
97887	/* 680 */ 411, 422, 13, 318, 619, 618, 617, 622, 275, 414,
97888	/* 690 */ 336, 414, 622, 414, 622, 414, 591, 585, 602, 69,
97889	/* 700 */ 602, 97, 602, 100, 602, 98, 631, 629, 334, 475,
97890	/* 710 */ 475, 367, 319, 148, 327, 56, 57, 47, 583, 582,
97891	/* 720 */ 584, 584, 54, 54, 55, 55, 55, 55, 411, 53,
97892	/* 730 */ 53, 53, 53, 52, 52, 51, 51, 51, 50, 238,
97893	/* 740 */ 313, 411, 331, 414, 411, 49, 276, 46, 147, 569,
97894	/* 750 */ 406, 216, 602, 106, 573, 573, 414, 354, 524, 414,
97895	/* 760 */ 411, 622, 411, 224, 4, 602, 104, 605, 602, 108,
97896	/* 770 */ 591, 585, 622, 20, 375, 414, 167, 414, 215, 144,
97897	/* 780 */ 470, 239, 167, 225, 602, 109, 602, 134, 18, 56,
97898	/* 790 */ 57, 47, 583, 582, 584, 584, 54, 54, 55, 55,
97899	/* 800 */ 55, 55, 411, 53, 53, 53, 53, 52, 52, 51,
97900	/* 810 */ 51, 51, 50, 238, 313, 411, 276, 414, 12, 459,
97901	/* 820 */ 276, 171, 411, 16, 223, 189, 602, 135, 354, 170,
97902	/* 830 */ 414, 622, 630, 2, 411, 622, 540, 414, 143, 602,
97903	/* 840 */ 61, 359, 132, 622, 591, 585, 602, 105, 458, 414,
97904	/* 850 */ 23, 622, 446, 326, 23, 538, 622, 325, 602, 103,
97905	/* 860 */ 427, 530, 309, 56, 57, 47, 583, 582, 584, 584,
97906	/* 870 */ 54, 54, 55, 55, 55, 55, 411, 53, 53, 53,
97907	/* 880 */ 53, 52, 52, 51, 51, 51, 50, 238, 313, 411,
97908	/* 890 */ 264, 414, 411, 276, 359, 219, 157, 214, 357, 366,
97909	/* 900 */ 602, 96, 522, 521, 414, 622, 358, 414, 622, 622,
97910	/* 910 */ 411, 613, 612, 602, 102, 142, 602, 77, 591, 585,
97911	/* 920 */ 529, 540, 231, 426, 308, 414, 622, 622, 468, 521,
97912	/* 930 */ 324, 601, 257, 263, 602, 99, 622, 56, 45, 47,
97913	/* 940 */ 583, 582, 584, 584, 54, 54, 55, 55, 55, 55,
97914	/* 950 */ 411, 53, 53, 53, 53, 52, 52, 51, 51, 51,
97915	/* 960 */ 50, 238, 313, 264, 264, 414, 411, 213, 209, 544,
97916	/* 970 */ 544, 207, 611, 28, 602, 138, 50, 238, 622, 622,
97917	/* 980 */ 381, 414, 503, 140, 323, 222, 274, 622, 590, 589,
97918	/* 990 */ 602, 137, 591, 585, 629, 334, 606, 30, 622, 571,
97919	/* 1000 */ 236, 601, 601, 130, 496, 601, 453, 451, 288, 286,
97920	/* 1010 */ 587, 586, 57, 47, 583, 582, 584, 584, 54, 54,
97921	/* 1020 */ 55, 55, 55, 55, 411, 53, 53, 53, 53, 52,
97922	/* 1030 */ 52, 51, 51, 51, 50, 238, 313, 588, 411, 414,
97923	/* 1040 */ 411, 264, 410, 129, 595, 400, 27, 376, 602, 136,
97924	/* 1050 */ 128, 165, 479, 414, 282, 414, 622, 622, 411, 622,
97925	/* 1060 */ 622, 411, 602, 76, 602, 93, 591, 585, 188, 372,
97926	/* 1070 */ 368, 125, 476, 414, 261, 160, 414, 171, 124, 472,
97927	/* 1080 */ 123, 15, 602, 92, 450, 602, 75, 47, 583, 582,
97928	/* 1090 */ 584, 584, 54, 54, 55, 55, 55, 55, 464, 53,
97929	/* 1100 */ 53, 53, 53, 52, 52, 51, 51, 51, 50, 238,
97930	/* 1110 */ 43, 405, 264, 3, 558, 264, 545, 415, 623, 159,
97931	/* 1120 */ 541, 158, 539, 278, 25, 461, 121, 622, 408, 622,
97932	/* 1130 */ 622, 622, 24, 43, 405, 622, 3, 622, 622, 120,
97933	/* 1140 */ 415, 623, 11, 456, 411, 156, 452, 403, 509, 277,
97934	/* 1150 */ 118, 408, 489, 113, 205, 449, 271, 567, 221, 414,
97935	/* 1160 */ 269, 267, 155, 622, 622, 111, 411, 622, 602, 95,
97936	/* 1170 */ 403, 622, 411, 110, 10, 622, 622, 40, 41, 534,
97937	/* 1180 */ 567, 414, 64, 264, 42, 413, 412, 414, 601, 596,
97938	/* 1190 */ 602, 91, 445, 436, 150, 435, 602, 90, 622, 265,
97939	/* 1200 */ 40, 41, 337, 242, 411, 191, 333, 42, 413, 412,
97940	/* 1210 */ 398, 420, 596, 316, 622, 399, 260, 107, 230, 414,
97941	/* 1220 */ 594, 594, 594, 593, 592, 14, 220, 411, 602, 101,
97942	/* 1230 */ 240, 622, 43, 405, 362, 3, 149, 315, 626, 415,
97943	/* 1240 */ 623, 127, 414, 594, 594, 594, 593, 592, 14, 622,
97944	/* 1250 */ 408, 602, 89, 411, 181, 33, 405, 463, 3, 411,
97945	/* 1260 */ 264, 462, 415, 623, 616, 615, 614, 355, 414, 403,
97946	/* 1270 */ 417, 416, 622, 408, 414, 622, 622, 602, 87, 567,
97947	/* 1280 */ 418, 627, 622, 602, 86, 8, 241, 180, 126, 255,
97948	/* 1290 */ 600, 178, 403, 240, 208, 455, 395, 294, 444, 40,
97949	/* 1300 */ 41, 297, 567, 248, 622, 296, 42, 413, 412, 247,
97950	/* 1310 */ 622, 596, 244, 622, 30, 60, 31, 243, 430, 624,
97951	/* 1320 */ 623, 292, 40, 41, 622, 295, 145, 622, 601, 42,
97952	/* 1330 */ 413, 412, 622, 622, 596, 393, 622, 397, 599, 59,
97953	/* 1340 */ 235, 622, 594, 594, 594, 593, 592, 14, 218, 291,
97954	/* 1350 */ 622, 36, 344, 305, 304, 303, 179, 301, 411, 567,
97955	/* 1360 */ 454, 557, 173, 185, 622, 594, 594, 594, 593, 592,
97956	/* 1370 */ 14, 411, 29, 414, 151, 289, 246, 523, 411, 196,
97957	/* 1380 */ 195, 335, 602, 85, 411, 245, 414, 526, 392, 543,
97958	/* 1390 */ 411, 596, 287, 414, 285, 602, 72, 537, 153, 414,
97959	/* 1400 */ 466, 411, 602, 71, 154, 414, 411, 152, 602, 84,
97960	/* 1410 */ 386, 536, 329, 411, 602, 83, 414, 518, 280, 411,
97961	/* 1420 */ 513, 414, 594, 594, 594, 602, 82, 517, 414, 311,
97962	/* 1430 */ 602, 81, 411, 514, 414, 512, 131, 602, 70, 229,
97963	/* 1440 */ 228, 227, 494, 602, 17, 411, 488, 414, 259, 346,
97964	/* 1450 */ 249, 389, 487, 486, 314, 164, 602, 79, 310, 240,
97965	/* 1460 */ 414, 373, 480, 163, 262, 371, 414, 162, 369, 602,
97966	/* 1470 */ 78, 212, 478, 26, 477, 602, 9, 161, 467, 363,
97967	/* 1480 */ 141, 122, 339, 187, 119, 457, 348, 347, 117, 116,
97968	/* 1490 */ 115, 112, 114, 448, 182, 22, 320, 433, 432, 431,
97969	/* 1500 */ 19, 428, 610, 597, 574, 193, 572, 63, 298, 404,
97970	/* 1510 */ 555, 552, 290, 281, 510, 460, 498, 499, 495, 447,
97971	/* 1520 */ 356, 497, 256, 380, 306, 570, 5, 250, 345, 238,
97972	/* 1530 */ 299, 550, 527, 490, 508, 525, 502, 401, 501, 963,
97973	/* 1540 */ 211, 963, 483, 963, 963, 963, 963, 963, 963, 370,

97974	};
97975	static const YYCODETYPE yy_lookahead[] = {
97976	/* 0 */ 19, 222, 223, 224, 225, 24, 1, 26, 77, 78,
97977	/* 10 */ 79, 80, 15, 82, 83, 84, 85, 86, 87, 88,
97978	/* 20 */ 89, 90, 91, 92, 113, 22, 26, 27, 117, 26,
97979	/* 30 */ 49, 50, 81, 82, 83, 84, 85, 86, 87, 88,
97980	/* 40 */ 89, 90, 91, 92, 88, 89, 90, 91, 92, 68,
97981	/* 50 */ 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
97982	/* 60 */ 79, 80, 23, 82, 83, 84, 85, 86, 87, 88,
97983	/* 70 */ 89, 90, 91, 92, 19, 94, 118, 19, 150, 22,
97984	/* 80 */ 25, 82, 83, 84, 85, 86, 87, 88, 89, 90,
97985	/* 90 */ 91, 92, 19, 165, 94, 95, 96, 94, 118, 99,
97986	/* 100 */ 100, 101, 174, 175, 49, 50, 22, 23, 96, 54,
97987	/* 110 */ 110, 99, 100, 101, 7, 8, 26, 27, 16, 105,
97988	/* 120 */ 106, 107, 110, 68, 69, 70, 71, 72, 73, 74,
97989	/* 130 */ 75, 76, 77, 78, 79, 80, 113, 82, 83, 84,
97990	/* 140 */ 85, 86, 87, 88, 89, 90, 91, 92, 19, 16,
97991	/* 150 */ 92, 67, 98, 24, 96, 97, 98, 99, 100, 101,
97992	/* 160 */ 102, 25, 60, 109, 62, 92, 150, 109, 150, 25,
97993	/* 170 */ 97, 98, 99, 100, 101, 102, 86, 87, 49, 50,
97994	/* 180 */ 116, 165, 109, 165, 94, 95, 118, 97, 170, 171,
97995	/* 190 */ 174, 175, 128, 60, 104, 62, 106, 68, 69, 70,
97996	/* 200 */ 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
97997	/* 210 */ 11, 82, 83, 84, 85, 86, 87, 88, 89, 90,
97998	/* 220 */ 91, 92, 19, 21, 86, 87, 88, 89, 90, 91,
97999	/* 230 */ 92, 215, 96, 150, 66, 99, 100, 101, 22, 150,
98000	/* 240 */ 138, 118, 26, 27, 161, 162, 110, 103, 165, 231,
98001	/* 250 */ 232, 23, 49, 50, 165, 24, 57, 26, 32, 170,
98002	/* 260 */ 171, 112, 94, 114, 115, 63, 98, 41, 185, 186,
98003	/* 270 */ 118, 68, 69, 70, 71, 72, 73, 74, 75, 76,
98004	/* 280 */ 77, 78, 79, 80, 12, 82, 83, 84, 85, 86,
98005	/* 290 */ 87, 88, 89, 90, 91, 92, 19, 129, 130, 131,
98006	/* 300 */ 28, 23, 100, 25, 105, 106, 107, 150, 26, 27,
98007	/* 310 */ 94, 95, 169, 170, 171, 116, 44, 23, 46, 150,
98008	/* 320 */ 231, 232, 165, 26, 27, 94, 49, 50, 23, 57,
98009	/* 330 */ 25, 174, 175, 22, 165, 26, 27, 26, 27, 136,
98010	/* 340 */ 138, 97, 98, 174, 175, 68, 69, 70, 71, 72,
98011	/* 350 */ 73, 74, 75, 76, 77, 78, 79, 80, 23, 82,
98012	/* 360 */ 83, 84, 85, 86, 87, 88, 89, 90, 91, 92,
98013	/* 370 */ 19, 150, 23, 216, 23, 232, 94, 95, 221, 150,
98014	/* 380 */ 23, 160, 25, 214, 215, 163, 165, 88, 166, 167,
98015	/* 390 */ 168, 94, 95, 23, 165, 174, 175, 88, 160, 150,
98016	/* 400 */ 49, 50, 120, 94, 95, 94, 95, 158, 26, 57,
98017	/* 410 */ 161, 162, 113, 136, 165, 194, 117, 120, 22, 68,
98018	/* 420 */ 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
98019	/* 430 */ 79, 80, 194, 82, 83, 84, 85, 86, 87, 88,
98020	/* 440 */ 89, 90, 91, 92, 19, 150, 23, 112, 23, 114,
98021	/* 450 */ 115, 25, 142, 143, 144, 145, 218, 105, 106, 107,
98022	/* 460 */ 165, 112, 150, 114, 115, 22, 150, 166, 116, 174,
98023	/* 470 */ 175, 22, 76, 235, 49, 50, 94, 165, 240, 172,
98024	/* 480 */ 173, 165, 112, 155, 114, 115, 174, 175, 181, 11,
98025	/* 490 */ 174, 175, 22, 68, 69, 70, 71, 72, 73, 74,
98026	/* 500 */ 75, 76, 77, 78, 79, 80, 205, 82, 83, 84,
98027	/* 510 */ 85, 86, 87, 88, 89, 90, 91, 92, 19, 160,
98028	/* 520 */ 23, 226, 23, 222, 12, 224, 225, 150, 216, 23,
98029	/* 530 */ 23, 25, 36, 25, 25, 112, 220, 114, 115, 135,
98030	/* 540 */ 28, 137, 165, 26, 27, 119, 30, 51, 49, 50,
98031	/* 550 */ 34, 174, 175, 194, 58, 166, 44, 229, 46, 160,
98032	/* 560 */ 22, 23, 234, 25, 48, 206, 207, 68, 69, 70,
98033	/* 570 */ 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
98034	/* 580 */ 23, 82, 83, 84, 85, 86, 87, 88, 89, 90,
98035	/* 590 */ 91, 92, 19, 194, 205, 150, 23, 220, 19, 181,
98036	/* 600 */ 182, 95, 97, 95, 108, 67, 188, 169, 170, 171,
98037	/* 610 */ 165, 94, 95, 222, 50, 224, 225, 218, 120, 150,
98038	/* 620 */ 160, 116, 49, 50, 22, 23, 120, 25, 120, 50,
98039	/* 630 */ 161, 162, 19, 128, 165, 244, 22, 23, 193, 240,
98040	/* 640 */ 27, 68, 69, 70, 71, 72, 73, 74, 75, 76,
98041	/* 650 */ 77, 78, 79, 80, 194, 82, 83, 84, 85, 86,
98042	/* 660 */ 87, 88, 89, 90, 91, 92, 19, 25, 104, 67,
98043	/* 670 */ 232, 24, 150, 23, 150, 25, 150, 150, 150, 150,
98044	/* 680 */ 150, 67, 25, 104, 7, 8, 9, 165, 109, 165,
98045	/* 690 */ 245, 165, 165, 165, 165, 165, 49, 50, 174, 175,
98046	/* 700 */ 174, 175, 174, 175, 174, 175, 0, 1, 2, 105,
98047	/* 710 */ 106, 107, 248, 249, 187, 68, 69, 70, 71, 72,
98048	/* 720 */ 73, 74, 75, 76, 77, 78, 79, 80, 150, 82,
98049	/* 730 */ 83, 84, 85, 86, 87, 88, 89, 90, 91, 92,
98050	/* 740 */ 19, 150, 213, 165, 150, 222, 150, 224, 225, 166,
98051	/* 750 */ 167, 168, 174, 175, 129, 130, 165, 150, 165, 165,
98052	/* 760 */ 150, 165, 150, 241, 35, 174, 175, 174, 174, 175,
98053	/* 770 */ 49, 50, 165, 52, 23, 165, 25, 165, 206, 207,
98054	/* 780 */ 23, 197, 25, 187, 174, 175, 174, 175, 204, 68,
98055	/* 790 */ 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
98056	/* 800 */ 79, 80, 150, 82, 83, 84, 85, 86, 87, 88,
98057	/* 810 */ 89, 90, 91, 92, 19, 150, 150, 165, 35, 23,
98058	/* 820 */ 150, 25, 150, 22, 217, 24, 174, 175, 150, 35,
98059	/* 830 */ 165, 165, 144, 145, 150, 165, 150, 165, 118, 174,
98060	/* 840 */ 175, 150, 22, 165, 49, 50, 174, 175, 23, 165,
98061	/* 850 */ 25, 165, 23, 187, 25, 27, 165, 187, 174, 175,
98062	/* 860 */ 23, 23, 25, 68, 69, 70, 71, 72, 73, 74,
98063	/* 870 */ 75, 76, 77, 78, 79, 80, 150, 82, 83, 84,
98064	/* 880 */ 85, 86, 87, 88, 89, 90, 91, 92, 19, 150,
98065	/* 890 */ 150, 165, 150, 150, 150, 217, 25, 160, 19, 213,
98066	/* 900 */ 174, 175, 190, 191, 165, 165, 27, 165, 165, 165,
98067	/* 910 */ 150, 150, 150, 174, 175, 39, 174, 175, 49, 50,
98068	/* 920 */ 23, 150, 52, 250, 251, 165, 165, 165, 190, 191,
98069	/* 930 */ 187, 194, 241, 193, 174, 175, 165, 68, 69, 70,
98070	/* 940 */ 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
98071	/* 950 */ 150, 82, 83, 84, 85, 86, 87, 88, 89, 90,
98072	/* 960 */ 91, 92, 19, 150, 150, 165, 150, 160, 160, 166,
98073	/* 970 */ 166, 160, 150, 22, 174, 175, 91, 92, 165, 165,
98074	/* 980 */ 52, 165, 29, 150, 213, 241, 23, 165, 49, 50,
98075	/* 990 */ 174, 175, 49, 50, 1, 2, 173, 126, 165, 86,
98076	/* 1000 */ 87, 194, 194, 22, 181, 194, 193, 193, 205, 205,
98077	/* 1010 */ 71, 72, 69, 70, 71, 72, 73, 74, 75, 76,
98078	/* 1020 */ 77, 78, 79, 80, 150, 82, 83, 84, 85, 86,
98079	/* 1030 */ 87, 88, 89, 90, 91, 92, 19, 98, 150, 165,
98080	/* 1040 */ 150, 150, 150, 22, 150, 150, 22, 52, 174, 175,
98081	/* 1050 */ 22, 102, 20, 165, 109, 165, 165, 165, 150, 165,
98082	/* 1060 */ 165, 150, 174, 175, 174, 175, 49, 50, 24, 19,
98083	/* 1070 */ 43, 104, 59, 165, 138, 104, 165, 25, 53, 53,
98084	/* 1080 */ 22, 5, 174, 175, 193, 174, 175, 70, 71, 72,
98085	/* 1090 */ 73, 74, 75, 76, 77, 78, 79, 80, 1, 82,
98086	/* 1100 */ 83, 84, 85, 86, 87, 88, 89, 90, 91, 92,
98087	/* 1110 */ 19, 20, 150, 22, 150, 150, 150, 26, 27, 118,
98088	/* 1120 */ 150, 35, 150, 150, 76, 27, 108, 165, 37, 165,
98089	/* 1130 */ 165, 165, 76, 19, 20, 165, 22, 165, 165, 127,
98090	/* 1140 */ 26, 27, 22, 1, 150, 16, 20, 56, 150, 150,
98091	/* 1150 */ 119, 37, 150, 119, 160, 193, 150, 66, 193, 165,
98092	/* 1160 */ 150, 150, 121, 165, 165, 108, 150, 165, 174, 175,
98093	/* 1170 */ 56, 165, 150, 127, 22, 165, 165, 86, 87, 88,
98094	/* 1180 */ 66, 165, 16, 150, 93, 94, 95, 165, 194, 98,
98095	/* 1190 */ 174, 175, 128, 23, 15, 23, 174, 175, 165, 150,
98096	/* 1200 */ 86, 87, 65, 140, 150, 22, 3, 93, 94, 95,
98097	/* 1210 */ 216, 4, 98, 252, 165, 221, 150, 164, 180, 165,
98098	/* 1220 */ 129, 130, 131, 132, 133, 134, 193, 150, 174, 175,
98099	/* 1230 */ 116, 165, 19, 20, 150, 22, 249, 252, 149, 26,
98100	/* 1240 */ 27, 180, 165, 129, 130, 131, 132, 133, 134, 165,
98101	/* 1250 */ 37, 174, 175, 150, 6, 19, 20, 150, 22, 150,
98102	/* 1260 */ 150, 150, 26, 27, 149, 149, 13, 150, 165, 56,
98103	/* 1270 */ 149, 159, 165, 37, 165, 165, 165, 174, 175, 66,
98104	/* 1280 */ 146, 147, 165, 174, 175, 25, 152, 151, 154, 150,
98105	/* 1290 */ 194, 151, 56, 116, 160, 150, 123, 202, 150, 86,
98106	/* 1300 */ 87, 199, 66, 193, 165, 200, 93, 94, 95, 150,
98107	/* 1310 */ 165, 98, 150, 165, 126, 22, 124, 150, 150, 26,
98108	/* 1320 */ 27, 150, 86, 87, 165, 201, 150, 165, 194, 93,
98109	/* 1330 */ 94, 95, 165, 165, 98, 150, 165, 122, 203, 125,
98110	/* 1340 */ 227, 165, 129, 130, 131, 132, 133, 134, 5, 150,
98111	/* 1350 */ 165, 135, 218, 10, 11, 12, 13, 14, 150, 66,
98112	/* 1360 */ 17, 157, 118, 157, 165, 129, 130, 131, 132, 133,
98113	/* 1370 */ 134, 150, 104, 165, 31, 210, 33, 176, 150, 86,
98114	/* 1380 */ 87, 247, 174, 175, 150, 42, 165, 94, 121, 211,
98115	/* 1390 */ 150, 98, 210, 165, 210, 174, 175, 211, 55, 165,
98116	/* 1400 */ 57, 150, 174, 175, 61, 165, 150, 64, 174, 175,
98117	/* 1410 */ 104, 211, 47, 150, 174, 175, 165, 176, 176, 150,
98118	/* 1420 */ 103, 165, 129, 130, 131, 174, 175, 184, 165, 179,
98119	/* 1430 */ 174, 175, 150, 178, 165, 176, 22, 174, 175, 230,
98120	/* 1440 */ 92, 230, 184, 174, 175, 150, 176, 165, 105, 106,
98121	/* 1450 */ 107, 150, 176, 176, 111, 156, 174, 175, 179, 116,
98122	/* 1460 */ 165, 18, 157, 156, 238, 157, 165, 156, 45, 174,
98123	/* 1470 */ 175, 157, 157, 135, 239, 174, 175, 156, 189, 157,
98124	/* 1480 */ 68, 189, 139, 219, 22, 199, 157, 18, 192, 192,
98125	/* 1490 */ 192, 189, 192, 199, 219, 243, 157, 40, 157, 157,
98126	/* 1500 */ 243, 38, 153, 166, 233, 196, 233, 246, 198, 228,
98127	/* 1510 */ 177, 177, 209, 177, 182, 199, 166, 177, 166, 199,
98128	/* 1520 */ 242, 177, 242, 178, 148, 166, 196, 209, 209, 92,
98129	/* 1530 */ 195, 208, 174, 186, 183, 174, 183, 191, 183, 253,
98130	/* 1540 */ 236, 253, 186, 253, 253, 253, 253, 253, 253, 237,

98131	};
98132	#define YY_SHIFT_USE_DFLT (-90)
98133	#define YY_SHIFT_COUNT (418)
98134	#define YY_SHIFT_MIN (-89)
98135	#define YY_SHIFT_MAX (1469)
98136	static const short yy_shift_ofst[] = {
98137	/* 0 */ 993, 1114, 1343, 1114, 1213, 1213, 90, 90, 0, -19,
98138	/* 10 */ 1213, 1213, 1213, 1213, 1213, 352, 517, 721, 1091, 1213,
98139	/* 20 */ 1213, 1213, 1213, 1213, 1213, 1213, 1213, 1213, 1213, 1213,
98140	/* 30 */ 1213, 1213, 1213, 1213, 1213, 1213, 1213, 1213, 1213, 1213,
98141	/* 40 */ 1213, 1213, 1213, 1213, 1213, 1213, 1213, 1236, 1213, 1213,
98142	/* 50 */ 1213, 1213, 1213, 1213, 1213, 1213, 1213, 1213, 1213, 1213,
98143	/* 60 */ 1213, -49, 199, 517, 517, 913, 913, 382, 1177, 55,
98144	/* 70 */ 647, 573, 499, 425, 351, 277, 203, 129, 795, 795,
98145	/* 80 */ 795, 795, 795, 795, 795, 795, 795, 795, 795, 795,
98146	/* 90 */ 795, 795, 795, 795, 795, 795, 869, 795, 943, 1017,
98147	/* 100 */ 1017, -69, -69, -69, -69, -1, -1, 58, 138, -44,
98148	/* 110 */ 517, 517, 517, 517, 517, 517, 517, 517, 517, 517,
98149	/* 120 */ 517, 517, 517, 517, 517, 517, 202, 579, 517, 517,
98150	/* 130 */ 517, 517, 517, 382, 885, 1437, -90, -90, -90, 1293,
98151	/* 140 */ 73, 272, 272, 309, 311, 297, 282, 216, 602, 538,
98152	/* 150 */ 517, 517, 517, 517, 517, 517, 517, 517, 517, 517,
98153	/* 160 */ 517, 517, 517, 517, 517, 517, 517, 517, 517, 517,
98154	/* 170 */ 517, 517, 517, 517, 517, 517, 517, 517, 517, 517,
98155	/* 180 */ 517, 517, 505, 231, 231, 231, 706, 64, 1177, 1177,
98156	/* 190 */ 1177, -90, -90, -90, 136, 168, 168, 12, 496, 496,
98157	/* 200 */ 496, 506, 423, 512, 370, 349, 335, 149, 149, 149,
98158	/* 210 */ 149, 604, 516, 149, 149, 508, 3, 299, 677, 871,
98159	/* 220 */ 613, 613, 879, 871, 879, 144, 382, 226, 382, 226,
98160	/* 230 */ 564, 226, 613, 226, 226, 404, 625, 625, 382, 426,
98161	/* 240 */ -89, 801, 1463, 1244, 1244, 1457, 1457, 1244, 1462, 1412,
98162	/* 250 */ 1188, 1469, 1469, 1469, 1469, 1244, 1188, 1462, 1412, 1412,
98163	/* 260 */ 1244, 1443, 1338, 1423, 1244, 1244, 1443, 1244, 1443, 1244,
98164	/* 270 */ 1443, 1414, 1306, 1306, 1306, 1365, 1348, 1348, 1414, 1306,
98165	/* 280 */ 1317, 1306, 1365, 1306, 1306, 1267, 1268, 1267, 1268, 1267,
98166	/* 290 */ 1268, 1244, 1244, 1216, 1214, 1215, 1192, 1173, 1188, 1177,
98167	/* 300 */ 1260, 1253, 1253, 1248, 1248, 1248, 1248, -90, -90, -90,
98168	/* 310 */ -90, -90, -90, 939, 102, 614, 84, 133, 14, 837,
98169	/* 320 */ 396, 829, 825, 796, 757, 751, 650, 357, 244, 107,
98170	/* 330 */ 54, 305, 278, 1207, 1203, 1183, 1063, 1179, 1137, 1166,
98171	/* 340 */ 1172, 1170, 1064, 1152, 1046, 1057, 1034, 1126, 1041, 1129,
98172	/* 350 */ 1142, 1031, 1120, 1012, 1056, 1048, 1018, 1098, 1086, 1001,
98173	/* 360 */ 1097, 1076, 1058, 971, 936, 1026, 1052, 1025, 1013, 1027,
98174	/* 370 */ 967, 1044, 1032, 1050, 945, 949, 1028, 995, 1024, 1021,
98175	/* 380 */ 963, 981, 928, 953, 951, 870, 876, 897, 838, 720,
98176	/* 390 */ 828, 794, 820, 498, 642, 783, 657, 729, 642, 557,
98177	/* 400 */ 507, 509, 497, 470, 478, 449, 294, 228, 443, 23,
98178	/* 410 */ 152, 123, 68, -20, -42, 57, 39, -3, 5,
98179	};
98180	#define YY_REDUCE_USE_DFLT (-222)
98181	#define YY_REDUCE_COUNT (312)
98182	#define YY_REDUCE_MIN (-221)
98183	#define YY_REDUCE_MAX (1376)
98184	static const short yy_reduce_ofst[] = {
98185	/* 0 */ 310, 994, 1134, 221, 169, 157, 89, 18, 83, 301,
98186	/* 10 */ 377, 316, 312, 16, 295, 238, 249, 391, 1301, 1295,
98187	/* 20 */ 1282, 1269, 1263, 1256, 1251, 1240, 1234, 1228, 1221, 1208,
98188	/* 30 */ 1109, 1103, 1077, 1054, 1022, 1016, 911, 908, 890, 888,
98189	/* 40 */ 874, 816, 800, 760, 742, 739, 726, 684, 672, 665,
98190	/* 50 */ 652, 612, 610, 594, 591, 578, 530, 528, 526, 524,
98191	/* 60 */ -72, -221, 399, 469, 445, 438, 143, 222, 359, 523,
98192	/* 70 */ 523, 523, 523, 523, 523, 523, 523, 523, 523, 523,
98193	/* 80 */ 523, 523, 523, 523, 523, 523, 523, 523, 523, 523,
98194	/* 90 */ 523, 523, 523, 523, 523, 523, 523, 523, 523, 523,
98195	/* 100 */ 523, 523, 523, 523, 523, 523, 523, 307, 523, 523,
98196	/* 110 */ 1110, 678, 1033, 965, 962, 891, 814, 813, 744, 771,
98197	/* 120 */ 691, 607, 522, 743, 686, 740, 328, 418, 670, 666,
98198	/* 130 */ 596, 527, 529, 583, 523, 523, 523, 523, 523, 593,
98199	/* 140 */ 823, 738, 712, 892, 1199, 1185, 1176, 1171, 673, 673,
98200	/* 150 */ 1168, 1167, 1162, 1159, 1148, 1145, 1139, 1117, 1111, 1107,
98201	/* 160 */ 1084, 1066, 1049, 1011, 1010, 1006, 1002, 999, 998, 973,
98202	/* 170 */ 972, 970, 966, 964, 895, 894, 892, 833, 822, 762,
98203	/* 180 */ 761, 229, 811, 804, 803, 389, 688, 808, 807, 737,
98204	/* 190 */ 460, 464, 572, 584, 1356, 1361, 1358, 1347, 1355, 1353,
98205	/* 200 */ 1351, 1323, 1335, 1346, 1335, 1335, 1335, 1335, 1335, 1335,
98206	/* 210 */ 1335, 1312, 1304, 1335, 1335, 1323, 1359, 1330, 1376, 1320,
98207	/* 220 */ 1319, 1318, 1280, 1316, 1278, 1345, 1352, 1344, 1350, 1340,
98208	/* 230 */ 1332, 1336, 1303, 1334, 1333, 1281, 1273, 1271, 1337, 1310,
98209	/* 240 */ 1309, 1349, 1261, 1342, 1341, 1257, 1252, 1339, 1275, 1302,
98210	/* 250 */ 1294, 1300, 1298, 1297, 1296, 1329, 1286, 1264, 1292, 1289,
98211	/* 260 */ 1322, 1321, 1235, 1226, 1315, 1314, 1311, 1308, 1307, 1305,
98212	/* 270 */ 1299, 1279, 1277, 1276, 1270, 1258, 1211, 1209, 1250, 1259,
98213	/* 280 */ 1255, 1242, 1243, 1241, 1201, 1200, 1184, 1186, 1182, 1178,
98214	/* 290 */ 1165, 1206, 1204, 1113, 1135, 1095, 1124, 1105, 1102, 1096,
98215	/* 300 */ 1112, 1140, 1136, 1121, 1116, 1115, 1089, 985, 961, 987,
98216	/* 310 */ 1061, 1038, 1053,
98217	};
98218	static const YYACTIONTYPE yy_default[] = {
98219	/* 0 */ 636, 872, 961, 961, 961, 872, 901, 901, 961, 760,
98220	/* 10 */ 961, 961, 961, 961, 870, 961, 961, 935, 961, 961,
98221	/* 20 */ 961, 961, 961, 961, 961, 961, 961, 961, 961, 961,
98222	/* 30 */ 961, 961, 961, 961, 961, 961, 961, 961, 961, 961,
98223	/* 40 */ 961, 961, 961, 961, 961, 961, 961, 961, 961, 961,
98224	/* 50 */ 961, 961, 961, 961, 961, 961, 961, 961, 961, 961,
98225	/* 60 */ 961, 844, 961, 961, 961, 901, 901, 675, 764, 795,
98226	/* 70 */ 961, 961, 961, 961, 961, 961, 961, 961, 934, 936,
98227	/* 80 */ 810, 809, 803, 802, 914, 775, 800, 793, 786, 797,
98228	/* 90 */ 873, 866, 867, 865, 869, 874, 961, 796, 832, 850,
98229	/* 100 */ 831, 849, 856, 848, 834, 843, 833, 667, 835, 836,
98230	/* 110 */ 961, 961, 961, 961, 961, 961, 961, 961, 961, 961,
98231	/* 120 */ 961, 961, 961, 961, 961, 961, 662, 729, 961, 961,
98232	/* 130 */ 961, 961, 961, 961, 837, 838, 853, 852, 851, 961,
98233	/* 140 */ 961, 961, 961, 961, 961, 961, 961, 961, 961, 961,
98234	/* 150 */ 961, 941, 939, 961, 885, 961, 961, 961, 961, 961,
98235	/* 160 */ 961, 961, 961, 961, 961, 961, 961, 961, 961, 961,
98236	/* 170 */ 961, 961, 961, 961, 961, 961, 961, 961, 961, 961,
98237	/* 180 */ 961, 642, 961, 760, 760, 760, 636, 961, 961, 961,
98238	/* 190 */ 961, 953, 764, 754, 720, 961, 961, 961, 961, 961,
98239	/* 200 */ 961, 961, 961, 961, 961, 961, 961, 805, 743, 924,
98240	/* 210 */ 926, 961, 907, 741, 664, 762, 677, 752, 644, 799,
98241	/* 220 */ 777, 777, 919, 799, 919, 701, 961, 789, 961, 789,
98242	/* 230 */ 698, 789, 777, 789, 789, 868, 961, 961, 961, 761,
98243	/* 240 */ 752, 961, 946, 768, 768, 938, 938, 768, 811, 733,
98244	/* 250 */ 799, 740, 740, 740, 740, 768, 799, 811, 733, 733,
98245	/* 260 */ 768, 659, 913, 911, 768, 768, 659, 768, 659, 768,
98246	/* 270 */ 659, 878, 731, 731, 731, 716, 882, 882, 878, 731,
98247	/* 280 */ 701, 731, 716, 731, 731, 781, 776, 781, 776, 781,
98248	/* 290 */ 776, 768, 768, 961, 794, 782, 792, 790, 799, 961,
98249	/* 300 */ 719, 652, 652, 641, 641, 641, 641, 958, 958, 953,
98250	/* 310 */ 703, 703, 685, 961, 961, 961, 961, 961, 961, 961,
98251	/* 320 */ 887, 961, 961, 961, 961, 961, 961, 961, 961, 961,
98252	/* 330 */ 961, 961, 961, 961, 637, 948, 961, 961, 945, 961,
98253	/* 340 */ 961, 961, 961, 961, 961, 961, 961, 961, 961, 961,
98254	/* 350 */ 961, 961, 961, 961, 961, 961, 961, 961, 961, 917,
98255	/* 360 */ 961, 961, 961, 961, 961, 961, 910, 909, 961, 961,
98256	/* 370 */ 961, 961, 961, 961, 961, 961, 961, 961, 961, 961,
98257	/* 380 */ 961, 961, 961, 961, 961, 961, 961, 961, 961, 961,
98258	/* 390 */ 961, 961, 961, 961, 791, 961, 783, 961, 871, 961,
98259	/* 400 */ 961, 961, 961, 961, 961, 961, 961, 961, 961, 746,
98260	/* 410 */ 820, 961, 819, 823, 818, 669, 961, 650, 961, 633,
98261	/* 420 */ 638, 957, 960, 959, 956, 955, 954, 949, 947, 944,
98262	/* 430 */ 943, 942, 940, 937, 933, 891, 889, 896, 895, 894,
98263	/* 440 */ 893, 892, 890, 888, 886, 806, 804, 801, 798, 932,
98264	/* 450 */ 884, 742, 739, 738, 658, 950, 916, 925, 923, 812,
98265	/* 460 */ 922, 921, 920, 918, 915, 902, 808, 807, 734, 876,
98266	/* 470 */ 875, 661, 906, 905, 904, 908, 912, 903, 770, 660,
98267	/* 480 */ 657, 666, 723, 722, 730, 728, 727, 726, 725, 724,
98268	/* 490 */ 721, 668, 676, 687, 715, 700, 699, 881, 883, 880,
98269	/* 500 */ 879, 708, 707, 713, 712, 711, 710, 709, 706, 705,
98270	/* 510 */ 704, 697, 696, 702, 695, 718, 717, 714, 694, 737,
98271	/* 520 */ 736, 735, 732, 693, 692, 691, 823, 690, 689, 829,
98272	/* 530 */ 828, 816, 860, 757, 756, 755, 767, 766, 779, 778,
98273	/* 540 */ 814, 813, 780, 765, 759, 758, 774, 773, 772, 771,
98274	/* 550 */ 763, 753, 785, 788, 787, 784, 845, 862, 769, 859,
98275	/* 560 */ 931, 930, 929, 928, 927, 864, 863, 830, 827, 680,
98276	/* 570 */ 681, 900, 898, 899, 897, 683, 682, 679, 678, 861,
98277	/* 580 */ 748, 747, 857, 854, 846, 841, 858, 855, 847, 842,
98278	/* 590 */ 840, 839, 825, 824, 822, 821, 817, 826, 671, 749,
98279	/* 600 */ 745, 744, 815, 751, 750, 688, 686, 684, 665, 663,
98280	/* 610 */ 656, 654, 653, 655, 651, 649, 648, 647, 646, 645,
98281	/* 620 */ 674, 673, 672, 670, 669, 643, 640, 639, 635, 634,
98282	/* 630 */ 632,
98283	};
98284
98285	/* The next table maps tokens into fallback tokens. If a construct
98286	** like the following:
98287	**
	@@ -98491,19 +98718,18 @@
98491	"groupby_opt", "having_opt", "orderby_opt", "limit_opt",
98492	"sclp", "as", "seltablist", "stl_prefix",
98493	"joinop", "indexed_opt", "on_opt", "using_opt",
98494	"joinop2", "inscollist", "sortlist", "sortitem",
98495	"nexprlist", "setlist", "insert_cmd", "inscollist_opt",
98496	"itemlist", "exprlist", "likeop", "escape",
98497	"between_op", "in_op", "case_operand", "case_exprlist",
98498	"case_else", "uniqueflag", "collate", "nmnum",
98499	"plus_opt", "number", "trigger_decl", "trigger_cmd_list",
98500	"trigger_time", "trigger_event", "foreach_clause", "when_clause",
98501	"trigger_cmd", "trnm", "tridxby", "database_kw_opt",
98502	"key_opt", "add_column_fullname", "kwcolumn_opt", "create_vtab",
98503	"vtabarglist", "vtabarg", "vtabargtoken", "lp",
98504	"anylist",
98505	};
98506	#endif /* NDEBUG */
98507
98508	#ifndef NDEBUG
98509	/* For tracing reduce actions, the names of all rules are required.
	@@ -98719,128 +98945,127 @@
98719	/* 207 */ "expr ::= expr CONCAT expr",
98720	/* 208 */ "likeop ::= LIKE_KW",
98721	/* 209 */ "likeop ::= NOT LIKE_KW",
98722	/* 210 */ "likeop ::= MATCH",
98723	/* 211 */ "likeop ::= NOT MATCH",
98724	/* 212 */ "escape ::= ESCAPE expr",
98725	/* 213 */ "escape ::=",
98726	/* 214 */ "expr ::= expr likeop expr escape",
98727	/* 215 */ "expr ::= expr ISNULL\|NOTNULL",
98728	/* 216 */ "expr ::= expr NOT NULL",
98729	/* 217 */ "expr ::= expr IS expr",
98730	/* 218 */ "expr ::= expr IS NOT expr",
98731	/* 219 */ "expr ::= NOT expr",
98732	/* 220 */ "expr ::= BITNOT expr",
98733	/* 221 */ "expr ::= MINUS expr",
98734	/* 222 */ "expr ::= PLUS expr",
98735	/* 223 */ "between_op ::= BETWEEN",
98736	/* 224 */ "between_op ::= NOT BETWEEN",
98737	/* 225 */ "expr ::= expr between_op expr AND expr",
98738	/* 226 */ "in_op ::= IN",
98739	/* 227 */ "in_op ::= NOT IN",
98740	/* 228 */ "expr ::= expr in_op LP exprlist RP",
98741	/* 229 */ "expr ::= LP select RP",
98742	/* 230 */ "expr ::= expr in_op LP select RP",
98743	/* 231 */ "expr ::= expr in_op nm dbnm",
98744	/* 232 */ "expr ::= EXISTS LP select RP",
98745	/* 233 */ "expr ::= CASE case_operand case_exprlist case_else END",
98746	/* 234 */ "case_exprlist ::= case_exprlist WHEN expr THEN expr",
98747	/* 235 */ "case_exprlist ::= WHEN expr THEN expr",
98748	/* 236 */ "case_else ::= ELSE expr",
98749	/* 237 */ "case_else ::=",
98750	/* 238 */ "case_operand ::= expr",
98751	/* 239 */ "case_operand ::=",
98752	/* 240 */ "exprlist ::= nexprlist",
98753	/* 241 */ "exprlist ::=",
98754	/* 242 */ "nexprlist ::= nexprlist COMMA expr",
98755	/* 243 */ "nexprlist ::= expr",
98756	/* 244 */ "cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP idxlist RP",
98757	/* 245 */ "uniqueflag ::= UNIQUE",
98758	/* 246 */ "uniqueflag ::=",
98759	/* 247 */ "idxlist_opt ::=",
98760	/* 248 */ "idxlist_opt ::= LP idxlist RP",
98761	/* 249 */ "idxlist ::= idxlist COMMA nm collate sortorder",
98762	/* 250 */ "idxlist ::= nm collate sortorder",
98763	/* 251 */ "collate ::=",
98764	/* 252 */ "collate ::= COLLATE ids",
98765	/* 253 */ "cmd ::= DROP INDEX ifexists fullname",
98766	/* 254 */ "cmd ::= VACUUM",
98767	/* 255 */ "cmd ::= VACUUM nm",
98768	/* 256 */ "cmd ::= PRAGMA nm dbnm",
98769	/* 257 */ "cmd ::= PRAGMA nm dbnm EQ nmnum",
98770	/* 258 */ "cmd ::= PRAGMA nm dbnm LP nmnum RP",
98771	/* 259 */ "cmd ::= PRAGMA nm dbnm EQ minus_num",
98772	/* 260 */ "cmd ::= PRAGMA nm dbnm LP minus_num RP",
98773	/* 261 */ "nmnum ::= plus_num",
98774	/* 262 */ "nmnum ::= nm",
98775	/* 263 */ "nmnum ::= ON",
98776	/* 264 */ "nmnum ::= DELETE",
98777	/* 265 */ "nmnum ::= DEFAULT",
98778	/* 266 */ "plus_num ::= plus_opt number",
98779	/* 267 */ "minus_num ::= MINUS number",
98780	/* 268 */ "number ::= INTEGER\|FLOAT",
98781	/* 269 */ "plus_opt ::= PLUS",
98782	/* 270 */ "plus_opt ::=",
98783	/* 271 */ "cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END",
98784	/* 272 */ "trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause",
98785	/* 273 */ "trigger_time ::= BEFORE",
98786	/* 274 */ "trigger_time ::= AFTER",
98787	/* 275 */ "trigger_time ::= INSTEAD OF",
98788	/* 276 */ "trigger_time ::=",
98789	/* 277 */ "trigger_event ::= DELETE\|INSERT",
98790	/* 278 */ "trigger_event ::= UPDATE",
98791	/* 279 */ "trigger_event ::= UPDATE OF inscollist",
98792	/* 280 */ "foreach_clause ::=",
98793	/* 281 */ "foreach_clause ::= FOR EACH ROW",
98794	/* 282 */ "when_clause ::=",
98795	/* 283 */ "when_clause ::= WHEN expr",
98796	/* 284 */ "trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI",
98797	/* 285 */ "trigger_cmd_list ::= trigger_cmd SEMI",
98798	/* 286 */ "trnm ::= nm",
98799	/* 287 */ "trnm ::= nm DOT nm",
98800	/* 288 */ "tridxby ::=",
98801	/* 289 */ "tridxby ::= INDEXED BY nm",
98802	/* 290 */ "tridxby ::= NOT INDEXED",
98803	/* 291 */ "trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist where_opt",
98804	/* 292 */ "trigger_cmd ::= insert_cmd INTO trnm inscollist_opt VALUES LP itemlist RP",
98805	/* 293 */ "trigger_cmd ::= insert_cmd INTO trnm inscollist_opt select",
98806	/* 294 */ "trigger_cmd ::= DELETE FROM trnm tridxby where_opt",
98807	/* 295 */ "trigger_cmd ::= select",
98808	/* 296 */ "expr ::= RAISE LP IGNORE RP",
98809	/* 297 */ "expr ::= RAISE LP raisetype COMMA nm RP",
98810	/* 298 */ "raisetype ::= ROLLBACK",
98811	/* 299 */ "raisetype ::= ABORT",
98812	/* 300 */ "raisetype ::= FAIL",
98813	/* 301 */ "cmd ::= DROP TRIGGER ifexists fullname",
98814	/* 302 */ "cmd ::= ATTACH database_kw_opt expr AS expr key_opt",
98815	/* 303 */ "cmd ::= DETACH database_kw_opt expr",
98816	/* 304 */ "key_opt ::=",
98817	/* 305 */ "key_opt ::= KEY expr",
98818	/* 306 */ "database_kw_opt ::= DATABASE",
98819	/* 307 */ "database_kw_opt ::=",
98820	/* 308 */ "cmd ::= REINDEX",
98821	/* 309 */ "cmd ::= REINDEX nm dbnm",
98822	/* 310 */ "cmd ::= ANALYZE",
98823	/* 311 */ "cmd ::= ANALYZE nm dbnm",
98824	/* 312 */ "cmd ::= ALTER TABLE fullname RENAME TO nm",
98825	/* 313 */ "cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt column",
98826	/* 314 */ "add_column_fullname ::= fullname",
98827	/* 315 */ "kwcolumn_opt ::=",
98828	/* 316 */ "kwcolumn_opt ::= COLUMNKW",
98829	/* 317 */ "cmd ::= create_vtab",
98830	/* 318 */ "cmd ::= create_vtab LP vtabarglist RP",
98831	/* 319 */ "create_vtab ::= createkw VIRTUAL TABLE nm dbnm USING nm",
98832	/* 320 */ "vtabarglist ::= vtabarg",
98833	/* 321 */ "vtabarglist ::= vtabarglist COMMA vtabarg",
98834	/* 322 */ "vtabarg ::=",
98835	/* 323 */ "vtabarg ::= vtabarg vtabargtoken",
98836	/* 324 */ "vtabargtoken ::= ANY",
98837	/* 325 */ "vtabargtoken ::= lp anylist RP",
98838	/* 326 */ "lp ::= LP",
98839	/* 327 */ "anylist ::=",
98840	/* 328 */ "anylist ::= anylist LP anylist RP",
98841	/* 329 */ "anylist ::= anylist ANY",
98842	};
98843	#endif /* NDEBUG */
98844
98845
98846	#if YYSTACKDEPTH<=0
	@@ -98918,18 +99143,17 @@
98918	** inside the C code.
98919	*/
98920	case 160: /* select */
98921	case 194: /* oneselect */
98922	{
98923	sqlite3SelectDelete(pParse->db, (yypminor->yy3));
98924	}
98925	break;
98926	case 174: /* term */
98927	case 175: /* expr */
98928	case 223: /* escape */
98929	{
98930	sqlite3ExprDelete(pParse->db, (yypminor->yy346).pExpr);
98931	}
98932	break;
98933	case 179: /* idxlist_opt */
98934	case 187: /* idxlist */
98935	case 197: /* selcollist */
	@@ -98939,51 +99163,51 @@
98939	case 214: /* sortlist */
98940	case 216: /* nexprlist */
98941	case 217: /* setlist */
98942	case 220: /* itemlist */
98943	case 221: /* exprlist */
98944	case 227: /* case_exprlist */
98945	{
98946	sqlite3ExprListDelete(pParse->db, (yypminor->yy14));
98947	}
98948	break;
98949	case 193: /* fullname */
98950	case 198: /* from */
98951	case 206: /* seltablist */
98952	case 207: /* stl_prefix */
98953	{
98954	sqlite3SrcListDelete(pParse->db, (yypminor->yy65));
98955	}
98956	break;
98957	case 199: /* where_opt */
98958	case 201: /* having_opt */
98959	case 210: /* on_opt */
98960	case 215: /* sortitem */
98961	case 226: /* case_operand */
98962	case 228: /* case_else */
98963	case 239: /* when_clause */
98964	case 244: /* key_opt */
98965	{
98966	sqlite3ExprDelete(pParse->db, (yypminor->yy132));
98967	}
98968	break;
98969	case 211: /* using_opt */
98970	case 213: /* inscollist */
98971	case 219: /* inscollist_opt */
98972	{
98973	sqlite3IdListDelete(pParse->db, (yypminor->yy408));
98974	}
98975	break;
98976	case 235: /* trigger_cmd_list */
98977	case 240: /* trigger_cmd */
98978	{
98979	sqlite3DeleteTriggerStep(pParse->db, (yypminor->yy473));
98980	}
98981	break;
98982	case 237: /* trigger_event */
98983	{
98984	sqlite3IdListDelete(pParse->db, (yypminor->yy378).b);
98985	}
98986	break;
98987	default: break; /* If no destructor action specified: do nothing */
98988	}
98989	}
	@@ -99437,128 +99661,127 @@
99437	{ 175, 3 },
99438	{ 222, 1 },
99439	{ 222, 2 },
99440	{ 222, 1 },
99441	{ 222, 2 },
99442	{ 223, 2 },
99443	{ 223, 0 },
99444	{ 175, 4 },
99445	{ 175, 2 },
99446	{ 175, 3 },
99447	{ 175, 3 },
99448	{ 175, 4 },
99449	{ 175, 2 },
99450	{ 175, 2 },
99451	{ 175, 2 },
99452	{ 175, 2 },



99453	{ 224, 1 },
99454	{ 224, 2 },
99455	{ 175, 5 },
99456	{ 225, 1 },
99457	{ 225, 2 },
99458	{ 175, 5 },
99459	{ 175, 3 },
99460	{ 175, 5 },
99461	{ 175, 4 },
99462	{ 175, 4 },
99463	{ 175, 5 },
99464	{ 227, 5 },
99465	{ 227, 4 },
99466	{ 228, 2 },
99467	{ 228, 0 },
99468	{ 226, 1 },
99469	{ 226, 0 },
99470	{ 221, 1 },
99471	{ 221, 0 },
99472	{ 216, 3 },
99473	{ 216, 1 },
99474	{ 147, 11 },
99475	{ 229, 1 },
99476	{ 229, 0 },
99477	{ 179, 0 },
99478	{ 179, 3 },
99479	{ 187, 5 },
99480	{ 187, 3 },
99481	{ 230, 0 },
99482	{ 230, 2 },
99483	{ 147, 4 },
99484	{ 147, 1 },
99485	{ 147, 2 },
99486	{ 147, 3 },
99487	{ 147, 5 },
99488	{ 147, 6 },
99489	{ 147, 5 },
99490	{ 147, 6 },
99491	{ 231, 1 },
99492	{ 231, 1 },
99493	{ 231, 1 },
99494	{ 231, 1 },
99495	{ 231, 1 },
99496	{ 170, 2 },
99497	{ 171, 2 },
99498	{ 233, 1 },
99499	{ 232, 1 },
99500	{ 232, 0 },

99501	{ 147, 5 },
99502	{ 234, 11 },




99503	{ 236, 1 },
99504	{ 236, 1 },
99505	{ 236, 2 },
99506	{ 236, 0 },
99507	{ 237, 1 },
99508	{ 237, 1 },
99509	{ 237, 3 },
99510	{ 238, 0 },
99511	{ 238, 3 },
99512	{ 239, 0 },
99513	{ 239, 2 },
99514	{ 235, 3 },
99515	{ 235, 2 },
99516	{ 241, 1 },
99517	{ 241, 3 },
99518	{ 242, 0 },
99519	{ 242, 3 },
99520	{ 242, 2 },
99521	{ 240, 7 },
99522	{ 240, 8 },
99523	{ 240, 5 },
99524	{ 240, 5 },
99525	{ 240, 1 },
99526	{ 175, 4 },
99527	{ 175, 6 },
99528	{ 191, 1 },
99529	{ 191, 1 },
99530	{ 191, 1 },
99531	{ 147, 4 },
99532	{ 147, 6 },
99533	{ 147, 3 },
99534	{ 244, 0 },
99535	{ 244, 2 },
99536	{ 243, 1 },
99537	{ 243, 0 },



99538	{ 147, 1 },
99539	{ 147, 3 },
99540	{ 147, 1 },
99541	{ 147, 3 },
99542	{ 147, 6 },
99543	{ 147, 6 },


99544	{ 245, 1 },
99545	{ 246, 0 },
99546	{ 246, 1 },
99547	{ 147, 1 },
99548	{ 147, 4 },
99549	{ 247, 7 },
99550	{ 248, 1 },
99551	{ 248, 3 },
99552	{ 249, 0 },
99553	{ 249, 2 },


99554	{ 250, 1 },
99555	{ 250, 3 },
99556	{ 251, 1 },
99557	{ 252, 0 },
99558	{ 252, 4 },
99559	{ 252, 2 },
99560	};
99561
99562	static void yy_accept(yyParser); / Forward Declaration */
99563
99564	/*
	@@ -99622,21 +99845,21 @@
99622	break;
99623	case 8: /* cmdx ::= cmd */
99624	{ sqlite3FinishCoding(pParse); }
99625	break;
99626	case 9: /* cmd ::= BEGIN transtype trans_opt */
99627	{sqlite3BeginTransaction(pParse, yymsp[-1].minor.yy328);}
99628	break;
99629	case 13: /* transtype ::= */
99630	{yygotominor.yy328 = TK_DEFERRED;}
99631	break;
99632	case 14: /* transtype ::= DEFERRED */
99633	case 15: /* transtype ::= IMMEDIATE */ yytestcase(yyruleno==15);
99634	case 16: /* transtype ::= EXCLUSIVE */ yytestcase(yyruleno==16);
99635	case 115: /* multiselect_op ::= UNION */ yytestcase(yyruleno==115);
99636	case 117: /* multiselect_op ::= EXCEPT\|INTERSECT */ yytestcase(yyruleno==117);
99637	{yygotominor.yy328 = yymsp[0].major;}
99638	break;
99639	case 17: /* cmd ::= COMMIT trans_opt */
99640	case 18: /* cmd ::= END trans_opt */ yytestcase(yyruleno==18);
99641	{sqlite3CommitTransaction(pParse);}
99642	break;
	@@ -99658,11 +99881,11 @@
99658	sqlite3Savepoint(pParse, SAVEPOINT_ROLLBACK, &yymsp[0].minor.yy0);
99659	}
99660	break;
99661	case 26: /* create_table ::= createkw temp TABLE ifnotexists nm dbnm */
99662	{
99663	sqlite3StartTable(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,yymsp[-4].minor.yy328,0,0,yymsp[-2].minor.yy328);
99664	}
99665	break;
99666	case 27: /* createkw ::= CREATE */
99667	{
99668	pParse->db->lookaside.bEnabled = 0;
	@@ -99677,33 +99900,33 @@
99677	case 87: /* init_deferred_pred_opt ::= INITIALLY IMMEDIATE */ yytestcase(yyruleno==87);
99678	case 98: /* defer_subclause_opt ::= */ yytestcase(yyruleno==98);
99679	case 109: /* ifexists ::= */ yytestcase(yyruleno==109);
99680	case 120: /* distinct ::= ALL */ yytestcase(yyruleno==120);
99681	case 121: /* distinct ::= */ yytestcase(yyruleno==121);
99682	case 223: /* between_op ::= BETWEEN */ yytestcase(yyruleno==223);
99683	case 226: /* in_op ::= IN */ yytestcase(yyruleno==226);
99684	{yygotominor.yy328 = 0;}
99685	break;
99686	case 29: /* ifnotexists ::= IF NOT EXISTS */
99687	case 30: /* temp ::= TEMP */ yytestcase(yyruleno==30);
99688	case 71: /* autoinc ::= AUTOINCR */ yytestcase(yyruleno==71);
99689	case 86: /* init_deferred_pred_opt ::= INITIALLY DEFERRED */ yytestcase(yyruleno==86);
99690	case 108: /* ifexists ::= IF EXISTS */ yytestcase(yyruleno==108);
99691	case 119: /* distinct ::= DISTINCT */ yytestcase(yyruleno==119);
99692	case 224: /* between_op ::= NOT BETWEEN */ yytestcase(yyruleno==224);
99693	case 227: /* in_op ::= NOT IN */ yytestcase(yyruleno==227);
99694	{yygotominor.yy328 = 1;}
99695	break;
99696	case 32: /* create_table_args ::= LP columnlist conslist_opt RP */
99697	{
99698	sqlite3EndTable(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,0);
99699	}
99700	break;
99701	case 33: /* create_table_args ::= AS select */
99702	{
99703	sqlite3EndTable(pParse,0,0,yymsp[0].minor.yy3);
99704	sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy3);
99705	}
99706	break;
99707	case 36: /* column ::= columnid type carglist */
99708	{
99709	yygotominor.yy0.z = yymsp[-2].minor.yy0.z;
	@@ -99726,20 +99949,20 @@
99726	case 49: /* typename ::= ids */ yytestcase(yyruleno==49);
99727	case 127: /* as ::= AS nm */ yytestcase(yyruleno==127);
99728	case 128: /* as ::= ids */ yytestcase(yyruleno==128);
99729	case 138: /* dbnm ::= DOT nm */ yytestcase(yyruleno==138);
99730	case 147: /* indexed_opt ::= INDEXED BY nm */ yytestcase(yyruleno==147);
99731	case 252: /* collate ::= COLLATE ids */ yytestcase(yyruleno==252);
99732	case 261: /* nmnum ::= plus_num */ yytestcase(yyruleno==261);
99733	case 262: /* nmnum ::= nm */ yytestcase(yyruleno==262);
99734	case 263: /* nmnum ::= ON */ yytestcase(yyruleno==263);
99735	case 264: /* nmnum ::= DELETE */ yytestcase(yyruleno==264);
99736	case 265: /* nmnum ::= DEFAULT */ yytestcase(yyruleno==265);
99737	case 266: /* plus_num ::= plus_opt number */ yytestcase(yyruleno==266);
99738	case 267: /* minus_num ::= MINUS number */ yytestcase(yyruleno==267);
99739	case 268: /* number ::= INTEGER\|FLOAT */ yytestcase(yyruleno==268);
99740	case 286: /* trnm ::= nm */ yytestcase(yyruleno==286);
99741	{yygotominor.yy0 = yymsp[0].minor.yy0;}
99742	break;
99743	case 45: /* type ::= typetoken */
99744	{sqlite3AddColumnType(pParse,&yymsp[0].minor.yy0);}
99745	break;
	@@ -99758,21 +99981,21 @@
99758	case 50: /* typename ::= typename ids */
99759	{yygotominor.yy0.z=yymsp[-1].minor.yy0.z; yygotominor.yy0.n=yymsp[0].minor.yy0.n+(int)(yymsp[0].minor.yy0.z-yymsp[-1].minor.yy0.z);}
99760	break;
99761	case 57: /* ccons ::= DEFAULT term */
99762	case 59: /* ccons ::= DEFAULT PLUS term */ yytestcase(yyruleno==59);
99763	{sqlite3AddDefaultValue(pParse,&yymsp[0].minor.yy346);}
99764	break;
99765	case 58: /* ccons ::= DEFAULT LP expr RP */
99766	{sqlite3AddDefaultValue(pParse,&yymsp[-1].minor.yy346);}
99767	break;
99768	case 60: /* ccons ::= DEFAULT MINUS term */
99769	{
99770	ExprSpan v;
99771	v.pExpr = sqlite3PExpr(pParse, TK_UMINUS, yymsp[0].minor.yy346.pExpr, 0, 0);
99772	v.zStart = yymsp[-1].minor.yy0.z;
99773	v.zEnd = yymsp[0].minor.yy346.zEnd;
99774	sqlite3AddDefaultValue(pParse,&v);
99775	}
99776	break;
99777	case 61: /* ccons ::= DEFAULT id */
99778	{
	@@ -99780,454 +100003,453 @@
99780	spanExpr(&v, pParse, TK_STRING, &yymsp[0].minor.yy0);
99781	sqlite3AddDefaultValue(pParse,&v);
99782	}
99783	break;
99784	case 63: /* ccons ::= NOT NULL onconf */
99785	{sqlite3AddNotNull(pParse, yymsp[0].minor.yy328);}
99786	break;
99787	case 64: /* ccons ::= PRIMARY KEY sortorder onconf autoinc */
99788	{sqlite3AddPrimaryKey(pParse,0,yymsp[-1].minor.yy328,yymsp[0].minor.yy328,yymsp[-2].minor.yy328);}
99789	break;
99790	case 65: /* ccons ::= UNIQUE onconf */
99791	{sqlite3CreateIndex(pParse,0,0,0,0,yymsp[0].minor.yy328,0,0,0,0);}
99792	break;
99793	case 66: /* ccons ::= CHECK LP expr RP */
99794	{sqlite3AddCheckConstraint(pParse,yymsp[-1].minor.yy346.pExpr);}
99795	break;
99796	case 67: /* ccons ::= REFERENCES nm idxlist_opt refargs */
99797	{sqlite3CreateForeignKey(pParse,0,&yymsp[-2].minor.yy0,yymsp[-1].minor.yy14,yymsp[0].minor.yy328);}
99798	break;
99799	case 68: /* ccons ::= defer_subclause */
99800	{sqlite3DeferForeignKey(pParse,yymsp[0].minor.yy328);}
99801	break;
99802	case 69: /* ccons ::= COLLATE ids */
99803	{sqlite3AddCollateType(pParse, &yymsp[0].minor.yy0);}
99804	break;
99805	case 72: /* refargs ::= */
99806	{ yygotominor.yy328 = OE_None0x0101; / EV: R-19803-45884 */}
99807	break;
99808	case 73: /* refargs ::= refargs refarg */
99809	{ yygotominor.yy328 = (yymsp[-1].minor.yy328 & ~yymsp[0].minor.yy429.mask) \| yymsp[0].minor.yy429.value; }
99810	break;
99811	case 74: /* refarg ::= MATCH nm */
99812	case 75: /* refarg ::= ON INSERT refact */ yytestcase(yyruleno==75);
99813	{ yygotominor.yy429.value = 0; yygotominor.yy429.mask = 0x000000; }
99814	break;
99815	case 76: /* refarg ::= ON DELETE refact */
99816	{ yygotominor.yy429.value = yymsp[0].minor.yy328; yygotominor.yy429.mask = 0x0000ff; }
99817	break;
99818	case 77: /* refarg ::= ON UPDATE refact */
99819	{ yygotominor.yy429.value = yymsp[0].minor.yy328<<8; yygotominor.yy429.mask = 0x00ff00; }
99820	break;
99821	case 78: /* refact ::= SET NULL */
99822	{ yygotominor.yy328 = OE_SetNull; /* EV: R-33326-45252 */}
99823	break;
99824	case 79: /* refact ::= SET DEFAULT */
99825	{ yygotominor.yy328 = OE_SetDflt; /* EV: R-33326-45252 */}
99826	break;
99827	case 80: /* refact ::= CASCADE */
99828	{ yygotominor.yy328 = OE_Cascade; /* EV: R-33326-45252 */}
99829	break;
99830	case 81: /* refact ::= RESTRICT */
99831	{ yygotominor.yy328 = OE_Restrict; /* EV: R-33326-45252 */}
99832	break;
99833	case 82: /* refact ::= NO ACTION */
99834	{ yygotominor.yy328 = OE_None; /* EV: R-33326-45252 */}
99835	break;
99836	case 84: /* defer_subclause ::= DEFERRABLE init_deferred_pred_opt */
99837	case 99: /* defer_subclause_opt ::= defer_subclause */ yytestcase(yyruleno==99);
99838	case 101: /* onconf ::= ON CONFLICT resolvetype */ yytestcase(yyruleno==101);
99839	case 104: /* resolvetype ::= raisetype */ yytestcase(yyruleno==104);
99840	{yygotominor.yy328 = yymsp[0].minor.yy328;}
99841	break;
99842	case 88: /* conslist_opt ::= */
99843	{yygotominor.yy0.n = 0; yygotominor.yy0.z = 0;}
99844	break;
99845	case 89: /* conslist_opt ::= COMMA conslist */
99846	{yygotominor.yy0 = yymsp[-1].minor.yy0;}
99847	break;
99848	case 94: /* tcons ::= PRIMARY KEY LP idxlist autoinc RP onconf */
99849	{sqlite3AddPrimaryKey(pParse,yymsp[-3].minor.yy14,yymsp[0].minor.yy328,yymsp[-2].minor.yy328,0);}
99850	break;
99851	case 95: /* tcons ::= UNIQUE LP idxlist RP onconf */
99852	{sqlite3CreateIndex(pParse,0,0,0,yymsp[-2].minor.yy14,yymsp[0].minor.yy328,0,0,0,0);}
99853	break;
99854	case 96: /* tcons ::= CHECK LP expr RP onconf */
99855	{sqlite3AddCheckConstraint(pParse,yymsp[-2].minor.yy346.pExpr);}
99856	break;
99857	case 97: /* tcons ::= FOREIGN KEY LP idxlist RP REFERENCES nm idxlist_opt refargs defer_subclause_opt */
99858	{
99859	sqlite3CreateForeignKey(pParse, yymsp[-6].minor.yy14, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy14, yymsp[-1].minor.yy328);
99860	sqlite3DeferForeignKey(pParse, yymsp[0].minor.yy328);
99861	}
99862	break;
99863	case 100: /* onconf ::= */
99864	{yygotominor.yy328 = OE_Default;}
99865	break;
99866	case 102: /* orconf ::= */
99867	{yygotominor.yy186 = OE_Default;}
99868	break;
99869	case 103: /* orconf ::= OR resolvetype */
99870	{yygotominor.yy186 = (u8)yymsp[0].minor.yy328;}
99871	break;
99872	case 105: /* resolvetype ::= IGNORE */
99873	{yygotominor.yy328 = OE_Ignore;}
99874	break;
99875	case 106: /* resolvetype ::= REPLACE */
99876	{yygotominor.yy328 = OE_Replace;}
99877	break;
99878	case 107: /* cmd ::= DROP TABLE ifexists fullname */
99879	{
99880	sqlite3DropTable(pParse, yymsp[0].minor.yy65, 0, yymsp[-1].minor.yy328);
99881	}
99882	break;
99883	case 110: /* cmd ::= createkw temp VIEW ifnotexists nm dbnm AS select */
99884	{
99885	sqlite3CreateView(pParse, &yymsp[-7].minor.yy0, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0, yymsp[0].minor.yy3, yymsp[-6].minor.yy328, yymsp[-4].minor.yy328);
99886	}
99887	break;
99888	case 111: /* cmd ::= DROP VIEW ifexists fullname */
99889	{
99890	sqlite3DropTable(pParse, yymsp[0].minor.yy65, 1, yymsp[-1].minor.yy328);
99891	}
99892	break;
99893	case 112: /* cmd ::= select */
99894	{
99895	SelectDest dest = {SRT_Output, 0, 0, 0, 0};
99896	sqlite3Select(pParse, yymsp[0].minor.yy3, &dest);
99897	sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy3);
99898	}
99899	break;
99900	case 113: /* select ::= oneselect */
99901	{yygotominor.yy3 = yymsp[0].minor.yy3;}
99902	break;
99903	case 114: /* select ::= select multiselect_op oneselect */
99904	{
99905	if( yymsp[0].minor.yy3 ){
99906	yymsp[0].minor.yy3->op = (u8)yymsp[-1].minor.yy328;
99907	yymsp[0].minor.yy3->pPrior = yymsp[-2].minor.yy3;
99908	}else{
99909	sqlite3SelectDelete(pParse->db, yymsp[-2].minor.yy3);
99910	}
99911	yygotominor.yy3 = yymsp[0].minor.yy3;
99912	}
99913	break;
99914	case 116: /* multiselect_op ::= UNION ALL */
99915	{yygotominor.yy328 = TK_ALL;}
99916	break;
99917	case 118: /* oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */
99918	{
99919	yygotominor.yy3 = sqlite3SelectNew(pParse,yymsp[-6].minor.yy14,yymsp[-5].minor.yy65,yymsp[-4].minor.yy132,yymsp[-3].minor.yy14,yymsp[-2].minor.yy132,yymsp[-1].minor.yy14,yymsp[-7].minor.yy328,yymsp[0].minor.yy476.pLimit,yymsp[0].minor.yy476.pOffset);
99920	}
99921	break;
99922	case 122: /* sclp ::= selcollist COMMA */
99923	case 248: /* idxlist_opt ::= LP idxlist RP */ yytestcase(yyruleno==248);
99924	{yygotominor.yy14 = yymsp[-1].minor.yy14;}
99925	break;
99926	case 123: /* sclp ::= */
99927	case 151: /* orderby_opt ::= */ yytestcase(yyruleno==151);
99928	case 159: /* groupby_opt ::= */ yytestcase(yyruleno==159);
99929	case 241: /* exprlist ::= */ yytestcase(yyruleno==241);
99930	case 247: /* idxlist_opt ::= */ yytestcase(yyruleno==247);
99931	{yygotominor.yy14 = 0;}
99932	break;
99933	case 124: /* selcollist ::= sclp expr as */
99934	{
99935	yygotominor.yy14 = sqlite3ExprListAppend(pParse, yymsp[-2].minor.yy14, yymsp[-1].minor.yy346.pExpr);
99936	if( yymsp[0].minor.yy0.n>0 ) sqlite3ExprListSetName(pParse, yygotominor.yy14, &yymsp[0].minor.yy0, 1);
99937	sqlite3ExprListSetSpan(pParse,yygotominor.yy14,&yymsp[-1].minor.yy346);
99938	}
99939	break;
99940	case 125: /* selcollist ::= sclp STAR */
99941	{
99942	Expr *p = sqlite3Expr(pParse->db, TK_ALL, 0);
99943	yygotominor.yy14 = sqlite3ExprListAppend(pParse, yymsp[-1].minor.yy14, p);
99944	}
99945	break;
99946	case 126: /* selcollist ::= sclp nm DOT STAR */
99947	{
99948	Expr *pRight = sqlite3PExpr(pParse, TK_ALL, 0, 0, &yymsp[0].minor.yy0);
99949	Expr *pLeft = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[-2].minor.yy0);
99950	Expr *pDot = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight, 0);
99951	yygotominor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy14, pDot);
99952	}
99953	break;
99954	case 129: /* as ::= */
99955	{yygotominor.yy0.n = 0;}
99956	break;
99957	case 130: /* from ::= */
99958	{yygotominor.yy65 = sqlite3DbMallocZero(pParse->db, sizeof(*yygotominor.yy65));}
99959	break;
99960	case 131: /* from ::= FROM seltablist */
99961	{
99962	yygotominor.yy65 = yymsp[0].minor.yy65;
99963	sqlite3SrcListShiftJoinType(yygotominor.yy65);
99964	}
99965	break;
99966	case 132: /* stl_prefix ::= seltablist joinop */
99967	{
99968	yygotominor.yy65 = yymsp[-1].minor.yy65;
99969	if( ALWAYS(yygotominor.yy65 && yygotominor.yy65->nSrc>0) ) yygotominor.yy65->a[yygotominor.yy65->nSrc-1].jointype = (u8)yymsp[0].minor.yy328;
99970	}
99971	break;
99972	case 133: /* stl_prefix ::= */
99973	{yygotominor.yy65 = 0;}
99974	break;
99975	case 134: /* seltablist ::= stl_prefix nm dbnm as indexed_opt on_opt using_opt */
99976	{
99977	yygotominor.yy65 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy65,&yymsp[-5].minor.yy0,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,0,yymsp[-1].minor.yy132,yymsp[0].minor.yy408);
99978	sqlite3SrcListIndexedBy(pParse, yygotominor.yy65, &yymsp[-2].minor.yy0);
99979	}
99980	break;
99981	case 135: /* seltablist ::= stl_prefix LP select RP as on_opt using_opt */
99982	{
99983	yygotominor.yy65 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy65,0,0,&yymsp[-2].minor.yy0,yymsp[-4].minor.yy3,yymsp[-1].minor.yy132,yymsp[0].minor.yy408);
99984	}
99985	break;
99986	case 136: /* seltablist ::= stl_prefix LP seltablist RP as on_opt using_opt */
99987	{
99988	if( yymsp[-6].minor.yy65==0 && yymsp[-2].minor.yy0.n==0 && yymsp[-1].minor.yy132==0 && yymsp[0].minor.yy408==0 ){
99989	yygotominor.yy65 = yymsp[-4].minor.yy65;
99990	}else{
99991	Select *pSubquery;
99992	sqlite3SrcListShiftJoinType(yymsp[-4].minor.yy65);
99993	pSubquery = sqlite3SelectNew(pParse,0,yymsp[-4].minor.yy65,0,0,0,0,0,0,0);
99994	yygotominor.yy65 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy65,0,0,&yymsp[-2].minor.yy0,pSubquery,yymsp[-1].minor.yy132,yymsp[0].minor.yy408);
99995	}
99996	}
99997	break;
99998	case 137: /* dbnm ::= */
99999	case 146: /* indexed_opt ::= */ yytestcase(yyruleno==146);
100000	{yygotominor.yy0.z=0; yygotominor.yy0.n=0;}
100001	break;
100002	case 139: /* fullname ::= nm dbnm */
100003	{yygotominor.yy65 = sqlite3SrcListAppend(pParse->db,0,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0);}
100004	break;
100005	case 140: /* joinop ::= COMMA\|JOIN */
100006	{ yygotominor.yy328 = JT_INNER; }
100007	break;
100008	case 141: /* joinop ::= JOIN_KW JOIN */
100009	{ yygotominor.yy328 = sqlite3JoinType(pParse,&yymsp[-1].minor.yy0,0,0); }
100010	break;
100011	case 142: /* joinop ::= JOIN_KW nm JOIN */
100012	{ yygotominor.yy328 = sqlite3JoinType(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,0); }
100013	break;
100014	case 143: /* joinop ::= JOIN_KW nm nm JOIN */
100015	{ yygotominor.yy328 = sqlite3JoinType(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0); }
100016	break;
100017	case 144: /* on_opt ::= ON expr */
100018	case 155: /* sortitem ::= expr */ yytestcase(yyruleno==155);
100019	case 162: /* having_opt ::= HAVING expr */ yytestcase(yyruleno==162);
100020	case 169: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==169);
100021	case 236: /* case_else ::= ELSE expr */ yytestcase(yyruleno==236);
100022	case 238: /* case_operand ::= expr */ yytestcase(yyruleno==238);
100023	{yygotominor.yy132 = yymsp[0].minor.yy346.pExpr;}
100024	break;
100025	case 145: /* on_opt ::= */
100026	case 161: /* having_opt ::= */ yytestcase(yyruleno==161);
100027	case 168: /* where_opt ::= */ yytestcase(yyruleno==168);
100028	case 237: /* case_else ::= */ yytestcase(yyruleno==237);
100029	case 239: /* case_operand ::= */ yytestcase(yyruleno==239);
100030	{yygotominor.yy132 = 0;}
100031	break;
100032	case 148: /* indexed_opt ::= NOT INDEXED */
100033	{yygotominor.yy0.z=0; yygotominor.yy0.n=1;}
100034	break;
100035	case 149: /* using_opt ::= USING LP inscollist RP */
100036	case 181: /* inscollist_opt ::= LP inscollist RP */ yytestcase(yyruleno==181);
100037	{yygotominor.yy408 = yymsp[-1].minor.yy408;}
100038	break;
100039	case 150: /* using_opt ::= */
100040	case 180: /* inscollist_opt ::= */ yytestcase(yyruleno==180);
100041	{yygotominor.yy408 = 0;}
100042	break;
100043	case 152: /* orderby_opt ::= ORDER BY sortlist */
100044	case 160: /* groupby_opt ::= GROUP BY nexprlist */ yytestcase(yyruleno==160);
100045	case 240: /* exprlist ::= nexprlist */ yytestcase(yyruleno==240);
100046	{yygotominor.yy14 = yymsp[0].minor.yy14;}
100047	break;
100048	case 153: /* sortlist ::= sortlist COMMA sortitem sortorder */
100049	{
100050	yygotominor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy14,yymsp[-1].minor.yy132);
100051	if( yygotominor.yy14 ) yygotominor.yy14->a[yygotominor.yy14->nExpr-1].sortOrder = (u8)yymsp[0].minor.yy328;
100052	}
100053	break;
100054	case 154: /* sortlist ::= sortitem sortorder */
100055	{
100056	yygotominor.yy14 = sqlite3ExprListAppend(pParse,0,yymsp[-1].minor.yy132);
100057	if( yygotominor.yy14 && ALWAYS(yygotominor.yy14->a) ) yygotominor.yy14->a[0].sortOrder = (u8)yymsp[0].minor.yy328;
100058	}
100059	break;
100060	case 156: /* sortorder ::= ASC */
100061	case 158: /* sortorder ::= */ yytestcase(yyruleno==158);
100062	{yygotominor.yy328 = SQLITE_SO_ASC;}
100063	break;
100064	case 157: /* sortorder ::= DESC */
100065	{yygotominor.yy328 = SQLITE_SO_DESC;}
100066	break;
100067	case 163: /* limit_opt ::= */
100068	{yygotominor.yy476.pLimit = 0; yygotominor.yy476.pOffset = 0;}
100069	break;
100070	case 164: /* limit_opt ::= LIMIT expr */
100071	{yygotominor.yy476.pLimit = yymsp[0].minor.yy346.pExpr; yygotominor.yy476.pOffset = 0;}
100072	break;
100073	case 165: /* limit_opt ::= LIMIT expr OFFSET expr */
100074	{yygotominor.yy476.pLimit = yymsp[-2].minor.yy346.pExpr; yygotominor.yy476.pOffset = yymsp[0].minor.yy346.pExpr;}
100075	break;
100076	case 166: /* limit_opt ::= LIMIT expr COMMA expr */
100077	{yygotominor.yy476.pOffset = yymsp[-2].minor.yy346.pExpr; yygotominor.yy476.pLimit = yymsp[0].minor.yy346.pExpr;}
100078	break;
100079	case 167: /* cmd ::= DELETE FROM fullname indexed_opt where_opt */
100080	{
100081	sqlite3SrcListIndexedBy(pParse, yymsp[-2].minor.yy65, &yymsp[-1].minor.yy0);
100082	sqlite3DeleteFrom(pParse,yymsp[-2].minor.yy65,yymsp[0].minor.yy132);
100083	}
100084	break;
100085	case 170: /* cmd ::= UPDATE orconf fullname indexed_opt SET setlist where_opt */
100086	{
100087	sqlite3SrcListIndexedBy(pParse, yymsp[-4].minor.yy65, &yymsp[-3].minor.yy0);
100088	sqlite3ExprListCheckLength(pParse,yymsp[-1].minor.yy14,"set list");
100089	sqlite3Update(pParse,yymsp[-4].minor.yy65,yymsp[-1].minor.yy14,yymsp[0].minor.yy132,yymsp[-5].minor.yy186);
100090	}
100091	break;
100092	case 171: /* setlist ::= setlist COMMA nm EQ expr */
100093	{
100094	yygotominor.yy14 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy14, yymsp[0].minor.yy346.pExpr);
100095	sqlite3ExprListSetName(pParse, yygotominor.yy14, &yymsp[-2].minor.yy0, 1);
100096	}
100097	break;
100098	case 172: /* setlist ::= nm EQ expr */
100099	{
100100	yygotominor.yy14 = sqlite3ExprListAppend(pParse, 0, yymsp[0].minor.yy346.pExpr);
100101	sqlite3ExprListSetName(pParse, yygotominor.yy14, &yymsp[-2].minor.yy0, 1);
100102	}
100103	break;
100104	case 173: /* cmd ::= insert_cmd INTO fullname inscollist_opt VALUES LP itemlist RP */
100105	{sqlite3Insert(pParse, yymsp[-5].minor.yy65, yymsp[-1].minor.yy14, 0, yymsp[-4].minor.yy408, yymsp[-7].minor.yy186);}
100106	break;
100107	case 174: /* cmd ::= insert_cmd INTO fullname inscollist_opt select */
100108	{sqlite3Insert(pParse, yymsp[-2].minor.yy65, 0, yymsp[0].minor.yy3, yymsp[-1].minor.yy408, yymsp[-4].minor.yy186);}
100109	break;
100110	case 175: /* cmd ::= insert_cmd INTO fullname inscollist_opt DEFAULT VALUES */
100111	{sqlite3Insert(pParse, yymsp[-3].minor.yy65, 0, 0, yymsp[-2].minor.yy408, yymsp[-5].minor.yy186);}
100112	break;
100113	case 176: /* insert_cmd ::= INSERT orconf */
100114	{yygotominor.yy186 = yymsp[0].minor.yy186;}
100115	break;
100116	case 177: /* insert_cmd ::= REPLACE */
100117	{yygotominor.yy186 = OE_Replace;}
100118	break;
100119	case 178: /* itemlist ::= itemlist COMMA expr */
100120	case 242: /* nexprlist ::= nexprlist COMMA expr */ yytestcase(yyruleno==242);
100121	{yygotominor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy14,yymsp[0].minor.yy346.pExpr);}
100122	break;
100123	case 179: /* itemlist ::= expr */
100124	case 243: /* nexprlist ::= expr */ yytestcase(yyruleno==243);
100125	{yygotominor.yy14 = sqlite3ExprListAppend(pParse,0,yymsp[0].minor.yy346.pExpr);}
100126	break;
100127	case 182: /* inscollist ::= inscollist COMMA nm */
100128	{yygotominor.yy408 = sqlite3IdListAppend(pParse->db,yymsp[-2].minor.yy408,&yymsp[0].minor.yy0);}
100129	break;
100130	case 183: /* inscollist ::= nm */
100131	{yygotominor.yy408 = sqlite3IdListAppend(pParse->db,0,&yymsp[0].minor.yy0);}
100132	break;
100133	case 184: /* expr ::= term */
100134	case 212: /* escape ::= ESCAPE expr */ yytestcase(yyruleno==212);
100135	{yygotominor.yy346 = yymsp[0].minor.yy346;}
100136	break;
100137	case 185: /* expr ::= LP expr RP */
100138	{yygotominor.yy346.pExpr = yymsp[-1].minor.yy346.pExpr; spanSet(&yygotominor.yy346,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0);}
100139	break;
100140	case 186: /* term ::= NULL */
100141	case 191: /* term ::= INTEGER\|FLOAT\|BLOB */ yytestcase(yyruleno==191);
100142	case 192: /* term ::= STRING */ yytestcase(yyruleno==192);
100143	{spanExpr(&yygotominor.yy346, pParse, yymsp[0].major, &yymsp[0].minor.yy0);}
100144	break;
100145	case 187: /* expr ::= id */
100146	case 188: /* expr ::= JOIN_KW */ yytestcase(yyruleno==188);
100147	{spanExpr(&yygotominor.yy346, pParse, TK_ID, &yymsp[0].minor.yy0);}
100148	break;
100149	case 189: /* expr ::= nm DOT nm */
100150	{
100151	Expr *temp1 = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[-2].minor.yy0);
100152	Expr *temp2 = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[0].minor.yy0);
100153	yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_DOT, temp1, temp2, 0);
100154	spanSet(&yygotominor.yy346,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0);
100155	}
100156	break;
100157	case 190: /* expr ::= nm DOT nm DOT nm */
100158	{
100159	Expr *temp1 = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[-4].minor.yy0);
100160	Expr *temp2 = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[-2].minor.yy0);
100161	Expr *temp3 = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[0].minor.yy0);
100162	Expr *temp4 = sqlite3PExpr(pParse, TK_DOT, temp2, temp3, 0);
100163	yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_DOT, temp1, temp4, 0);
100164	spanSet(&yygotominor.yy346,&yymsp[-4].minor.yy0,&yymsp[0].minor.yy0);
100165	}
100166	break;
100167	case 193: /* expr ::= REGISTER */
100168	{
100169	/* When doing a nested parse, one can include terms in an expression
100170	** that look like this: #1 #2 ... These terms refer to registers
100171	** in the virtual machine. #N is the N-th register. */
100172	if( pParse->nested==0 ){
100173	sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", &yymsp[0].minor.yy0);
100174	yygotominor.yy346.pExpr = 0;
100175	}else{
100176	yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_REGISTER, 0, 0, &yymsp[0].minor.yy0);
100177	if( yygotominor.yy346.pExpr ) sqlite3GetInt32(&yymsp[0].minor.yy0.z[1], &yygotominor.yy346.pExpr->iTable);
100178	}
100179	spanSet(&yygotominor.yy346, &yymsp[0].minor.yy0, &yymsp[0].minor.yy0);
100180	}
100181	break;
100182	case 194: /* expr ::= VARIABLE */
100183	{
100184	spanExpr(&yygotominor.yy346, pParse, TK_VARIABLE, &yymsp[0].minor.yy0);
100185	sqlite3ExprAssignVarNumber(pParse, yygotominor.yy346.pExpr);
100186	spanSet(&yygotominor.yy346, &yymsp[0].minor.yy0, &yymsp[0].minor.yy0);
100187	}
100188	break;
100189	case 195: /* expr ::= expr COLLATE ids */
100190	{
100191	yygotominor.yy346.pExpr = sqlite3ExprSetColl(pParse, yymsp[-2].minor.yy346.pExpr, &yymsp[0].minor.yy0);
100192	yygotominor.yy346.zStart = yymsp[-2].minor.yy346.zStart;
100193	yygotominor.yy346.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
100194	}
100195	break;
100196	case 196: /* expr ::= CAST LP expr AS typetoken RP */
100197	{
100198	yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_CAST, yymsp[-3].minor.yy346.pExpr, 0, &yymsp[-1].minor.yy0);
100199	spanSet(&yygotominor.yy346,&yymsp[-5].minor.yy0,&yymsp[0].minor.yy0);
100200	}
100201	break;
100202	case 197: /* expr ::= ID LP distinct exprlist RP */
100203	{
100204	if( yymsp[-1].minor.yy14 && yymsp[-1].minor.yy14->nExpr>pParse->db->aLimit[SQLITE_LIMIT_FUNCTION_ARG] ){
100205	sqlite3ErrorMsg(pParse, "too many arguments on function %T", &yymsp[-4].minor.yy0);
100206	}
100207	yygotominor.yy346.pExpr = sqlite3ExprFunction(pParse, yymsp[-1].minor.yy14, &yymsp[-4].minor.yy0);
100208	spanSet(&yygotominor.yy346,&yymsp[-4].minor.yy0,&yymsp[0].minor.yy0);
100209	if( yymsp[-2].minor.yy328 && yygotominor.yy346.pExpr ){
100210	yygotominor.yy346.pExpr->flags \|= EP_Distinct;
100211	}
100212	}
100213	break;
100214	case 198: /* expr ::= ID LP STAR RP */
100215	{
100216	yygotominor.yy346.pExpr = sqlite3ExprFunction(pParse, 0, &yymsp[-3].minor.yy0);
100217	spanSet(&yygotominor.yy346,&yymsp[-3].minor.yy0,&yymsp[0].minor.yy0);
100218	}
100219	break;
100220	case 199: /* term ::= CTIME_KW */
100221	{
100222	/* The CURRENT_TIME, CURRENT_DATE, and CURRENT_TIMESTAMP values are
100223	** treated as functions that return constants */
100224	yygotominor.yy346.pExpr = sqlite3ExprFunction(pParse, 0,&yymsp[0].minor.yy0);
100225	if( yygotominor.yy346.pExpr ){
100226	yygotominor.yy346.pExpr->op = TK_CONST_FUNC;
100227	}
100228	spanSet(&yygotominor.yy346, &yymsp[0].minor.yy0, &yymsp[0].minor.yy0);
100229	}
100230	break;
100231	case 200: /* expr ::= expr AND expr */
100232	case 201: /* expr ::= expr OR expr */ yytestcase(yyruleno==201);
100233	case 202: /* expr ::= expr LT\|GT\|GE\|LE expr */ yytestcase(yyruleno==202);
	@@ -100234,421 +100456,441 @@
100234	case 203: /* expr ::= expr EQ\|NE expr */ yytestcase(yyruleno==203);
100235	case 204: /* expr ::= expr BITAND\|BITOR\|LSHIFT\|RSHIFT expr */ yytestcase(yyruleno==204);
100236	case 205: /* expr ::= expr PLUS\|MINUS expr */ yytestcase(yyruleno==205);
100237	case 206: /* expr ::= expr STAR\|SLASH\|REM expr */ yytestcase(yyruleno==206);
100238	case 207: /* expr ::= expr CONCAT expr */ yytestcase(yyruleno==207);
100239	{spanBinaryExpr(&yygotominor.yy346,pParse,yymsp[-1].major,&yymsp[-2].minor.yy346,&yymsp[0].minor.yy346);}
100240	break;
100241	case 208: /* likeop ::= LIKE_KW */
100242	case 210: /* likeop ::= MATCH */ yytestcase(yyruleno==210);
100243	{yygotominor.yy96.eOperator = yymsp[0].minor.yy0; yygotominor.yy96.not = 0;}
100244	break;
100245	case 209: /* likeop ::= NOT LIKE_KW */
100246	case 211: /* likeop ::= NOT MATCH */ yytestcase(yyruleno==211);
100247	{yygotominor.yy96.eOperator = yymsp[0].minor.yy0; yygotominor.yy96.not = 1;}
100248	break;
100249	case 213: /* escape ::= */
100250	{memset(&yygotominor.yy346,0,sizeof(yygotominor.yy346));}









100251	break;
100252	case 214: /* expr ::= expr likeop expr escape */
100253	{
100254	ExprList *pList;
100255	pList = sqlite3ExprListAppend(pParse,0, yymsp[-1].minor.yy346.pExpr);
100256	pList = sqlite3ExprListAppend(pParse,pList, yymsp[-3].minor.yy346.pExpr);
100257	if( yymsp[0].minor.yy346.pExpr ){
100258	pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy346.pExpr);
100259	}
100260	yygotominor.yy346.pExpr = sqlite3ExprFunction(pParse, pList, &yymsp[-2].minor.yy96.eOperator);
100261	if( yymsp[-2].minor.yy96.not ) yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy346.pExpr, 0, 0);
100262	yygotominor.yy346.zStart = yymsp[-3].minor.yy346.zStart;
100263	yygotominor.yy346.zEnd = yymsp[-1].minor.yy346.zEnd;
100264	if( yygotominor.yy346.pExpr ) yygotominor.yy346.pExpr->flags \|= EP_InfixFunc;
100265	}
100266	break;
100267	case 215: /* expr ::= expr ISNULL\|NOTNULL */
100268	{spanUnaryPostfix(&yygotominor.yy346,pParse,yymsp[0].major,&yymsp[-1].minor.yy346,&yymsp[0].minor.yy0);}
100269	break;
100270	case 216: /* expr ::= expr NOT NULL */
100271	{spanUnaryPostfix(&yygotominor.yy346,pParse,TK_NOTNULL,&yymsp[-2].minor.yy346,&yymsp[0].minor.yy0);}
100272	break;
100273	case 217: /* expr ::= expr IS expr */
100274	{
100275	spanBinaryExpr(&yygotominor.yy346,pParse,TK_IS,&yymsp[-2].minor.yy346,&yymsp[0].minor.yy346);
100276	binaryToUnaryIfNull(pParse, yymsp[0].minor.yy346.pExpr, yygotominor.yy346.pExpr, TK_ISNULL);
100277	}
100278	break;
100279	case 218: /* expr ::= expr IS NOT expr */
100280	{
100281	spanBinaryExpr(&yygotominor.yy346,pParse,TK_ISNOT,&yymsp[-3].minor.yy346,&yymsp[0].minor.yy346);
100282	binaryToUnaryIfNull(pParse, yymsp[0].minor.yy346.pExpr, yygotominor.yy346.pExpr, TK_NOTNULL);
100283	}
100284	break;
100285	case 219: /* expr ::= NOT expr */
100286	case 220: /* expr ::= BITNOT expr */ yytestcase(yyruleno==220);
100287	{spanUnaryPrefix(&yygotominor.yy346,pParse,yymsp[-1].major,&yymsp[0].minor.yy346,&yymsp[-1].minor.yy0);}
100288	break;
100289	case 221: /* expr ::= MINUS expr */
100290	{spanUnaryPrefix(&yygotominor.yy346,pParse,TK_UMINUS,&yymsp[0].minor.yy346,&yymsp[-1].minor.yy0);}
100291	break;
100292	case 222: /* expr ::= PLUS expr */
100293	{spanUnaryPrefix(&yygotominor.yy346,pParse,TK_UPLUS,&yymsp[0].minor.yy346,&yymsp[-1].minor.yy0);}
100294	break;
100295	case 225: /* expr ::= expr between_op expr AND expr */
100296	{
100297	ExprList *pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy346.pExpr);
100298	pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy346.pExpr);
100299	yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_BETWEEN, yymsp[-4].minor.yy346.pExpr, 0, 0);
100300	if( yygotominor.yy346.pExpr ){
100301	yygotominor.yy346.pExpr->x.pList = pList;
100302	}else{
100303	sqlite3ExprListDelete(pParse->db, pList);
100304	}
100305	if( yymsp[-3].minor.yy328 ) yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy346.pExpr, 0, 0);
100306	yygotominor.yy346.zStart = yymsp[-4].minor.yy346.zStart;
100307	yygotominor.yy346.zEnd = yymsp[0].minor.yy346.zEnd;
100308	}
100309	break;
100310	case 228: /* expr ::= expr in_op LP exprlist RP */
100311	{
100312	yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy346.pExpr, 0, 0);
100313	if( yygotominor.yy346.pExpr ){
100314	yygotominor.yy346.pExpr->x.pList = yymsp[-1].minor.yy14;
100315	sqlite3ExprSetHeight(pParse, yygotominor.yy346.pExpr);
100316	}else{
100317	sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy14);
100318	}
100319	if( yymsp[-3].minor.yy328 ) yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy346.pExpr, 0, 0);
100320	yygotominor.yy346.zStart = yymsp[-4].minor.yy346.zStart;
100321	yygotominor.yy346.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
100322	}
100323	break;
100324	case 229: /* expr ::= LP select RP */
100325	{
100326	yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_SELECT, 0, 0, 0);
100327	if( yygotominor.yy346.pExpr ){
100328	yygotominor.yy346.pExpr->x.pSelect = yymsp[-1].minor.yy3;
100329	ExprSetProperty(yygotominor.yy346.pExpr, EP_xIsSelect);
100330	sqlite3ExprSetHeight(pParse, yygotominor.yy346.pExpr);
100331	}else{
100332	sqlite3SelectDelete(pParse->db, yymsp[-1].minor.yy3);
100333	}
100334	yygotominor.yy346.zStart = yymsp[-2].minor.yy0.z;
100335	yygotominor.yy346.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
100336	}
100337	break;
100338	case 230: /* expr ::= expr in_op LP select RP */
100339	{
100340	yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy346.pExpr, 0, 0);
100341	if( yygotominor.yy346.pExpr ){
100342	yygotominor.yy346.pExpr->x.pSelect = yymsp[-1].minor.yy3;
100343	ExprSetProperty(yygotominor.yy346.pExpr, EP_xIsSelect);
100344	sqlite3ExprSetHeight(pParse, yygotominor.yy346.pExpr);
100345	}else{
100346	sqlite3SelectDelete(pParse->db, yymsp[-1].minor.yy3);
100347	}
100348	if( yymsp[-3].minor.yy328 ) yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy346.pExpr, 0, 0);
100349	yygotominor.yy346.zStart = yymsp[-4].minor.yy346.zStart;
100350	yygotominor.yy346.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
100351	}
100352	break;
100353	case 231: /* expr ::= expr in_op nm dbnm */













100354	{
100355	SrcList *pSrc = sqlite3SrcListAppend(pParse->db, 0,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0);
100356	yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_IN, yymsp[-3].minor.yy346.pExpr, 0, 0);
100357	if( yygotominor.yy346.pExpr ){
100358	yygotominor.yy346.pExpr->x.pSelect = sqlite3SelectNew(pParse, 0,pSrc,0,0,0,0,0,0,0);
100359	ExprSetProperty(yygotominor.yy346.pExpr, EP_xIsSelect);
100360	sqlite3ExprSetHeight(pParse, yygotominor.yy346.pExpr);
100361	}else{
100362	sqlite3SrcListDelete(pParse->db, pSrc);
100363	}
100364	if( yymsp[-2].minor.yy328 ) yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy346.pExpr, 0, 0);
100365	yygotominor.yy346.zStart = yymsp[-3].minor.yy346.zStart;
100366	yygotominor.yy346.zEnd = yymsp[0].minor.yy0.z ? &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n] : &yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n];
100367	}
100368	break;
100369	case 232: /* expr ::= EXISTS LP select RP */
100370	{
100371	Expr *p = yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_EXISTS, 0, 0, 0);
100372	if( p ){
100373	p->x.pSelect = yymsp[-1].minor.yy3;
100374	ExprSetProperty(p, EP_xIsSelect);
100375	sqlite3ExprSetHeight(pParse, p);
100376	}else{
100377	sqlite3SelectDelete(pParse->db, yymsp[-1].minor.yy3);
100378	}
100379	yygotominor.yy346.zStart = yymsp[-3].minor.yy0.z;
100380	yygotominor.yy346.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
100381	}
100382	break;
100383	case 233: /* expr ::= CASE case_operand case_exprlist case_else END */
100384	{
100385	yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_CASE, yymsp[-3].minor.yy132, yymsp[-1].minor.yy132, 0);
100386	if( yygotominor.yy346.pExpr ){
100387	yygotominor.yy346.pExpr->x.pList = yymsp[-2].minor.yy14;
100388	sqlite3ExprSetHeight(pParse, yygotominor.yy346.pExpr);
100389	}else{
100390	sqlite3ExprListDelete(pParse->db, yymsp[-2].minor.yy14);
100391	}
100392	yygotominor.yy346.zStart = yymsp[-4].minor.yy0.z;
100393	yygotominor.yy346.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
100394	}
100395	break;
100396	case 234: /* case_exprlist ::= case_exprlist WHEN expr THEN expr */
100397	{
100398	yygotominor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy14, yymsp[-2].minor.yy346.pExpr);
100399	yygotominor.yy14 = sqlite3ExprListAppend(pParse,yygotominor.yy14, yymsp[0].minor.yy346.pExpr);
100400	}
100401	break;
100402	case 235: /* case_exprlist ::= WHEN expr THEN expr */
100403	{
100404	yygotominor.yy14 = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy346.pExpr);
100405	yygotominor.yy14 = sqlite3ExprListAppend(pParse,yygotominor.yy14, yymsp[0].minor.yy346.pExpr);
100406	}
100407	break;
100408	case 244: /* cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP idxlist RP */
100409	{
100410	sqlite3CreateIndex(pParse, &yymsp[-6].minor.yy0, &yymsp[-5].minor.yy0,
100411	sqlite3SrcListAppend(pParse->db,0,&yymsp[-3].minor.yy0,0), yymsp[-1].minor.yy14, yymsp[-9].minor.yy328,
100412	&yymsp[-10].minor.yy0, &yymsp[0].minor.yy0, SQLITE_SO_ASC, yymsp[-7].minor.yy328);
100413	}
100414	break;
100415	case 245: /* uniqueflag ::= UNIQUE */
100416	case 299: /* raisetype ::= ABORT */ yytestcase(yyruleno==299);
100417	{yygotominor.yy328 = OE_Abort;}
100418	break;
100419	case 246: /* uniqueflag ::= */
100420	{yygotominor.yy328 = OE_None;}
100421	break;
100422	case 249: /* idxlist ::= idxlist COMMA nm collate sortorder */
100423	{
100424	Expr *p = 0;
100425	if( yymsp[-1].minor.yy0.n>0 ){
100426	p = sqlite3Expr(pParse->db, TK_COLUMN, 0);
100427	sqlite3ExprSetColl(pParse, p, &yymsp[-1].minor.yy0);
100428	}
100429	yygotominor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy14, p);
100430	sqlite3ExprListSetName(pParse,yygotominor.yy14,&yymsp[-2].minor.yy0,1);
100431	sqlite3ExprListCheckLength(pParse, yygotominor.yy14, "index");
100432	if( yygotominor.yy14 ) yygotominor.yy14->a[yygotominor.yy14->nExpr-1].sortOrder = (u8)yymsp[0].minor.yy328;
100433	}
100434	break;
100435	case 250: /* idxlist ::= nm collate sortorder */
100436	{
100437	Expr *p = 0;
100438	if( yymsp[-1].minor.yy0.n>0 ){
100439	p = sqlite3PExpr(pParse, TK_COLUMN, 0, 0, 0);
100440	sqlite3ExprSetColl(pParse, p, &yymsp[-1].minor.yy0);
100441	}
100442	yygotominor.yy14 = sqlite3ExprListAppend(pParse,0, p);
100443	sqlite3ExprListSetName(pParse, yygotominor.yy14, &yymsp[-2].minor.yy0, 1);
100444	sqlite3ExprListCheckLength(pParse, yygotominor.yy14, "index");
100445	if( yygotominor.yy14 ) yygotominor.yy14->a[yygotominor.yy14->nExpr-1].sortOrder = (u8)yymsp[0].minor.yy328;
100446	}
100447	break;
100448	case 251: /* collate ::= */
100449	{yygotominor.yy0.z = 0; yygotominor.yy0.n = 0;}
100450	break;
100451	case 253: /* cmd ::= DROP INDEX ifexists fullname */
100452	{sqlite3DropIndex(pParse, yymsp[0].minor.yy65, yymsp[-1].minor.yy328);}
100453	break;
100454	case 254: /* cmd ::= VACUUM */
100455	case 255: /* cmd ::= VACUUM nm */ yytestcase(yyruleno==255);
100456	{sqlite3Vacuum(pParse);}
100457	break;
100458	case 256: /* cmd ::= PRAGMA nm dbnm */
100459	{sqlite3Pragma(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,0,0);}
100460	break;
100461	case 257: /* cmd ::= PRAGMA nm dbnm EQ nmnum */
100462	{sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,0);}
100463	break;
100464	case 258: /* cmd ::= PRAGMA nm dbnm LP nmnum RP */
100465	{sqlite3Pragma(pParse,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,0);}
100466	break;
100467	case 259: /* cmd ::= PRAGMA nm dbnm EQ minus_num */
100468	{sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,1);}
100469	break;
100470	case 260: /* cmd ::= PRAGMA nm dbnm LP minus_num RP */
100471	{sqlite3Pragma(pParse,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,1);}
100472	break;
100473	case 271: /* cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
100474	{
100475	Token all;
100476	all.z = yymsp[-3].minor.yy0.z;
100477	all.n = (int)(yymsp[0].minor.yy0.z - yymsp[-3].minor.yy0.z) + yymsp[0].minor.yy0.n;
100478	sqlite3FinishTrigger(pParse, yymsp[-1].minor.yy473, &all);
100479	}
100480	break;
100481	case 272: /* trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
100482	{
100483	sqlite3BeginTrigger(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0, yymsp[-5].minor.yy328, yymsp[-4].minor.yy378.a, yymsp[-4].minor.yy378.b, yymsp[-2].minor.yy65, yymsp[0].minor.yy132, yymsp[-10].minor.yy328, yymsp[-8].minor.yy328);
100484	yygotominor.yy0 = (yymsp[-6].minor.yy0.n==0?yymsp[-7].minor.yy0:yymsp[-6].minor.yy0);
100485	}
100486	break;
100487	case 273: /* trigger_time ::= BEFORE */
100488	case 276: /* trigger_time ::= */ yytestcase(yyruleno==276);
100489	{ yygotominor.yy328 = TK_BEFORE; }
100490	break;
100491	case 274: /* trigger_time ::= AFTER */
100492	{ yygotominor.yy328 = TK_AFTER; }
100493	break;
100494	case 275: /* trigger_time ::= INSTEAD OF */
100495	{ yygotominor.yy328 = TK_INSTEAD;}
100496	break;
100497	case 277: /* trigger_event ::= DELETE\|INSERT */
100498	case 278: /* trigger_event ::= UPDATE */ yytestcase(yyruleno==278);
100499	{yygotominor.yy378.a = yymsp[0].major; yygotominor.yy378.b = 0;}
100500	break;
100501	case 279: /* trigger_event ::= UPDATE OF inscollist */
100502	{yygotominor.yy378.a = TK_UPDATE; yygotominor.yy378.b = yymsp[0].minor.yy408;}
100503	break;
100504	case 282: /* when_clause ::= */
100505	case 304: /* key_opt ::= */ yytestcase(yyruleno==304);
100506	{ yygotominor.yy132 = 0; }
100507	break;
100508	case 283: /* when_clause ::= WHEN expr */
100509	case 305: /* key_opt ::= KEY expr */ yytestcase(yyruleno==305);
100510	{ yygotominor.yy132 = yymsp[0].minor.yy346.pExpr; }
100511	break;
100512	case 284: /* trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
100513	{
100514	assert( yymsp[-2].minor.yy473!=0 );
100515	yymsp[-2].minor.yy473->pLast->pNext = yymsp[-1].minor.yy473;
100516	yymsp[-2].minor.yy473->pLast = yymsp[-1].minor.yy473;
100517	yygotominor.yy473 = yymsp[-2].minor.yy473;
100518	}
100519	break;
100520	case 285: /* trigger_cmd_list ::= trigger_cmd SEMI */
100521	{
100522	assert( yymsp[-1].minor.yy473!=0 );
100523	yymsp[-1].minor.yy473->pLast = yymsp[-1].minor.yy473;
100524	yygotominor.yy473 = yymsp[-1].minor.yy473;
100525	}
100526	break;
100527	case 287: /* trnm ::= nm DOT nm */
100528	{
100529	yygotominor.yy0 = yymsp[0].minor.yy0;
100530	sqlite3ErrorMsg(pParse,
100531	"qualified table names are not allowed on INSERT, UPDATE, and DELETE "
100532	"statements within triggers");
100533	}
100534	break;
100535	case 289: /* tridxby ::= INDEXED BY nm */
100536	{
100537	sqlite3ErrorMsg(pParse,
100538	"the INDEXED BY clause is not allowed on UPDATE or DELETE statements "
100539	"within triggers");
100540	}
100541	break;
100542	case 290: /* tridxby ::= NOT INDEXED */
100543	{
100544	sqlite3ErrorMsg(pParse,
100545	"the NOT INDEXED clause is not allowed on UPDATE or DELETE statements "
100546	"within triggers");
100547	}
100548	break;
100549	case 291: /* trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist where_opt */
100550	{ yygotominor.yy473 = sqlite3TriggerUpdateStep(pParse->db, &yymsp[-4].minor.yy0, yymsp[-1].minor.yy14, yymsp[0].minor.yy132, yymsp[-5].minor.yy186); }
100551	break;
100552	case 292: /* trigger_cmd ::= insert_cmd INTO trnm inscollist_opt VALUES LP itemlist RP */
100553	{yygotominor.yy473 = sqlite3TriggerInsertStep(pParse->db, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy408, yymsp[-1].minor.yy14, 0, yymsp[-7].minor.yy186);}
100554	break;
100555	case 293: /* trigger_cmd ::= insert_cmd INTO trnm inscollist_opt select */
100556	{yygotominor.yy473 = sqlite3TriggerInsertStep(pParse->db, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy408, 0, yymsp[0].minor.yy3, yymsp[-4].minor.yy186);}
100557	break;
100558	case 294: /* trigger_cmd ::= DELETE FROM trnm tridxby where_opt */
100559	{yygotominor.yy473 = sqlite3TriggerDeleteStep(pParse->db, &yymsp[-2].minor.yy0, yymsp[0].minor.yy132);}
100560	break;
100561	case 295: /* trigger_cmd ::= select */
100562	{yygotominor.yy473 = sqlite3TriggerSelectStep(pParse->db, yymsp[0].minor.yy3); }
100563	break;
100564	case 296: /* expr ::= RAISE LP IGNORE RP */
100565	{
100566	yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_RAISE, 0, 0, 0);
100567	if( yygotominor.yy346.pExpr ){
100568	yygotominor.yy346.pExpr->affinity = OE_Ignore;
100569	}
100570	yygotominor.yy346.zStart = yymsp[-3].minor.yy0.z;
100571	yygotominor.yy346.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
100572	}
100573	break;
100574	case 297: /* expr ::= RAISE LP raisetype COMMA nm RP */
100575	{
100576	yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_RAISE, 0, 0, &yymsp[-1].minor.yy0);
100577	if( yygotominor.yy346.pExpr ) {
100578	yygotominor.yy346.pExpr->affinity = (char)yymsp[-3].minor.yy328;
100579	}
100580	yygotominor.yy346.zStart = yymsp[-5].minor.yy0.z;
100581	yygotominor.yy346.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
100582	}
100583	break;
100584	case 298: /* raisetype ::= ROLLBACK */
100585	{yygotominor.yy328 = OE_Rollback;}
100586	break;
100587	case 300: /* raisetype ::= FAIL */
100588	{yygotominor.yy328 = OE_Fail;}
100589	break;
100590	case 301: /* cmd ::= DROP TRIGGER ifexists fullname */
100591	{
100592	sqlite3DropTrigger(pParse,yymsp[0].minor.yy65,yymsp[-1].minor.yy328);
100593	}
100594	break;
100595	case 302: /* cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
100596	{
100597	sqlite3Attach(pParse, yymsp[-3].minor.yy346.pExpr, yymsp[-1].minor.yy346.pExpr, yymsp[0].minor.yy132);
100598	}
100599	break;
100600	case 303: /* cmd ::= DETACH database_kw_opt expr */
100601	{
100602	sqlite3Detach(pParse, yymsp[0].minor.yy346.pExpr);
100603	}
100604	break;
100605	case 308: /* cmd ::= REINDEX */
100606	{sqlite3Reindex(pParse, 0, 0);}
100607	break;
100608	case 309: /* cmd ::= REINDEX nm dbnm */
100609	{sqlite3Reindex(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);}
100610	break;
100611	case 310: /* cmd ::= ANALYZE */
100612	{sqlite3Analyze(pParse, 0, 0);}
100613	break;
100614	case 311: /* cmd ::= ANALYZE nm dbnm */
100615	{sqlite3Analyze(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);}
100616	break;
100617	case 312: /* cmd ::= ALTER TABLE fullname RENAME TO nm */
100618	{
100619	sqlite3AlterRenameTable(pParse,yymsp[-3].minor.yy65,&yymsp[0].minor.yy0);
100620	}
100621	break;
100622	case 313: /* cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt column */
100623	{
100624	sqlite3AlterFinishAddColumn(pParse, &yymsp[0].minor.yy0);
100625	}
100626	break;
100627	case 314: /* add_column_fullname ::= fullname */
100628	{
100629	pParse->db->lookaside.bEnabled = 0;
100630	sqlite3AlterBeginAddColumn(pParse, yymsp[0].minor.yy65);
100631	}
100632	break;
100633	case 317: /* cmd ::= create_vtab */
100634	{sqlite3VtabFinishParse(pParse,0);}
100635	break;
100636	case 318: /* cmd ::= create_vtab LP vtabarglist RP */
100637	{sqlite3VtabFinishParse(pParse,&yymsp[0].minor.yy0);}
100638	break;
100639	case 319: /* create_vtab ::= createkw VIRTUAL TABLE nm dbnm USING nm */
100640	{
100641	sqlite3VtabBeginParse(pParse, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
100642	}
100643	break;
100644	case 322: /* vtabarg ::= */
100645	{sqlite3VtabArgInit(pParse);}
100646	break;
100647	case 324: /* vtabargtoken ::= ANY */
100648	case 325: /* vtabargtoken ::= lp anylist RP */ yytestcase(yyruleno==325);
100649	case 326: /* lp ::= LP */ yytestcase(yyruleno==326);
100650	{sqlite3VtabArgExtend(pParse,&yymsp[0].minor.yy0);}
100651	break;
100652	default:
100653	/* (0) input ::= cmdlist */ yytestcase(yyruleno==0);
100654	/* (1) cmdlist ::= cmdlist ecmd */ yytestcase(yyruleno==1);
	@@ -100673,25 +100915,25 @@
100673	/* (62) ccons ::= NULL onconf */ yytestcase(yyruleno==62);
100674	/* (90) conslist ::= conslist COMMA tcons */ yytestcase(yyruleno==90);
100675	/* (91) conslist ::= conslist tcons */ yytestcase(yyruleno==91);
100676	/* (92) conslist ::= tcons */ yytestcase(yyruleno==92);
100677	/* (93) tcons ::= CONSTRAINT nm */ yytestcase(yyruleno==93);
100678	/* (269) plus_opt ::= PLUS */ yytestcase(yyruleno==269);
100679	/* (270) plus_opt ::= */ yytestcase(yyruleno==270);
100680	/* (280) foreach_clause ::= */ yytestcase(yyruleno==280);
100681	/* (281) foreach_clause ::= FOR EACH ROW */ yytestcase(yyruleno==281);
100682	/* (288) tridxby ::= */ yytestcase(yyruleno==288);
100683	/* (306) database_kw_opt ::= DATABASE */ yytestcase(yyruleno==306);
100684	/* (307) database_kw_opt ::= */ yytestcase(yyruleno==307);
100685	/* (315) kwcolumn_opt ::= */ yytestcase(yyruleno==315);
100686	/* (316) kwcolumn_opt ::= COLUMNKW */ yytestcase(yyruleno==316);
100687	/* (320) vtabarglist ::= vtabarg */ yytestcase(yyruleno==320);
100688	/* (321) vtabarglist ::= vtabarglist COMMA vtabarg */ yytestcase(yyruleno==321);
100689	/* (323) vtabarg ::= vtabarg vtabargtoken */ yytestcase(yyruleno==323);
100690	/* (327) anylist ::= */ yytestcase(yyruleno==327);
100691	/* (328) anylist ::= anylist LP anylist RP */ yytestcase(yyruleno==328);
100692	/* (329) anylist ::= anylist ANY */ yytestcase(yyruleno==329);
100693	break;
100694	};
100695	yygoto = yyRuleInfo[yyruleno].lhs;
100696	yysize = yyRuleInfo[yyruleno].nrhs;
100697	yypParser->yyidx -= yysize;
	@@ -107179,13 +107421,61 @@
107179	** argument to sqlite3Fts3SegReaderIterate()
107180	*/
107181	typedef struct TermSelect TermSelect;
107182	struct TermSelect {
107183	int isReqPos;
107184	char aOutput; / Malloc'd output buffer */
107185	int nOutput; /* Size of output in bytes */
107186	};
















































107187
107188	/*
107189	** This function is used as the sqlite3Fts3SegReaderIterate() callback when
107190	** querying the full-text index for a doclist associated with a term or
107191	** term-prefix.
	@@ -107197,42 +107487,67 @@
107197	int nTerm,
107198	char *aDoclist,
107199	int nDoclist
107200	){
107201	TermSelect pTS = (TermSelect )pContext;
107202	int nNew = pTS->nOutput + nDoclist;
107203	char *aNew = sqlite3_malloc(nNew);
107204
107205	UNUSED_PARAMETER(p);
107206	UNUSED_PARAMETER(zTerm);
107207	UNUSED_PARAMETER(nTerm);
107208
107209	if( !aNew ){
107210	return SQLITE_NOMEM;
107211	}
107212
107213	if( pTS->nOutput==0 ){
107214	/* If this is the first term selected, copy the doclist to the output
107215	** buffer using memcpy(). TODO: Add a way to transfer control of the
107216	** aDoclist buffer from the caller so as to avoid the memcpy().
107217	*/
107218	memcpy(aNew, aDoclist, nDoclist);






107219	}else{
107220	/* The output buffer is not empty. Merge doclist aDoclist with the
107221	** existing output. This can only happen with prefix-searches (as
107222	** searches for exact terms return exactly one doclist).
107223	*/
107224	int mergetype = (pTS->isReqPos ? MERGE_POS_OR : MERGE_OR);
107225	fts3DoclistMerge(mergetype, 0, 0,
107226	aNew, &nNew, pTS->aOutput, pTS->nOutput, aDoclist, nDoclist
107227	);
107228	}
107229
107230	sqlite3_free(pTS->aOutput);
107231	pTS->aOutput = aNew;
107232	pTS->nOutput = nNew;
107233





























107234	return SQLITE_OK;
107235	}
107236
107237	/*
107238	** This function retreives the doclist for the specified term (or term
	@@ -107352,16 +107667,21 @@
107352	filter.nTerm = nTerm;
107353
107354	rc = sqlite3Fts3SegReaderIterate(p, apSegment, nSegment, &filter,
107355	fts3TermSelectCb, (void *)&tsc
107356	);



107357
107358	if( rc==SQLITE_OK ){
107359	*ppOut = tsc.aOutput;
107360	*pnOut = tsc.nOutput;
107361	}else{
107362	sqlite3_free(tsc.aOutput);


107363	}
107364
107365	finished:
107366	sqlite3_reset(pStmt);
107367	for(i=0; i<nSegment; i++){
107368

	--- src/sqlite3.c
	+++ src/sqlite3.c
	@@ -514,11 +514,11 @@
514	/*
515	** Return true (non-zero) if the input is a integer that is too large
516	** to fit in 32-bits. This macro is used inside of various testcase()
517	** macros to verify that we have tested SQLite for large-file support.
518	*/
519	#define IS_BIG_INT(X) (((X)&~(i64)0xffffffff)!=0)
520
521	/*
522	** The macro unlikely() is a hint that surrounds a boolean
523	** expression that is usually false. Macro likely() surrounds
524	** a boolean expression that is usually true. GCC is able to
	@@ -643,11 +643,11 @@
643	** [sqlite3_libversion_number()], [sqlite3_sourceid()],
644	** [sqlite_version()] and [sqlite_source_id()].
645	*/
646	#define SQLITE_VERSION "3.7.0"
647	#define SQLITE_VERSION_NUMBER 3007000
648	#define SQLITE_SOURCE_ID "2010-07-21 16:16:28 b36b105eab6fd3195f4bfba6cb5cda0f063b7460"
649
650	/*
651	** CAPI3REF: Run-Time Library Version Numbers
652	** KEYWORDS: sqlite3_version, sqlite3_sourceid
653	**
	@@ -1015,15 +1015,16 @@
1015	#define SQLITE_OPEN_MASTER_JOURNAL 0x00004000 /* VFS only */
1016	#define SQLITE_OPEN_NOMUTEX 0x00008000 /* Ok for sqlite3_open_v2() */
1017	#define SQLITE_OPEN_FULLMUTEX 0x00010000 /* Ok for sqlite3_open_v2() */
1018	#define SQLITE_OPEN_SHAREDCACHE 0x00020000 /* Ok for sqlite3_open_v2() */
1019	#define SQLITE_OPEN_PRIVATECACHE 0x00040000 /* Ok for sqlite3_open_v2() */
1020	#define SQLITE_OPEN_WAL 0x00080000 /* VFS only */
1021
1022	/*
1023	** CAPI3REF: Device Characteristics
1024	**
1025	** The xDeviceCharacteristics method of the [sqlite3_io_methods]
1026	** object returns an integer which is a vector of the these
1027	** bit values expressing I/O characteristics of the mass storage
1028	** device that holds the file that the [sqlite3_io_methods]
1029	** refers to.
1030	**
	@@ -1199,15 +1200,14 @@
1200	int (xCheckReservedLock)(sqlite3_file, int *pResOut);
1201	int (xFileControl)(sqlite3_file, int op, void *pArg);
1202	int (xSectorSize)(sqlite3_file);
1203	int (xDeviceCharacteristics)(sqlite3_file);
1204	/* Methods above are valid for version 1 */
1205	int (xShmMap)(sqlite3_file, int iPg, int pgsz, int, void volatile**);
1206	int (xShmLock)(sqlite3_file, int offset, int n, int flags);

1207	void (xShmBarrier)(sqlite3_file);
1208	int (xShmUnmap)(sqlite3_file, int deleteFlag);
1209	/* Methods above are valid for version 2 */
1210	/* Additional methods may be added in future releases */
1211	};
1212
1213	/*
	@@ -1426,17 +1426,24 @@
1426	** the xAccess method of an [sqlite3_vfs] object. They determine
1427	** what kind of permissions the xAccess method is looking for.
1428	** With SQLITE_ACCESS_EXISTS, the xAccess method
1429	** simply checks whether the file exists.
1430	** With SQLITE_ACCESS_READWRITE, the xAccess method
1431	** checks whether the named directory is both readable and writable
1432	** (in other words, if files can be added, removed, and renamed within
1433	** the directory).
1434	** The SQLITE_ACCESS_READWRITE constant is currently used only by the
1435	** [temp_store_directory pragma], though this could change in a future
1436	** release of SQLite.
1437	** With SQLITE_ACCESS_READ, the xAccess method
1438	** checks whether the file is readable. The SQLITE_ACCESS_READ constant is
1439	** currently unused, though it might be used in a future release of
1440	** SQLite.
1441	*/
1442	#define SQLITE_ACCESS_EXISTS 0
1443	#define SQLITE_ACCESS_READWRITE 1 /* Used by PRAGMA temp_store_directory */
1444	#define SQLITE_ACCESS_READ 2 /* Unused */
1445
1446	/*
1447	** CAPI3REF: Flags for the xShmLock VFS method
1448	**
1449	** These integer constants define the various locking operations
	@@ -5767,11 +5774,11 @@
5774	**
5775	** <dt>SQLITE_DBSTATUS_CACHE_USED</dt>
5776	** <dd>^This parameter returns the approximate number of of bytes of heap
5777	** memory used by all pager caches associated with the database connection.
5778	** ^The highwater mark associated with SQLITE_DBSTATUS_CACHE_USED is always 0.
5779	** </dd>
5780	** </dl>
5781	*/
5782	#define SQLITE_DBSTATUS_LOOKASIDE_USED 0
5783	#define SQLITE_DBSTATUS_CACHE_USED 1
5784	#define SQLITE_DBSTATUS_MAX 1 /* Largest defined DBSTATUS */
	@@ -8307,15 +8314,14 @@
8314	SQLITE_PRIVATE int sqlite3OsCheckReservedLock(sqlite3_file id, int pResOut);
8315	SQLITE_PRIVATE int sqlite3OsFileControl(sqlite3_file,int,void);
8316	#define SQLITE_FCNTL_DB_UNCHANGED 0xca093fa0
8317	SQLITE_PRIVATE int sqlite3OsSectorSize(sqlite3_file *id);
8318	SQLITE_PRIVATE int sqlite3OsDeviceCharacteristics(sqlite3_file *id);
8319	SQLITE_PRIVATE int sqlite3OsShmMap(sqlite3_file ,int,int,int,void volatile *);
8320	SQLITE_PRIVATE int sqlite3OsShmLock(sqlite3_file *id, int, int, int);
8321	SQLITE_PRIVATE void sqlite3OsShmBarrier(sqlite3_file *id);
8322	SQLITE_PRIVATE int sqlite3OsShmUnmap(sqlite3_file *id, int);

8323
8324	/*
8325	** Functions for accessing sqlite3_vfs methods
8326	*/
8327	SQLITE_PRIVATE int sqlite3OsOpen(sqlite3_vfs , const char , sqlite3_file, int, int );
	@@ -10665,10 +10671,11 @@
10671	SQLITE_PRIVATE void sqlite3ValueApplyAffinity(sqlite3_value *, u8, u8);
10672	#ifndef SQLITE_AMALGAMATION
10673	SQLITE_PRIVATE const unsigned char sqlite3OpcodeProperty[];
10674	SQLITE_PRIVATE const unsigned char sqlite3UpperToLower[];
10675	SQLITE_PRIVATE const unsigned char sqlite3CtypeMap[];
10676	SQLITE_PRIVATE const Token sqlite3IntTokens[];
10677	SQLITE_PRIVATE SQLITE_WSD struct Sqlite3Config sqlite3Config;
10678	SQLITE_PRIVATE SQLITE_WSD FuncDefHash sqlite3GlobalFunctions;
10679	#ifndef SQLITE_OMIT_WSD
10680	SQLITE_PRIVATE int sqlite3PendingByte;
10681	#endif
	@@ -11110,10 +11117,19 @@
11117	** Hash table for global functions - functions common to all
11118	** database connections. After initialization, this table is
11119	** read-only.
11120	*/
11121	SQLITE_PRIVATE SQLITE_WSD FuncDefHash sqlite3GlobalFunctions;
11122
11123	/*
11124	** Constant tokens for values 0 and 1.
11125	*/
11126	SQLITE_PRIVATE const Token sqlite3IntTokens[] = {
11127	{ "0", 1 },
11128	{ "1", 1 }
11129	};
11130
11131
11132	/*
11133	** The value of the "pending" byte must be 0x40000000 (1 byte past the
11134	** 1-gibabyte boundary) in a compatible database. SQLite never uses
11135	** the database page that contains the pending byte. It never attempts
	@@ -12875,30 +12891,27 @@
12891	return (xSectorSize ? xSectorSize(id) : SQLITE_DEFAULT_SECTOR_SIZE);
12892	}
12893	SQLITE_PRIVATE int sqlite3OsDeviceCharacteristics(sqlite3_file *id){
12894	return id->pMethods->xDeviceCharacteristics(id);
12895	}



12896	SQLITE_PRIVATE int sqlite3OsShmLock(sqlite3_file *id, int offset, int n, int flags){
12897	return id->pMethods->xShmLock(id, offset, n, flags);
12898	}
12899	SQLITE_PRIVATE void sqlite3OsShmBarrier(sqlite3_file *id){
12900	id->pMethods->xShmBarrier(id);
12901	}
12902	SQLITE_PRIVATE int sqlite3OsShmUnmap(sqlite3_file *id, int deleteFlag){
12903	return id->pMethods->xShmUnmap(id, deleteFlag);
12904	}
12905	SQLITE_PRIVATE int sqlite3OsShmMap(
12906	sqlite3_file id, / Database file handle */
12907	int iPage,
12908	int pgsz,
12909	int bExtend, /* True to extend file if necessary */
12910	void volatile *pp / OUT: Pointer to mapping */
12911	){
12912	return id->pMethods->xShmMap(id, iPage, pgsz, bExtend, pp);
12913	}
12914
12915	/*
12916	** The next group of routines are convenience wrappers around the
12917	** VFS methods.
	@@ -12910,15 +12923,15 @@
12923	int flags,
12924	int *pFlagsOut
12925	){
12926	int rc;
12927	DO_OS_MALLOC_TEST(0);
12928	/* 0x87f3f is a mask of SQLITE_OPEN_ flags that are valid to be passed
12929	** down into the VFS layer. Some SQLITE_OPEN_ flags (for example,
12930	** SQLITE_OPEN_FULLMUTEX or SQLITE_OPEN_SHAREDCACHE) are blocked before
12931	** reaching the VFS. */
12932	rc = pVfs->xOpen(pVfs, zPath, pFile, flags & 0x87f3f, pFlagsOut);
12933	assert( rc==SQLITE_OK \|\| pFile->pMethods==0 );
12934	return rc;
12935	}
12936	SQLITE_PRIVATE int sqlite3OsDelete(sqlite3_vfs pVfs, const char zPath, int dirSync){
12937	return pVfs->xDelete(pVfs, zPath, dirSync);
	@@ -25708,74 +25721,100 @@
25721	sqlite3_free(p);
25722	}
25723	}
25724
25725	/*
25726	** Open a shared-memory area associated with open database file pDbFd.
25727	** This particular implementation uses mmapped files.
25728	**
25729	** The file used to implement shared-memory is in the same directory
25730	** as the open database file and has the same name as the open database
25731	** file with the "-shm" suffix added. For example, if the database file
25732	** is "/home/user1/config.db" then the file that is created and mmapped
25733	** for shared memory will be called "/home/user1/config.db-shm".
25734	**
25735	** Another approach to is to use files in /dev/shm or /dev/tmp or an
25736	** some other tmpfs mount. But if a file in a different directory
25737	** from the database file is used, then differing access permissions
25738	** or a chroot() might cause two different processes on the same
25739	** database to end up using different files for shared memory -
25740	** meaning that their memory would not really be shared - resulting
25741	** in database corruption. Nevertheless, this tmpfs file usage
25742	** can be enabled at compile-time using -DSQLITE_SHM_DIRECTORY="/dev/shm"
25743	** or the equivalent. The use of the SQLITE_SHM_DIRECTORY compile-time
25744	** option results in an incompatible build of SQLite; builds of SQLite
25745	** that with differing SQLITE_SHM_DIRECTORY settings attempt to use the
25746	** same database file at the same time, database corruption will likely
25747	** result. The SQLITE_SHM_DIRECTORY compile-time option is considered
25748	** "unsupported" and may go away in a future SQLite release.
25749	**
25750	** When opening a new shared-memory file, if no other instances of that
25751	** file are currently open, in this process or in other processes, then
25752	** the file must be truncated to zero length or have its header cleared.
25753	*/
25754	static int unixOpenSharedMemory(unixFile *pDbFd){
25755	struct unixShm p = 0; / The connection to be opened */
25756	struct unixShmNode pShmNode; / The underlying mmapped file */
25757	int rc; /* Result code */
25758	unixInodeInfo pInode; / The inode of fd */
25759	char zShmFilename; / Name of the file used for SHM */
25760	int nShmFilename; /* Size of the SHM filename in bytes */
25761
25762	/* Allocate space for the new unixShm object. */




25763	p = sqlite3_malloc( sizeof(*p) );
25764	if( p==0 ) return SQLITE_NOMEM;
25765	memset(p, 0, sizeof(*p));

25766	assert( pDbFd->pShm==0 );
25767
25768	/* Check to see if a unixShmNode object already exists. Reuse an existing
25769	** one if present. Create a new one if necessary.
25770	*/
25771	unixEnterMutex();
25772	pInode = pDbFd->pInode;
25773	pShmNode = pInode->pShmNode;
25774	if( pShmNode==0 ){
25775	struct stat sStat; /* fstat() info for database file */
25776
25777	/* Call fstat() to figure out the permissions on the database file. If
25778	** a new *-shm file is created, an attempt will be made to create it
25779	** with the same permissions. The actual permissions the file is created
25780	** with are subject to the current umask setting.
25781	*/
25782	if( fstat(pDbFd->h, &sStat) ){
25783	rc = SQLITE_IOERR_FSTAT;
25784	goto shm_open_err;
25785	}
25786
25787	#ifdef SQLITE_SHM_DIRECTORY
25788	nShmFilename = sizeof(SQLITE_SHM_DIRECTORY) + 30;
25789	#else
25790	nShmFilename = 5 + (int)strlen(pDbFd->zPath);
25791	#endif
25792	pShmNode = sqlite3_malloc( sizeof(*pShmNode) + nShmFilename );
25793	if( pShmNode==0 ){
25794	rc = SQLITE_NOMEM;
25795	goto shm_open_err;
25796	}
25797	memset(pShmNode, 0, sizeof(*pShmNode));
25798	zShmFilename = pShmNode->zFilename = (char*)&pShmNode[1];
25799	#ifdef SQLITE_SHM_DIRECTORY
25800	sqlite3_snprintf(nShmFilename, zShmFilename,
25801	SQLITE_SHM_DIRECTORY "/sqlite-shm-%x-%x",
25802	(u32)sStat.st_ino, (u32)sStat.st_dev);
25803	#else
25804	sqlite3_snprintf(nShmFilename, zShmFilename, "%s-shm", pDbFd->zPath);
25805	#endif
25806	pShmNode->h = -1;
25807	pDbFd->pInode->pShmNode = pShmNode;
25808	pShmNode->pInode = pDbFd->pInode;
25809	pShmNode->mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST);
25810	if( pShmNode->mutex==0 ){
25811	rc = SQLITE_NOMEM;
25812	goto shm_open_err;
25813	}
25814
25815	pShmNode->h = open(zShmFilename, O_RDWR\|O_CREAT, (sStat.st_mode & 0777));
25816	if( pShmNode->h<0 ){
25817	rc = SQLITE_CANTOPEN_BKPT;
25818	goto shm_open_err;
25819	}
25820
	@@ -25794,18 +25833,28 @@
25833	if( rc ) goto shm_open_err;
25834	}
25835
25836	/* Make the new connection a child of the unixShmNode */
25837	p->pShmNode = pShmNode;

25838	#ifdef SQLITE_DEBUG
25839	p->id = pShmNode->nextShmId++;
25840	#endif

25841	pShmNode->nRef++;
25842	pDbFd->pShm = p;
25843	unixLeaveMutex();
25844
25845	/* The reference count on pShmNode has already been incremented under
25846	** the cover of the unixEnterMutex() mutex and the pointer from the
25847	** new (struct unixShm) object to the pShmNode has been set. All that is
25848	** left to do is to link the new object into the linked list starting
25849	** at pShmNode->pFirst. This must be done while holding the pShmNode->mutex
25850	** mutex.
25851	*/
25852	sqlite3_mutex_enter(pShmNode->mutex);
25853	p->pNext = pShmNode->pFirst;
25854	pShmNode->pFirst = p;
25855	sqlite3_mutex_leave(pShmNode->mutex);
25856	return SQLITE_OK;
25857
25858	/* Jump here on any error */
25859	shm_open_err:
25860	unixShmPurge(pDbFd); /* This call frees pShmNode if required */
	@@ -25813,53 +25862,111 @@
25862	unixLeaveMutex();
25863	return rc;
25864	}
25865
25866	/*
25867	** This function is called to obtain a pointer to region iRegion of the
25868	** shared-memory associated with the database file fd. Shared-memory regions
25869	** are numbered starting from zero. Each shared-memory region is szRegion
25870	** bytes in size.
25871	**
25872	** If an error occurs, an error code is returned and *pp is set to NULL.
25873	**
25874	** Otherwise, if the bExtend parameter is 0 and the requested shared-memory
25875	** region has not been allocated (by any client, including one running in a
25876	** separate process), then *pp is set to NULL and SQLITE_OK returned. If
25877	** bExtend is non-zero and the requested shared-memory region has not yet
25878	** been allocated, it is allocated by this function.
25879	**
25880	** If the shared-memory region has already been allocated or is allocated by
25881	** this call as described above, then it is mapped into this processes
25882	** address space (if it is not already), *pp is set to point to the mapped
25883	** memory and SQLITE_OK returned.
25884	*/
25885	static int unixShmMap(
25886	sqlite3_file fd, / Handle open on database file */
25887	int iRegion, /* Region to retrieve */
25888	int szRegion, /* Size of regions */
25889	int bExtend, /* True to extend file if necessary */
25890	void volatile *pp / OUT: Mapped memory */
25891	){
25892	unixFile pDbFd = (unixFile)fd;
25893	unixShm *p;
25894	unixShmNode *pShmNode;
25895	int rc = SQLITE_OK;
25896
25897	/* If the shared-memory file has not yet been opened, open it now. */
25898	if( pDbFd->pShm==0 ){
25899	rc = unixOpenSharedMemory(pDbFd);
25900	if( rc!=SQLITE_OK ) return rc;
25901	}
25902
25903	p = pDbFd->pShm;
25904	pShmNode = p->pShmNode;






25905	sqlite3_mutex_enter(pShmNode->mutex);
25906	assert( szRegion==pShmNode->szRegion \|\| pShmNode->nRegion==0 );

25907
25908	if( pShmNode->nRegion<=iRegion ){
25909	char *apNew; / New apRegion[] array */
25910	int nByte = (iRegion+1)szRegion; / Minimum required file size */
25911	struct stat sStat; /* Used by fstat() */
25912
25913	pShmNode->szRegion = szRegion;
25914
25915	/* The requested region is not mapped into this processes address space.
25916	** Check to see if it has been allocated (i.e. if the wal-index file is
25917	** large enough to contain the requested region).
25918	*/
25919	if( fstat(pShmNode->h, &sStat) ){
25920	rc = SQLITE_IOERR_SHMSIZE;
25921	goto shmpage_out;
25922	}
25923
25924	if( sStat.st_size<nByte ){
25925	/* The requested memory region does not exist. If bExtend is set to
25926	** false, exit early. *pp will be set to NULL and SQLITE_OK returned.
25927	**
25928	** Alternatively, if bExtend is true, use ftruncate() to allocate
25929	** the requested memory region.
25930	*/
25931	if( !bExtend ) goto shmpage_out;
25932	if( ftruncate(pShmNode->h, nByte) ){
25933	rc = SQLITE_IOERR_SHMSIZE;
25934	goto shmpage_out;
25935	}
25936	}
25937
25938	/* Map the requested memory region into this processes address space. */
25939	apNew = (char **)sqlite3_realloc(
25940	pShmNode->apRegion, (iRegion+1)sizeof(char )
25941	);
25942	if( !apNew ){
25943	rc = SQLITE_IOERR_NOMEM;
25944	goto shmpage_out;
25945	}
25946	pShmNode->apRegion = apNew;
25947	while(pShmNode->nRegion<=iRegion){
25948	void *pMem = mmap(0, szRegion, PROT_READ\|PROT_WRITE,
25949	MAP_SHARED, pShmNode->h, iRegion*szRegion
25950	);
25951	if( pMem==MAP_FAILED ){
25952	rc = SQLITE_IOERR;
25953	goto shmpage_out;
25954	}
25955	pShmNode->apRegion[pShmNode->nRegion] = pMem;
25956	pShmNode->nRegion++;
25957	}
25958	}
25959
25960	shmpage_out:
25961	if( pShmNode->nRegion>iRegion ){
25962	*pp = pShmNode->apRegion[iRegion];
25963	}else{
25964	*pp = 0;
25965	}
25966	sqlite3_mutex_leave(pShmNode->mutex);
25967	return rc;












25968	}
25969
25970	/*
25971	** Change the lock state for a shared-memory segment.
25972	**
	@@ -25985,111 +26092,64 @@
26092	unixEnterMutex();
26093	unixLeaveMutex();
26094	}
26095
26096	/*
26097	** Close a connection to shared-memory. Delete the underlying
26098	** storage if deleteFlag is true.
26099	**
26100	** If there is no shared memory associated with the connection then this
26101	** routine is a harmless no-op.
26102	*/
26103	static int unixShmUnmap(
26104	sqlite3_file fd, / The underlying database file */
26105	int deleteFlag /* Delete shared-memory if true */
26106	){
26107	unixShm p; / The connection to be closed */
26108	unixShmNode pShmNode; / The underlying shared-memory file */
26109	unixShm *pp; / For looping over sibling connections */
26110	unixFile pDbFd; / The underlying database file */
26111
26112	pDbFd = (unixFile*)fd;
26113	p = pDbFd->pShm;
26114	if( p==0 ) return SQLITE_OK;
26115	pShmNode = p->pShmNode;
26116
26117	assert( pShmNode==pDbFd->pInode->pShmNode );
26118	assert( pShmNode->pInode==pDbFd->pInode );
26119
26120	/* Remove connection p from the set of connections associated
26121	** with pShmNode */





26122	sqlite3_mutex_enter(pShmNode->mutex);
26123	for(pp=&pShmNode->pFirst; (pp)!=p; pp = &(pp)->pNext){}
26124	*pp = p->pNext;
26125
26126	/* Free the connection p */
26127	sqlite3_free(p);
26128	pDbFd->pShm = 0;






















































26129	sqlite3_mutex_leave(pShmNode->mutex);
26130
26131	/* If pShmNode->nRef has reached 0, then close the underlying
26132	** shared-memory file, too */
26133	unixEnterMutex();
26134	assert( pShmNode->nRef>0 );
26135	pShmNode->nRef--;
26136	if( pShmNode->nRef==0 ){
26137	if( deleteFlag ) unlink(pShmNode->zFilename);
26138	unixShmPurge(pDbFd);
26139	}
26140	unixLeaveMutex();
26141
26142	return SQLITE_OK;
26143	}
26144
26145
26146	#else
26147	# define unixShmMap 0
26148	# define unixShmLock 0

26149	# define unixShmBarrier 0
26150	# define unixShmUnmap 0
26151	#endif /* #ifndef SQLITE_OMIT_WAL */
26152
26153	/*
26154	** Here ends the implementation of all sqlite3_file methods.
26155	**
	@@ -26143,15 +26203,14 @@
26203	UNLOCK, /* xUnlock */ \
26204	CKLOCK, /* xCheckReservedLock */ \
26205	unixFileControl, /* xFileControl */ \
26206	unixSectorSize, /* xSectorSize */ \
26207	unixDeviceCharacteristics, /* xDeviceCapabilities */ \
26208	unixShmMap, /* xShmMap */ \
26209	unixShmLock, /* xShmLock */ \

26210	unixShmBarrier, /* xShmBarrier */ \
26211	unixShmUnmap /* xShmUnmap */ \
26212	}; \
26213	static const sqlite3_io_methods FINDER##Impl(const char z, unixFile *p){ \
26214	UNUSED_PARAMETER(z); UNUSED_PARAMETER(p); \
26215	return &METHOD; \
26216	} \
	@@ -26164,29 +26223,29 @@
26223	** are also created.
26224	*/
26225	IOMETHODS(
26226	posixIoFinder, /* Finder function name */
26227	posixIoMethods, /* sqlite3_io_methods object name */
26228	2, /* shared memory is enabled */
26229	unixClose, /* xClose method */
26230	unixLock, /* xLock method */
26231	unixUnlock, /* xUnlock method */
26232	unixCheckReservedLock /* xCheckReservedLock method */
26233	)
26234	IOMETHODS(
26235	nolockIoFinder, /* Finder function name */
26236	nolockIoMethods, /* sqlite3_io_methods object name */
26237	1, /* shared memory is disabled */
26238	nolockClose, /* xClose method */
26239	nolockLock, /* xLock method */
26240	nolockUnlock, /* xUnlock method */
26241	nolockCheckReservedLock /* xCheckReservedLock method */
26242	)
26243	IOMETHODS(
26244	dotlockIoFinder, /* Finder function name */
26245	dotlockIoMethods, /* sqlite3_io_methods object name */
26246	1, /* shared memory is disabled */
26247	dotlockClose, /* xClose method */
26248	dotlockLock, /* xLock method */
26249	dotlockUnlock, /* xUnlock method */
26250	dotlockCheckReservedLock /* xCheckReservedLock method */
26251	)
	@@ -26193,11 +26252,11 @@
26252
26253	#if SQLITE_ENABLE_LOCKING_STYLE && !OS_VXWORKS
26254	IOMETHODS(
26255	flockIoFinder, /* Finder function name */
26256	flockIoMethods, /* sqlite3_io_methods object name */
26257	1, /* shared memory is disabled */
26258	flockClose, /* xClose method */
26259	flockLock, /* xLock method */
26260	flockUnlock, /* xUnlock method */
26261	flockCheckReservedLock /* xCheckReservedLock method */
26262	)
	@@ -26205,11 +26264,11 @@
26264
26265	#if OS_VXWORKS
26266	IOMETHODS(
26267	semIoFinder, /* Finder function name */
26268	semIoMethods, /* sqlite3_io_methods object name */
26269	1, /* shared memory is disabled */
26270	semClose, /* xClose method */
26271	semLock, /* xLock method */
26272	semUnlock, /* xUnlock method */
26273	semCheckReservedLock /* xCheckReservedLock method */
26274	)
	@@ -26217,11 +26276,11 @@
26276
26277	#if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE
26278	IOMETHODS(
26279	afpIoFinder, /* Finder function name */
26280	afpIoMethods, /* sqlite3_io_methods object name */
26281	1, /* shared memory is disabled */
26282	afpClose, /* xClose method */
26283	afpLock, /* xLock method */
26284	afpUnlock, /* xUnlock method */
26285	afpCheckReservedLock /* xCheckReservedLock method */
26286	)
	@@ -26242,11 +26301,11 @@
26301	static int proxyUnlock(sqlite3_file*, int);
26302	static int proxyCheckReservedLock(sqlite3_file, int);
26303	IOMETHODS(
26304	proxyIoFinder, /* Finder function name */
26305	proxyIoMethods, /* sqlite3_io_methods object name */
26306	1, /* shared memory is disabled */
26307	proxyClose, /* xClose method */
26308	proxyLock, /* xLock method */
26309	proxyUnlock, /* xUnlock method */
26310	proxyCheckReservedLock /* xCheckReservedLock method */
26311	)
	@@ -26255,11 +26314,11 @@
26314	/* nfs lockd on OSX 10.3+ doesn't clear write locks when a read lock is set */
26315	#if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE
26316	IOMETHODS(
26317	nfsIoFinder, /* Finder function name */
26318	nfsIoMethods, /* sqlite3_io_methods object name */
26319	1, /* shared memory is disabled */
26320	unixClose, /* xClose method */
26321	unixLock, /* xLock method */
26322	nfsUnlock, /* xUnlock method */
26323	unixCheckReservedLock /* xCheckReservedLock method */
26324	)
	@@ -26717,10 +26776,55 @@
26776	unixLeaveMutex();
26777	}
26778	#endif /* if !OS_VXWORKS */
26779	return pUnused;
26780	}
26781
26782	/*
26783	** This function is called by unixOpen() to determine the unix permissions
26784	** to create new files with. If no error occurs, then SQLITE_OK is returned
26785	** and a value suitable for passing as the third argument to open(2) is
26786	** written to *pMode. If an IO error occurs, an SQLite error code is
26787	** returned and the value of *pMode is not modified.
26788	**
26789	** If the file being opened is a temporary file, it is always created with
26790	** the octal permissions 0600 (read/writable by owner only). If the file
26791	** is a database or master journal file, it is created with the permissions
26792	** mask SQLITE_DEFAULT_FILE_PERMISSIONS.
26793	**
26794	** Finally, if the file being opened is a WAL or regular journal file, then
26795	** this function queries the file-system for the permissions on the
26796	** corresponding database file and sets *pMode to this value. Whenever
26797	** possible, WAL and journal files are created using the same permissions
26798	** as the associated database file.
26799	*/
26800	static int findCreateFileMode(
26801	const char zPath, / Path of file (possibly) being created */
26802	int flags, /* Flags passed as 4th argument to xOpen() */
26803	mode_t pMode / OUT: Permissions to open file with */
26804	){
26805	int rc = SQLITE_OK; /* Return Code */
26806	if( flags & (SQLITE_OPEN_WAL\|SQLITE_OPEN_MAIN_JOURNAL) ){
26807	char zDb[MAX_PATHNAME+1]; /* Database file path */
26808	int nDb; /* Number of valid bytes in zDb */
26809	struct stat sStat; /* Output of stat() on database file */
26810
26811	nDb = sqlite3Strlen30(zPath) - ((flags & SQLITE_OPEN_WAL) ? 4 : 8);
26812	memcpy(zDb, zPath, nDb);
26813	zDb[nDb] = '\0';
26814	if( 0==stat(zDb, &sStat) ){
26815	*pMode = sStat.st_mode & 0777;
26816	}else{
26817	rc = SQLITE_IOERR_FSTAT;
26818	}
26819	}else if( flags & SQLITE_OPEN_DELETEONCLOSE ){
26820	*pMode = 0600;
26821	}else{
26822	*pMode = SQLITE_DEFAULT_FILE_PERMISSIONS;
26823	}
26824	return rc;
26825	}
26826
26827	/*
26828	** Open the file zPath.
26829	**
26830	** Previously, the SQLite OS layer used three functions in place of this
	@@ -26768,13 +26872,15 @@
26872
26873	/* If creating a master or main-file journal, this function will open
26874	** a file-descriptor on the directory too. The first time unixSync()
26875	** is called the directory file descriptor will be fsync()ed and close()d.
26876	*/
26877	int isOpenDirectory = (isCreate && (
26878	eType==SQLITE_OPEN_MASTER_JOURNAL
26879	\|\| eType==SQLITE_OPEN_MAIN_JOURNAL
26880	\|\| eType==SQLITE_OPEN_WAL
26881	));
26882
26883	/* If argument zPath is a NULL pointer, this function is required to open
26884	** a temporary file. Use this buffer to store the file name in.
26885	*/
26886	char zTmpname[MAX_PATHNAME+1];
	@@ -26790,21 +26896,22 @@
26896	assert((isReadonly==0 \|\| isReadWrite==0) && (isReadWrite \|\| isReadonly));
26897	assert(isCreate==0 \|\| isReadWrite);
26898	assert(isExclusive==0 \|\| isCreate);
26899	assert(isDelete==0 \|\| isCreate);
26900
26901	/* The main DB, main journal, WAL file and master journal are never
26902	** automatically deleted. Nor are they ever temporary files. */
26903	assert( (!isDelete && zName) \|\| eType!=SQLITE_OPEN_MAIN_DB );
26904	assert( (!isDelete && zName) \|\| eType!=SQLITE_OPEN_MAIN_JOURNAL );
26905	assert( (!isDelete && zName) \|\| eType!=SQLITE_OPEN_MASTER_JOURNAL );
26906	assert( (!isDelete && zName) \|\| eType!=SQLITE_OPEN_WAL );
26907
26908	/* Assert that the upper layer has set one of the "file-type" flags. */
26909	assert( eType==SQLITE_OPEN_MAIN_DB \|\| eType==SQLITE_OPEN_TEMP_DB
26910	\|\| eType==SQLITE_OPEN_MAIN_JOURNAL \|\| eType==SQLITE_OPEN_TEMP_JOURNAL
26911	\|\| eType==SQLITE_OPEN_SUBJOURNAL \|\| eType==SQLITE_OPEN_MASTER_JOURNAL
26912	\|\| eType==SQLITE_OPEN_TRANSIENT_DB \|\| eType==SQLITE_OPEN_WAL
26913	);
26914
26915	memset(p, 0, sizeof(unixFile));
26916
26917	if( eType==SQLITE_OPEN_MAIN_DB ){
	@@ -26838,11 +26945,17 @@
26945	if( isCreate ) openFlags \|= O_CREAT;
26946	if( isExclusive ) openFlags \|= (O_EXCL\|O_NOFOLLOW);
26947	openFlags \|= (O_LARGEFILE\|O_BINARY);
26948
26949	if( fd<0 ){
26950	mode_t openMode; /* Permissions to create file with */
26951	rc = findCreateFileMode(zName, flags, &openMode);
26952	if( rc!=SQLITE_OK ){
26953	assert( !p->pUnused );
26954	assert( eType==SQLITE_OPEN_WAL \|\| eType==SQLITE_OPEN_MAIN_JOURNAL );
26955	return rc;
26956	}
26957	fd = open(zName, openFlags, openMode);
26958	OSTRACE(("OPENX %-3d %s 0%o\n", fd, zName, openFlags));
26959	if( fd<0 && errno!=EISDIR && isReadWrite && !isExclusive ){
26960	/* Failed to open the file for read/write access. Try read-only. */
26961	flags &= ~(SQLITE_OPEN_READWRITE\|SQLITE_OPEN_CREATE);
	@@ -26981,11 +27094,13 @@
27094	int dirSync /* If true, fsync() directory after deleting file */
27095	){
27096	int rc = SQLITE_OK;
27097	UNUSED_PARAMETER(NotUsed);
27098	SimulateIOError(return SQLITE_IOERR_DELETE);
27099	if( unlink(zPath)==(-1) && errno!=ENOENT ){
27100	return SQLITE_IOERR_DELETE;
27101	}
27102	#ifndef SQLITE_DISABLE_DIRSYNC
27103	if( dirSync ){
27104	int fd;
27105	rc = openDirectory(zPath, &fd);
27106	if( rc==SQLITE_OK ){
	@@ -29959,15 +30074,10 @@
30074	static int winDeviceCharacteristics(sqlite3_file *id){
30075	UNUSED_PARAMETER(id);
30076	return SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN;
30077	}
30078





30079	#ifndef SQLITE_OMIT_WAL
30080
30081	/*
30082	** Helper functions to obtain and relinquish the global mutex. The
30083	** global mutex is used to protect the winLockInfo objects used by
	@@ -29977,11 +30087,11 @@
30087	** is held when required. This function is only used as part of assert()
30088	** statements. e.g.
30089	**
30090	** winShmEnterMutex()
30091	** assert( winShmMutexHeld() );
30092	** winShmLeaveMutex()
30093	*/
30094	static void winShmEnterMutex(void){
30095	sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
30096	}
30097	static void winShmLeaveMutex(void){
	@@ -30013,15 +30123,10 @@
30123	**
30124	** Either winShmNode.mutex must be held or winShmNode.nRef==0 and
30125	** winShmMutexHeld() is true when reading or writing any other field
30126	** in this structure.
30127	**





30128	*/
30129	struct winShmNode {
30130	sqlite3_mutex mutex; / Mutex to access this object */
30131	char zFilename; / Name of the file */
30132	winFile hFile; /* File handle from winOpen */
	@@ -30051,21 +30156,25 @@
30156
30157	/*
30158	** Structure used internally by this VFS to record the state of an
30159	** open shared memory connection.
30160	**
30161	** The following fields are initialized when this object is created and
30162	** are read-only thereafter:
30163	**
30164	** winShm.pShmNode
30165	** winShm.id
30166	**
30167	** All other fields are read/write. The winShm.pShmNode->mutex must be held
30168	** while accessing any read/write fields.
30169	*/
30170	struct winShm {
30171	winShmNode pShmNode; / The underlying winShmNode object */
30172	winShm pNext; / Next winShm with the same winShmNode */
30173	u8 hasMutex; /* True if holding the winShmNode mutex */
30174	u16 sharedMask; /* Mask of shared locks held */
30175	u16 exclMask; /* Mask of exclusive locks held */
30176	#ifdef SQLITE_DEBUG
30177	u8 id; /* Id of this connection with its winShmNode */
30178	#endif
30179	};
30180
	@@ -30096,27 +30205,32 @@
30205
30206	/* Initialize the locking parameters */
30207	dwFlags = LOCKFILE_FAIL_IMMEDIATELY;
30208	if( lockType == _SHM_WRLCK ) dwFlags \|= LOCKFILE_EXCLUSIVE_LOCK;
30209

30210	memset(&ovlp, 0, sizeof(OVERLAPPED));
30211	ovlp.Offset = ofst;
30212
30213	/* Release/Acquire the system-level lock */
30214	if( lockType==_SHM_UNLCK ){
30215	rc = UnlockFileEx(pFile->hFile.h, 0, nByte, 0, &ovlp);
30216	}else{
30217	rc = LockFileEx(pFile->hFile.h, dwFlags, 0, nByte, 0, &ovlp);
30218	}
30219
30220	if( rc!= 0 ){
30221	rc = SQLITE_OK;
30222	}else{
30223	pFile->lastErrno = GetLastError();
30224	rc = SQLITE_BUSY;
30225	}
30226
30227	OSTRACE(("SHM-LOCK %d %s %s 0x%08lx\n",
30228	pFile->hFile.h,
30229	rc==SQLITE_OK ? "ok" : "failed",
30230	lockType==_SHM_UNLCK ? "UnlockFileEx" : "LockFileEx",
30231	pFile->lastErrno));
30232
30233	return rc;
30234	}
30235
30236	/* Forward references to VFS methods */
	@@ -30160,35 +30274,23 @@
30274	}
30275	}
30276	}
30277
30278	/*
30279	** Open the shared-memory area associated with database file pDbFd.








30280	**
30281	** When opening a new shared-memory file, if no other instances of that
30282	** file are currently open, in this process or in other processes, then
30283	** the file must be truncated to zero length or have its header cleared.
30284	*/
30285	static int winOpenSharedMemory(winFile *pDbFd){



30286	struct winShm p; / The connection to be opened */
30287	struct winShmNode pShmNode = 0; / The underlying mmapped file */
30288	int rc; /* Result code */
30289	struct winShmNode pNew; / Newly allocated winShmNode */
30290	int nName; /* Size of zName in bytes */
30291

30292	assert( pDbFd->pShm==0 ); /* Not previously opened */
30293
30294	/* Allocate space for the new sqlite3_shm object. Also speculatively
30295	** allocate space for a new winShmNode and filename.
30296	*/
	@@ -30255,18 +30357,28 @@
30357	if( rc ) goto shm_open_err;
30358	}
30359
30360	/* Make the new connection a child of the winShmNode */
30361	p->pShmNode = pShmNode;

30362	#ifdef SQLITE_DEBUG
30363	p->id = pShmNode->nextShmId++;
30364	#endif

30365	pShmNode->nRef++;
30366	pDbFd->pShm = p;
30367	winShmLeaveMutex();
30368
30369	/* The reference count on pShmNode has already been incremented under
30370	** the cover of the winShmEnterMutex() mutex and the pointer from the
30371	** new (struct winShm) object to the pShmNode has been set. All that is
30372	** left to do is to link the new object into the linked list starting
30373	** at pShmNode->pFirst. This must be done while holding the pShmNode->mutex
30374	** mutex.
30375	*/
30376	sqlite3_mutex_enter(pShmNode->mutex);
30377	p->pNext = pShmNode->pFirst;
30378	pShmNode->pFirst = p;
30379	sqlite3_mutex_leave(pShmNode->mutex);
30380	return SQLITE_OK;
30381
30382	/* Jump here on any error */
30383	shm_open_err:
30384	winShmSystemLock(pShmNode, _SHM_UNLCK, WIN_SHM_DMS, 1);
	@@ -30279,11 +30391,11 @@
30391
30392	/*
30393	** Close a connection to shared-memory. Delete the underlying
30394	** storage if deleteFlag is true.
30395	*/
30396	static int winShmUnmap(
30397	sqlite3_file fd, / Database holding shared memory */
30398	int deleteFlag /* Delete after closing if true */
30399	){
30400	winFile pDbFd; / Database holding shared-memory */
30401	winShm p; / The connection to be closed */
	@@ -30290,10 +30402,11 @@
30402	winShmNode pShmNode; / The underlying shared-memory file */
30403	winShm *pp; / For looping over sibling connections */
30404
30405	pDbFd = (winFile*)fd;
30406	p = pDbFd->pShm;
30407	if( p==0 ) return SQLITE_OK;
30408	pShmNode = p->pShmNode;
30409
30410	/* Remove connection p from the set of connections associated
30411	** with pShmNode */
30412	sqlite3_mutex_enter(pShmNode->mutex);
	@@ -30315,10 +30428,131 @@
30428	}
30429	winShmLeaveMutex();
30430
30431	return SQLITE_OK;
30432	}
30433
30434	/*
30435	** Change the lock state for a shared-memory segment.
30436	*/
30437	static int winShmLock(
30438	sqlite3_file fd, / Database file holding the shared memory */
30439	int ofst, /* First lock to acquire or release */
30440	int n, /* Number of locks to acquire or release */
30441	int flags /* What to do with the lock */
30442	){
30443	winFile pDbFd = (winFile)fd; /* Connection holding shared memory */
30444	winShm p = pDbFd->pShm; / The shared memory being locked */
30445	winShm pX; / For looping over all siblings */
30446	winShmNode *pShmNode = p->pShmNode;
30447	int rc = SQLITE_OK; /* Result code */
30448	u16 mask; /* Mask of locks to take or release */
30449
30450	assert( ofst>=0 && ofst+n<=SQLITE_SHM_NLOCK );
30451	assert( n>=1 );
30452	assert( flags==(SQLITE_SHM_LOCK \| SQLITE_SHM_SHARED)
30453	\|\| flags==(SQLITE_SHM_LOCK \| SQLITE_SHM_EXCLUSIVE)
30454	\|\| flags==(SQLITE_SHM_UNLOCK \| SQLITE_SHM_SHARED)
30455	\|\| flags==(SQLITE_SHM_UNLOCK \| SQLITE_SHM_EXCLUSIVE) );
30456	assert( n==1 \|\| (flags & SQLITE_SHM_EXCLUSIVE)!=0 );
30457
30458	mask = (u16)((1U<<(ofst+n)) - (1U<<ofst));
30459	assert( n>1 \|\| mask==(1<<ofst) );
30460	sqlite3_mutex_enter(pShmNode->mutex);
30461	if( flags & SQLITE_SHM_UNLOCK ){
30462	u16 allMask = 0; /* Mask of locks held by siblings */
30463
30464	/* See if any siblings hold this same lock */
30465	for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
30466	if( pX==p ) continue;
30467	assert( (pX->exclMask & (p->exclMask\|p->sharedMask))==0 );
30468	allMask \|= pX->sharedMask;
30469	}
30470
30471	/* Unlock the system-level locks */
30472	if( (mask & allMask)==0 ){
30473	rc = winShmSystemLock(pShmNode, _SHM_UNLCK, ofst+WIN_SHM_BASE, n);
30474	}else{
30475	rc = SQLITE_OK;
30476	}
30477
30478	/* Undo the local locks */
30479	if( rc==SQLITE_OK ){
30480	p->exclMask &= ~mask;
30481	p->sharedMask &= ~mask;
30482	}
30483	}else if( flags & SQLITE_SHM_SHARED ){
30484	u16 allShared = 0; /* Union of locks held by connections other than "p" */
30485
30486	/* Find out which shared locks are already held by sibling connections.
30487	** If any sibling already holds an exclusive lock, go ahead and return
30488	** SQLITE_BUSY.
30489	*/
30490	for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
30491	if( (pX->exclMask & mask)!=0 ){
30492	rc = SQLITE_BUSY;
30493	break;
30494	}
30495	allShared \|= pX->sharedMask;
30496	}
30497
30498	/* Get shared locks at the system level, if necessary */
30499	if( rc==SQLITE_OK ){
30500	if( (allShared & mask)==0 ){
30501	rc = winShmSystemLock(pShmNode, _SHM_RDLCK, ofst+WIN_SHM_BASE, n);
30502	}else{
30503	rc = SQLITE_OK;
30504	}
30505	}
30506
30507	/* Get the local shared locks */
30508	if( rc==SQLITE_OK ){
30509	p->sharedMask \|= mask;
30510	}
30511	}else{
30512	/* Make sure no sibling connections hold locks that will block this
30513	** lock. If any do, return SQLITE_BUSY right away.
30514	*/
30515	for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
30516	if( (pX->exclMask & mask)!=0 \|\| (pX->sharedMask & mask)!=0 ){
30517	rc = SQLITE_BUSY;
30518	break;
30519	}
30520	}
30521
30522	/* Get the exclusive locks at the system level. Then if successful
30523	** also mark the local connection as being locked.
30524	*/
30525	if( rc==SQLITE_OK ){
30526	rc = winShmSystemLock(pShmNode, _SHM_WRLCK, ofst+WIN_SHM_BASE, n);
30527	if( rc==SQLITE_OK ){
30528	assert( (p->sharedMask & mask)==0 );
30529	p->exclMask \|= mask;
30530	}
30531	}
30532	}
30533	sqlite3_mutex_leave(pShmNode->mutex);
30534	OSTRACE(("SHM-LOCK shmid-%d, pid-%d got %03x,%03x %s\n",
30535	p->id, (int)GetCurrentProcessId(), p->sharedMask, p->exclMask,
30536	rc ? "failed" : "ok"));
30537	return rc;
30538	}
30539
30540	/*
30541	** Implement a memory barrier or memory fence on shared memory.
30542	**
30543	** All loads and stores begun before the barrier must complete before
30544	** any load or store begun after the barrier.
30545	*/
30546	static void winShmBarrier(
30547	sqlite3_file fd / Database holding the shared memory */
30548	){
30549	UNUSED_PARAMETER(fd);
30550	/* MemoryBarrier(); // does not work -- do not know why not */
30551	winShmEnterMutex();
30552	winShmLeaveMutex();
30553	}
30554
30555	/*
30556	** This function is called to obtain a pointer to region iRegion of the
30557	** shared-memory associated with the database file fd. Shared-memory regions
30558	** are numbered starting from zero. Each shared-memory region is szRegion
	@@ -30344,13 +30578,20 @@
30578	int isWrite, /* True to extend file if necessary */
30579	void volatile *pp / OUT: Mapped memory */
30580	){
30581	winFile pDbFd = (winFile)fd;
30582	winShm *p = pDbFd->pShm;
30583	winShmNode *pShmNode;
30584	int rc = SQLITE_OK;
30585
30586	if( !p ){
30587	rc = winOpenSharedMemory(pDbFd);
30588	if( rc!=SQLITE_OK ) return rc;
30589	p = pDbFd->pShm;
30590	}
30591	pShmNode = p->pShmNode;
30592
30593	sqlite3_mutex_enter(pShmNode->mutex);
30594	assert( szRegion==pShmNode->szRegion \|\| pShmNode->nRegion==0 );
30595
30596	if( pShmNode->nRegion<=iRegion ){
30597	struct ShmRegion apNew; / New aRegion[] array */
	@@ -30363,10 +30604,11 @@
30604	** Check to see if it has been allocated (i.e. if the wal-index file is
30605	** large enough to contain the requested region).
30606	*/
30607	rc = winFileSize((sqlite3_file *)&pShmNode->hFile, &sz);
30608	if( rc!=SQLITE_OK ){
30609	rc = SQLITE_IOERR_SHMSIZE;
30610	goto shmpage_out;
30611	}
30612
30613	if( sz<nByte ){
30614	/* The requested memory region does not exist. If isWrite is set to
	@@ -30376,10 +30618,11 @@
30618	** the requested memory region.
30619	*/
30620	if( !isWrite ) goto shmpage_out;
30621	rc = winTruncate((sqlite3_file *)&pShmNode->hFile, nByte);
30622	if( rc!=SQLITE_OK ){
30623	rc = SQLITE_IOERR_SHMSIZE;
30624	goto shmpage_out;
30625	}
30626	}
30627
30628	/* Map the requested memory region into this processes address space. */
	@@ -30426,102 +30669,53 @@
30669	}
30670	sqlite3_mutex_leave(pShmNode->mutex);
30671	return rc;
30672	}
30673



















































30674	#else

30675	# define winShmMap 0
30676	# define winShmLock 0
30677	# define winShmBarrier 0
30678	# define winShmUnmap 0
30679	#endif /* #ifndef SQLITE_OMIT_WAL */
30680
30681	/*
30682	** Here ends the implementation of all sqlite3_file methods.
30683	**
30684	******************** End sqlite3_file Methods *****************************
30685	******************************************************************************/
30686
30687	/*
30688	** This vector defines all the methods that can operate on an
30689	** sqlite3_file for win32.
30690	*/
30691	static const sqlite3_io_methods winIoMethod = {
30692	2, /* iVersion */
30693	winClose, /* xClose */
30694	winRead, /* xRead */
30695	winWrite, /* xWrite */
30696	winTruncate, /* xTruncate */
30697	winSync, /* xSync */
30698	winFileSize, /* xFileSize */
30699	winLock, /* xLock */
30700	winUnlock, /* xUnlock */
30701	winCheckReservedLock, /* xCheckReservedLock */
30702	winFileControl, /* xFileControl */
30703	winSectorSize, /* xSectorSize */
30704	winDeviceCharacteristics, /* xDeviceCharacteristics */
30705	winShmMap, /* xShmMap */
30706	winShmLock, /* xShmLock */
30707	winShmBarrier, /* xShmBarrier */
30708	winShmUnmap /* xShmUnmap */

30709	};
30710
30711	/****************************************************************************
30712	************************** sqlite3_vfs methods **************************
30713	**
30714	** This division contains the implementation of methods on the
30715	** sqlite3_vfs object.
30716	*/
30717
30718	/*
30719	** Convert a UTF-8 filename into whatever form the underlying
30720	** operating system wants filenames in. Space to hold the result
30721	** is obtained from malloc and must be freed by the calling
	@@ -30788,10 +30982,11 @@
30982	}
30983	OSTRACE(("OPEN %d %s 0x%lx %s\n",
30984	h, zName, dwDesiredAccess,
30985	h==INVALID_HANDLE_VALUE ? "failed" : "ok"));
30986	if( h==INVALID_HANDLE_VALUE ){
30987	pFile->lastErrno = GetLastError();
30988	free(zConverted);
30989	if( flags & SQLITE_OPEN_READWRITE ){
30990	return winOpen(pVfs, zName, id,
30991	((flags\|SQLITE_OPEN_READONLY)&~SQLITE_OPEN_READWRITE), pOutFlags);
30992	}else{
	@@ -39553,16 +39748,15 @@
39748	\|\| eMode==PAGER_JOURNALMODE_PERSIST
39749	\|\| eMode==PAGER_JOURNALMODE_OFF
39750	\|\| eMode==PAGER_JOURNALMODE_WAL
39751	\|\| eMode==PAGER_JOURNALMODE_MEMORY );
39752
39753	/* This routine is only called from the OP_JournalMode opcode, and
39754	** the logic there will never allow a temporary file to be changed
39755	** to WAL mode.
39756	*/
39757	assert( pPager->tempFile==0 \|\| eMode!=PAGER_JOURNALMODE_WAL );



39758
39759	/* Do allow the journalmode of an in-memory database to be set to
39760	** anything other than MEMORY or OFF
39761	*/
39762	if( MEMDB ){
	@@ -39697,11 +39891,11 @@
39891	** Return true if the underlying VFS for the given pager supports the
39892	** primitives necessary for write-ahead logging.
39893	*/
39894	SQLITE_PRIVATE int sqlite3PagerWalSupported(Pager *pPager){
39895	const sqlite3_io_methods *pMethods = pPager->fd->pMethods;
39896	return pMethods->iVersion>=2 && pMethods->xShmMap!=0;
39897	}
39898
39899	/*
39900	** The caller must be holding a SHARED lock on the database file to call
39901	** this function.
	@@ -40229,13 +40423,13 @@
40423	int nWiData; /* Size of array apWiData */
40424	volatile u32 *apWiData; / Pointer to wal-index content in memory */
40425	u16 szPage; /* Database page size */
40426	i16 readLock; /* Which read lock is being held. -1 for none */
40427	u8 exclusiveMode; /* Non-zero if connection is in exclusive mode */

40428	u8 writeLock; /* True if in a write transaction */
40429	u8 ckptLock; /* True if holding a checkpoint lock */
40430	u8 readOnly; /* True if the WAL file is open read-only */
40431	WalIndexHdr hdr; /* Wal-index header for current transaction */
40432	const char zWalName; / Name of WAL file */
40433	u32 nCkpt; /* Checkpoint sequence counter in the wal-header */
40434	#ifdef SQLITE_DEBUG
40435	u8 lockError; /* True if a locking error has occurred */
	@@ -40311,18 +40505,19 @@
40505	static int walIndexPage(Wal pWal, int iPage, volatile u32 *ppPage){
40506	int rc = SQLITE_OK;
40507
40508	/* Enlarge the pWal->apWiData[] array if required */
40509	if( pWal->nWiData<=iPage ){
40510	int nByte = sizeof(u32)(iPage+1);
40511	volatile u32 **apNew;
40512	apNew = (volatile u32 *)sqlite3_realloc((void )pWal->apWiData, nByte);
40513	if( !apNew ){
40514	*ppPage = 0;
40515	return SQLITE_NOMEM;
40516	}
40517	memset((void*)&apNew[pWal->nWiData], 0,
40518	sizeof(u32)(iPage+1-pWal->nWiData));
40519	pWal->apWiData = apNew;
40520	pWal->nWiData = iPage+1;
40521	}
40522
40523	/* Request a pointer to the required page from the VFS */
	@@ -40494,13 +40689,14 @@
40689	pgno = sqlite3Get4byte(&aFrame[0]);
40690	if( pgno==0 ){
40691	return 0;
40692	}
40693
40694	/* A frame is only valid if a checksum of the WAL header,
40695	** all prior frams, the first 16 bytes of this frame-header,
40696	** and the frame-data matches the checksum in the last 8
40697	** bytes of this frame-header.
40698	*/
40699	nativeCksum = (pWal->hdr.bigEndCksum==SQLITE_BIGENDIAN);
40700	walChecksumBytes(nativeCksum, aFrame, 8, aCksum, aCksum);
40701	walChecksumBytes(nativeCksum, aData, pWal->szPage, aCksum, aCksum);
40702	if( aCksum[0]!=sqlite3Get4byte(&aFrame[16])
	@@ -40756,11 +40952,11 @@
40952	** page number array and hash table entry.
40953	*/
40954	if( rc==SQLITE_OK ){
40955	int iKey; /* Hash table key */
40956	int idx; /* Value to write to hash-table slot */
40957	int nCollide; /* Number of hash collisions */
40958
40959	idx = iFrame - iZero;
40960	assert( idx <= HASHTABLE_NSLOT/2 + 1 );
40961
40962	/* If this is the first entry to be added to this hash-table, zero the
	@@ -40781,12 +40977,13 @@
40977	walCleanupHash(pWal);
40978	assert( !aPgno[idx] );
40979	}
40980
40981	/* Write the aPgno[] array entry and the hash-table slot. */
40982	nCollide = idx;
40983	for(iKey=walHash(iPage); aHash[iKey]; iKey=walNextHash(iKey)){
40984	if( (nCollide--)==0 ) return SQLITE_CORRUPT_BKPT;
40985	}
40986	aPgno[idx] = iPage;
40987	aHash[iKey] = (ht_slot)idx;
40988
40989	#ifdef SQLITE_ENABLE_EXPENSIVE_ASSERT
	@@ -40981,14 +41178,11 @@
41178
41179	/*
41180	** Close an open wal-index.
41181	*/
41182	static void walIndexClose(Wal *pWal, int isDelete){
41183	sqlite3OsShmUnmap(pWal->pDbFd, isDelete);



41184	}
41185
41186	/*
41187	** Open a connection to the WAL file zWalName. The database file must
41188	** already be opened on connection pDbFd. The buffer that zWalName points
	@@ -41039,17 +41233,16 @@
41233	pRet->pVfs = pVfs;
41234	pRet->pWalFd = (sqlite3_file *)&pRet[1];
41235	pRet->pDbFd = pDbFd;
41236	pRet->readLock = -1;
41237	pRet->zWalName = zWalName;

41238
41239	/* Open file handle on the write-ahead log file. */
41240	flags = (SQLITE_OPEN_READWRITE\|SQLITE_OPEN_CREATE\|SQLITE_OPEN_WAL);
41241	rc = sqlite3OsOpen(pVfs, zWalName, pRet->pWalFd, flags, &flags);
41242	if( rc==SQLITE_OK && flags&SQLITE_OPEN_READONLY ){
41243	pRet->readOnly = 1;
41244	}
41245
41246	if( rc!=SQLITE_OK ){
41247	walIndexClose(pRet, 0);
41248	sqlite3OsClose(pRet->pWalFd);
	@@ -41268,11 +41461,15 @@
41461	int j; /* Counter variable */
41462	int nEntry; /* Number of entries in this segment */
41463	ht_slot aIndex; / Sorted index for this segment */
41464
41465	aPgno++;
41466	if( (i+1)==nSegment ){
41467	nEntry = (int)(iLast - iZero);
41468	}else{
41469	nEntry = (int)((u32)aHash - (u32)aPgno);
41470	}
41471	aIndex = &((ht_slot *)&p->aSegment[p->nSegment])[iZero];
41472	iZero++;
41473
41474	for(j=0; j<nEntry; j++){
41475	aIndex[j] = (ht_slot)j;
	@@ -41680,12 +41877,20 @@
41877	** which might cause WAL_RETRY to be returned even if BUSY_RECOVERY
41878	** would be technically correct. But the race is benign since with
41879	** WAL_RETRY this routine will be called again and will probably be
41880	** right on the second iteration.
41881	*/
41882	if( pWal->apWiData[0]==0 ){
41883	/* This branch is taken when the xShmMap() method returns SQLITE_BUSY.
41884	** We assume this is a transient condition, so return WAL_RETRY. The
41885	** xShmMap() implementation used by the default unix and win32 VFS
41886	** modules may return SQLITE_BUSY due to a race condition in the
41887	** code that determines whether or not the shared-memory region
41888	** must be zeroed before the requested page is returned.
41889	*/
41890	rc = WAL_RETRY;
41891	}else if( SQLITE_OK==(rc = walLockShared(pWal, WAL_RECOVER_LOCK)) ){
41892	walUnlockShared(pWal, WAL_RECOVER_LOCK);
41893	rc = WAL_RETRY;
41894	}else if( rc==SQLITE_BUSY ){
41895	rc = SQLITE_BUSY_RECOVERY;
41896	}
	@@ -41905,22 +42110,27 @@
42110	for(iHash=walFramePage(iLast); iHash>=0 && iRead==0; iHash--){
42111	volatile ht_slot aHash; / Pointer to hash table */
42112	volatile u32 aPgno; / Pointer to array of page numbers */
42113	u32 iZero; /* Frame number corresponding to aPgno[0] */
42114	int iKey; /* Hash slot index */
42115	int nCollide; /* Number of hash collisions remaining */
42116	int rc; /* Error code */
42117
42118	rc = walHashGet(pWal, iHash, &aHash, &aPgno, &iZero);
42119	if( rc!=SQLITE_OK ){
42120	return rc;
42121	}
42122	nCollide = HASHTABLE_NSLOT;
42123	for(iKey=walHash(pgno); aHash[iKey]; iKey=walNextHash(iKey)){
42124	u32 iFrame = aHash[iKey] + iZero;
42125	if( iFrame<=iLast && aPgno[aHash[iKey]]==pgno ){
42126	assert( iFrame>iRead );
42127	iRead = iFrame;
42128	}
42129	if( (nCollide--)==0 ){
42130	return SQLITE_CORRUPT_BKPT;
42131	}
42132	}
42133	}
42134
42135	#ifdef SQLITE_ENABLE_EXPENSIVE_ASSERT
42136	/* If expensive assert() statements are available, do a linear search
	@@ -41980,10 +42190,14 @@
42190	int rc;
42191
42192	/* Cannot start a write transaction without first holding a read
42193	** transaction. */
42194	assert( pWal->readLock>=0 );
42195
42196	if( pWal->readOnly ){
42197	return SQLITE_READONLY;
42198	}
42199
42200	/* Only one writer allowed at a time. Get the write lock. Return
42201	** SQLITE_BUSY if unable.
42202	*/
42203	rc = walLockExclusive(pWal, WAL_WRITE_LOCK, 1);
	@@ -42008,12 +42222,14 @@
42222	/*
42223	** End a write transaction. The commit has already been done. This
42224	** routine merely releases the lock.
42225	*/
42226	SQLITE_PRIVATE int sqlite3WalEndWriteTransaction(Wal *pWal){
42227	if( pWal->writeLock ){
42228	walUnlockExclusive(pWal, WAL_WRITE_LOCK, 1);
42229	pWal->writeLock = 0;
42230	}
42231	return SQLITE_OK;
42232	}
42233
42234	/*
42235	** If any data has been written (but not committed) to the log file, this
	@@ -63636,15 +63852,15 @@
63852
63853	#ifndef SQLITE_OMIT_WAL
63854	u.cd.zFilename = sqlite3PagerFilename(u.cd.pPager);
63855
63856	/* Do not allow a transition to journal_mode=WAL for a database
63857	** in temporary storage or if the VFS does not support shared memory
63858	*/
63859	if( u.cd.eNew==PAGER_JOURNALMODE_WAL
63860	&& (u.cd.zFilename[0]==0 /* Temp file */
63861	\|\| !sqlite3PagerWalSupported(u.cd.pPager)) /* No shared-memory support */
63862	){
63863	u.cd.eNew = u.cd.eOld;
63864	}
63865
63866	if( (u.cd.eNew!=u.cd.eOld)
	@@ -64882,15 +65098,14 @@
65098	0, /* xUnlock */
65099	0, /* xCheckReservedLock */
65100	0, /* xFileControl */
65101	0, /* xSectorSize */
65102	0, /* xDeviceCharacteristics */
65103	0, /* xShmMap */
65104	0, /* xShmLock */

65105	0, /* xShmBarrier */
65106	0 /* xShmUnmap */
65107	};
65108
65109	/*
65110	** Open a journal file.
65111	*/
	@@ -65167,15 +65382,14 @@
65382	0, /* xUnlock */
65383	0, /* xCheckReservedLock */
65384	0, /* xFileControl */
65385	0, /* xSectorSize */
65386	0, /* xDeviceCharacteristics */
65387	0, /* xShmMap */
65388	0, /* xShmLock */

65389	0, /* xShmBarrier */
65390	0 /* xShmUnlock */
65391	};
65392
65393	/*
65394	** Open a journal file.
65395	*/
	@@ -68178,11 +68392,11 @@
68392	pEList = pExpr->x.pSelect->pEList;
68393	if( ALWAYS(pEList!=0 && pEList->nExpr>0) ){
68394	keyInfo.aColl[0] = sqlite3BinaryCompareCollSeq(pParse, pExpr->pLeft,
68395	pEList->a[0].pExpr);
68396	}
68397	}else if( ALWAYS(pExpr->x.pList!=0) ){
68398	/* Case 2: expr IN (exprlist)
68399	**
68400	** For each expression, build an index key from the evaluation and
68401	** store it in the temporary table. If <expr> is a column, then use
68402	** that columns affinity when building index keys. If <expr> is not
	@@ -68248,11 +68462,10 @@
68462	** value of this select in a memory cell and record the number
68463	** of the memory cell in iColumn. If this is an EXISTS, write
68464	** an integer 0 (not exists) or 1 (exists) into a memory cell
68465	** and record that memory cell in iColumn.
68466	*/

68467	Select pSel; / SELECT statement to encode */
68468	SelectDest dest; /* How to deal with SELECt result */
68469
68470	testcase( pExpr->op==TK_EXISTS );
68471	testcase( pExpr->op==TK_SELECT );
	@@ -68269,11 +68482,12 @@
68482	dest.eDest = SRT_Exists;
68483	sqlite3VdbeAddOp2(v, OP_Integer, 0, dest.iParm);
68484	VdbeComment((v, "Init EXISTS result"));
68485	}
68486	sqlite3ExprDelete(pParse->db, pSel->pLimit);
68487	pSel->pLimit = sqlite3PExpr(pParse, TK_INTEGER, 0, 0,
68488	&sqlite3IntTokens[1]);
68489	if( sqlite3Select(pParse, pSel, &dest) ){
68490	return 0;
68491	}
68492	rReg = dest.iParm;
68493	ExprSetIrreducible(pExpr);
	@@ -68337,12 +68551,24 @@
68551	/* Code the LHS, the <expr> from "<expr> IN (...)".
68552	*/
68553	sqlite3ExprCachePush(pParse);
68554	r1 = sqlite3GetTempReg(pParse);
68555	sqlite3ExprCode(pParse, pExpr->pLeft, r1);

68556
68557	/* If the LHS is NULL, then the result is either false or NULL depending
68558	** on whether the RHS is empty or not, respectively.
68559	*/
68560	if( destIfNull==destIfFalse ){
68561	/* Shortcut for the common case where the false and NULL outcomes are
68562	** the same. */
68563	sqlite3VdbeAddOp2(v, OP_IsNull, r1, destIfNull);
68564	}else{
68565	int addr1 = sqlite3VdbeAddOp1(v, OP_NotNull, r1);
68566	sqlite3VdbeAddOp2(v, OP_Rewind, pExpr->iTable, destIfFalse);
68567	sqlite3VdbeAddOp2(v, OP_Goto, 0, destIfNull);
68568	sqlite3VdbeJumpHere(v, addr1);
68569	}
68570
68571	if( eType==IN_INDEX_ROWID ){
68572	/* In this case, the RHS is the ROWID of table b-tree
68573	*/
68574	sqlite3VdbeAddOp2(v, OP_MustBeInt, r1, destIfFalse);
	@@ -95669,11 +95895,11 @@
95895	Expr *pExpr = pTerm->pExpr;
95896	wsFlags \|= WHERE_COLUMN_IN;
95897	if( ExprHasProperty(pExpr, EP_xIsSelect) ){
95898	nInMul *= 25;
95899	bInEst = 1;
95900	}else if( ALWAYS(pExpr->x.pList) ){
95901	nInMul *= pExpr->x.pList->nExpr + 1;
95902	}
95903	}else if( pTerm->eOperator & WO_ISNULL ){
95904	wsFlags \|= WHERE_COLUMN_NULL;
95905	}
	@@ -97713,40 +97939,40 @@
97939	** YYNRULE the number of rules in the grammar
97940	** YYERRORSYMBOL is the code number of the error symbol. If not
97941	** defined, then do no error processing.
97942	*/
97943	#define YYCODETYPE unsigned char
97944	#define YYNOCODE 253
97945	#define YYACTIONTYPE unsigned short int
97946	#define YYWILDCARD 67
97947	#define sqlite3ParserTOKENTYPE Token
97948	typedef union {
97949	int yyinit;
97950	sqlite3ParserTOKENTYPE yy0;
97951	int yy4;
97952	struct TrigEvent yy90;
97953	ExprSpan yy118;
97954	TriggerStep* yy203;
97955	u8 yy210;
97956	struct {int value; int mask;} yy215;
97957	SrcList* yy259;
97958	struct LimitVal yy292;
97959	Expr* yy314;
97960	ExprList* yy322;
97961	struct LikeOp yy342;
97962	IdList* yy384;
97963	Select* yy387;
97964	} YYMINORTYPE;
97965	#ifndef YYSTACKDEPTH
97966	#define YYSTACKDEPTH 100
97967	#endif
97968	#define sqlite3ParserARG_SDECL Parse *pParse;
97969	#define sqlite3ParserARG_PDECL ,Parse *pParse
97970	#define sqlite3ParserARG_FETCH Parse *pParse = yypParser->pParse
97971	#define sqlite3ParserARG_STORE yypParser->pParse = pParse
97972	#define YYNSTATE 630
97973	#define YYNRULE 329
97974	#define YYFALLBACK 1
97975	#define YY_NO_ACTION (YYNSTATE+YYNRULE+2)
97976	#define YY_ACCEPT_ACTION (YYNSTATE+YYNRULE+1)
97977	#define YY_ERROR_ACTION (YYNSTATE+YYNRULE)
97978
	@@ -97812,476 +98038,477 @@
98038	** shifting terminals.
98039	** yy_reduce_ofst[] For each state, the offset into yy_action for
98040	** shifting non-terminals after a reduce.
98041	** yy_default[] Default action for each state.
98042	*/
98043	#define YY_ACTTAB_COUNT (1557)
98044	static const YYACTIONTYPE yy_action[] = {
98045	/* 0 */ 313, 960, 186, 419, 2, 172, 627, 597, 55, 55,
98046	/* 10 */ 55, 55, 48, 53, 53, 53, 53, 52, 52, 51,
98047	/* 20 */ 51, 51, 50, 238, 302, 283, 623, 622, 516, 515,
98048	/* 30 */ 590, 584, 55, 55, 55, 55, 282, 53, 53, 53,
98049	/* 40 */ 53, 52, 52, 51, 51, 51, 50, 238, 6, 56,
98050	/* 50 */ 57, 47, 582, 581, 583, 583, 54, 54, 55, 55,
98051	/* 60 */ 55, 55, 608, 53, 53, 53, 53, 52, 52, 51,
98052	/* 70 */ 51, 51, 50, 238, 313, 597, 409, 330, 579, 579,
98053	/* 80 */ 32, 53, 53, 53, 53, 52, 52, 51, 51, 51,
98054	/* 90 */ 50, 238, 330, 217, 620, 619, 166, 411, 624, 382,
98055	/* 100 */ 379, 378, 7, 491, 590, 584, 200, 199, 198, 58,
98056	/* 110 */ 377, 300, 414, 621, 481, 66, 623, 622, 621, 580,
98057	/* 120 */ 254, 601, 94, 56, 57, 47, 582, 581, 583, 583,
98058	/* 130 */ 54, 54, 55, 55, 55, 55, 671, 53, 53, 53,
98059	/* 140 */ 53, 52, 52, 51, 51, 51, 50, 238, 313, 532,
98060	/* 150 */ 226, 506, 507, 133, 177, 139, 284, 385, 279, 384,
98061	/* 160 */ 169, 197, 342, 398, 251, 226, 253, 275, 388, 167,
98062	/* 170 */ 139, 284, 385, 279, 384, 169, 570, 236, 590, 584,
98063	/* 180 */ 672, 240, 275, 157, 620, 619, 554, 437, 51, 51,
98064	/* 190 */ 51, 50, 238, 343, 439, 553, 438, 56, 57, 47,
98065	/* 200 */ 582, 581, 583, 583, 54, 54, 55, 55, 55, 55,
98066	/* 210 */ 465, 53, 53, 53, 53, 52, 52, 51, 51, 51,
98067	/* 220 */ 50, 238, 313, 390, 52, 52, 51, 51, 51, 50,
98068	/* 230 */ 238, 391, 166, 491, 566, 382, 379, 378, 409, 440,
98069	/* 240 */ 579, 579, 252, 440, 607, 66, 377, 513, 621, 49,
98070	/* 250 */ 46, 147, 590, 584, 621, 16, 466, 189, 621, 441,
98071	/* 260 */ 442, 673, 526, 441, 340, 577, 595, 64, 194, 482,
98072	/* 270 */ 434, 56, 57, 47, 582, 581, 583, 583, 54, 54,
98073	/* 280 */ 55, 55, 55, 55, 30, 53, 53, 53, 53, 52,
98074	/* 290 */ 52, 51, 51, 51, 50, 238, 313, 593, 593, 593,
98075	/* 300 */ 387, 578, 606, 493, 259, 351, 258, 411, 1, 623,
98076	/* 310 */ 622, 496, 623, 622, 65, 240, 623, 622, 597, 443,
98077	/* 320 */ 237, 239, 414, 341, 237, 602, 590, 584, 18, 603,
98078	/* 330 */ 166, 601, 87, 382, 379, 378, 67, 623, 622, 38,
98079	/* 340 */ 623, 622, 176, 270, 377, 56, 57, 47, 582, 581,
98080	/* 350 */ 583, 583, 54, 54, 55, 55, 55, 55, 175, 53,
98081	/* 360 */ 53, 53, 53, 52, 52, 51, 51, 51, 50, 238,
98082	/* 370 */ 313, 396, 233, 411, 531, 565, 317, 620, 619, 44,
98083	/* 380 */ 620, 619, 240, 206, 620, 619, 597, 266, 414, 268,
98084	/* 390 */ 409, 597, 579, 579, 352, 184, 505, 601, 73, 533,
98085	/* 400 */ 590, 584, 466, 548, 190, 620, 619, 576, 620, 619,
98086	/* 410 */ 547, 383, 551, 35, 332, 575, 574, 600, 504, 56,
98087	/* 420 */ 57, 47, 582, 581, 583, 583, 54, 54, 55, 55,
98088	/* 430 */ 55, 55, 567, 53, 53, 53, 53, 52, 52, 51,
98089	/* 440 */ 51, 51, 50, 238, 313, 411, 561, 561, 528, 364,
98090	/* 450 */ 259, 351, 258, 183, 361, 549, 524, 374, 411, 597,
98091	/* 460 */ 414, 240, 560, 560, 409, 604, 579, 579, 328, 601,
98092	/* 470 */ 93, 623, 622, 414, 590, 584, 237, 564, 559, 559,
98093	/* 480 */ 520, 402, 601, 87, 409, 210, 579, 579, 168, 421,
98094	/* 490 */ 950, 519, 950, 56, 57, 47, 582, 581, 583, 583,
98095	/* 500 */ 54, 54, 55, 55, 55, 55, 192, 53, 53, 53,
98096	/* 510 */ 53, 52, 52, 51, 51, 51, 50, 238, 313, 600,
98097	/* 520 */ 293, 563, 511, 234, 357, 146, 475, 475, 367, 411,
98098	/* 530 */ 562, 411, 358, 542, 425, 171, 411, 215, 144, 620,
98099	/* 540 */ 619, 544, 318, 353, 414, 203, 414, 275, 590, 584,
98100	/* 550 */ 549, 414, 174, 601, 94, 601, 79, 558, 471, 61,
98101	/* 560 */ 601, 79, 421, 949, 350, 949, 34, 56, 57, 47,
98102	/* 570 */ 582, 581, 583, 583, 54, 54, 55, 55, 55, 55,
98103	/* 580 */ 535, 53, 53, 53, 53, 52, 52, 51, 51, 51,
98104	/* 590 */ 50, 238, 313, 307, 424, 394, 272, 49, 46, 147,
98105	/* 600 */ 349, 322, 4, 411, 491, 312, 321, 425, 568, 492,
98106	/* 610 */ 216, 264, 407, 575, 574, 429, 66, 549, 414, 621,
98107	/* 620 */ 540, 602, 590, 584, 13, 603, 621, 601, 72, 12,
98108	/* 630 */ 618, 617, 616, 202, 210, 621, 546, 469, 422, 319,
98109	/* 640 */ 148, 56, 57, 47, 582, 581, 583, 583, 54, 54,
98110	/* 650 */ 55, 55, 55, 55, 338, 53, 53, 53, 53, 52,
98111	/* 660 */ 52, 51, 51, 51, 50, 238, 313, 600, 600, 411,
98112	/* 670 */ 39, 21, 37, 170, 237, 875, 411, 572, 572, 201,
98113	/* 680 */ 144, 473, 538, 331, 414, 474, 143, 146, 630, 628,
98114	/* 690 */ 334, 414, 353, 601, 68, 168, 590, 584, 132, 365,
98115	/* 700 */ 601, 96, 307, 423, 530, 336, 49, 46, 147, 568,
98116	/* 710 */ 406, 216, 549, 360, 529, 56, 57, 47, 582, 581,
98117	/* 720 */ 583, 583, 54, 54, 55, 55, 55, 55, 411, 53,
98118	/* 730 */ 53, 53, 53, 52, 52, 51, 51, 51, 50, 238,
98119	/* 740 */ 313, 411, 605, 414, 484, 510, 172, 422, 597, 318,
98120	/* 750 */ 496, 485, 601, 99, 411, 142, 414, 411, 231, 411,
98121	/* 760 */ 540, 411, 359, 629, 2, 601, 97, 426, 308, 414,
98122	/* 770 */ 590, 584, 414, 20, 414, 621, 414, 621, 601, 106,
98123	/* 780 */ 503, 601, 105, 601, 108, 601, 109, 204, 28, 56,
98124	/* 790 */ 57, 47, 582, 581, 583, 583, 54, 54, 55, 55,
98125	/* 800 */ 55, 55, 411, 53, 53, 53, 53, 52, 52, 51,
98126	/* 810 */ 51, 51, 50, 238, 313, 411, 597, 414, 411, 276,
98127	/* 820 */ 214, 600, 411, 366, 213, 381, 601, 134, 274, 500,
98128	/* 830 */ 414, 167, 130, 414, 621, 411, 354, 414, 376, 601,
98129	/* 840 */ 135, 129, 601, 100, 590, 584, 601, 104, 522, 521,
98130	/* 850 */ 414, 621, 224, 273, 600, 167, 327, 282, 600, 601,
98131	/* 860 */ 103, 468, 521, 56, 57, 47, 582, 581, 583, 583,
98132	/* 870 */ 54, 54, 55, 55, 55, 55, 411, 53, 53, 53,
98133	/* 880 */ 53, 52, 52, 51, 51, 51, 50, 238, 313, 411,
98134	/* 890 */ 27, 414, 411, 375, 276, 167, 359, 544, 50, 238,
98135	/* 900 */ 601, 95, 128, 223, 414, 411, 165, 414, 411, 621,
98136	/* 910 */ 411, 621, 612, 601, 102, 372, 601, 76, 590, 584,
98137	/* 920 */ 414, 570, 236, 414, 470, 414, 167, 621, 188, 601,
98138	/* 930 */ 98, 225, 601, 138, 601, 137, 232, 56, 45, 47,
98139	/* 940 */ 582, 581, 583, 583, 54, 54, 55, 55, 55, 55,
98140	/* 950 */ 411, 53, 53, 53, 53, 52, 52, 51, 51, 51,
98141	/* 960 */ 50, 238, 313, 276, 276, 414, 411, 276, 544, 459,
98142	/* 970 */ 359, 171, 209, 479, 601, 136, 628, 334, 621, 621,
98143	/* 980 */ 125, 414, 621, 368, 411, 621, 257, 540, 589, 588,
98144	/* 990 */ 601, 75, 590, 584, 458, 446, 23, 23, 124, 414,
98145	/* 1000 */ 326, 325, 621, 427, 324, 309, 600, 288, 601, 92,
98146	/* 1010 */ 586, 585, 57, 47, 582, 581, 583, 583, 54, 54,
98147	/* 1020 */ 55, 55, 55, 55, 411, 53, 53, 53, 53, 52,
98148	/* 1030 */ 52, 51, 51, 51, 50, 238, 313, 587, 411, 414,
98149	/* 1040 */ 411, 207, 611, 476, 171, 472, 160, 123, 601, 91,
98150	/* 1050 */ 323, 261, 15, 414, 464, 414, 411, 621, 411, 354,
98151	/* 1060 */ 222, 411, 601, 74, 601, 90, 590, 584, 159, 264,
98152	/* 1070 */ 158, 414, 461, 414, 621, 600, 414, 121, 120, 25,
98153	/* 1080 */ 601, 89, 601, 101, 621, 601, 88, 47, 582, 581,
98154	/* 1090 */ 583, 583, 54, 54, 55, 55, 55, 55, 544, 53,
98155	/* 1100 */ 53, 53, 53, 52, 52, 51, 51, 51, 50, 238,
98156	/* 1110 */ 43, 405, 263, 3, 610, 264, 140, 415, 622, 24,
98157	/* 1120 */ 410, 11, 456, 594, 118, 155, 219, 452, 408, 621,
98158	/* 1130 */ 621, 621, 156, 43, 405, 621, 3, 286, 621, 113,
98159	/* 1140 */ 415, 622, 111, 445, 411, 400, 557, 403, 545, 10,
98160	/* 1150 */ 411, 408, 264, 110, 205, 436, 541, 566, 453, 414,
98161	/* 1160 */ 621, 621, 63, 621, 435, 414, 411, 621, 601, 94,
98162	/* 1170 */ 403, 621, 411, 337, 601, 86, 150, 40, 41, 534,
98163	/* 1180 */ 566, 414, 242, 264, 42, 413, 412, 414, 600, 595,
98164	/* 1190 */ 601, 85, 191, 333, 107, 451, 601, 84, 621, 539,
98165	/* 1200 */ 40, 41, 420, 230, 411, 149, 316, 42, 413, 412,
98166	/* 1210 */ 398, 127, 595, 315, 621, 399, 278, 625, 181, 414,
98167	/* 1220 */ 593, 593, 593, 592, 591, 14, 450, 411, 601, 71,
98168	/* 1230 */ 240, 621, 43, 405, 264, 3, 615, 180, 264, 415,
98169	/* 1240 */ 622, 614, 414, 593, 593, 593, 592, 591, 14, 621,
98170	/* 1250 */ 408, 601, 70, 621, 417, 33, 405, 613, 3, 411,
98171	/* 1260 */ 264, 411, 415, 622, 418, 626, 178, 509, 8, 403,
98172	/* 1270 */ 241, 416, 126, 408, 414, 621, 414, 449, 208, 566,
98173	/* 1280 */ 240, 221, 621, 601, 83, 601, 82, 599, 297, 277,
98174	/* 1290 */ 296, 30, 403, 31, 395, 264, 295, 397, 489, 40,
98175	/* 1300 */ 41, 411, 566, 220, 621, 294, 42, 413, 412, 271,
98176	/* 1310 */ 621, 595, 600, 621, 59, 60, 414, 269, 267, 623,
98177	/* 1320 */ 622, 36, 40, 41, 621, 601, 81, 598, 235, 42,
98178	/* 1330 */ 413, 412, 621, 621, 595, 265, 344, 411, 248, 556,
98179	/* 1340 */ 173, 185, 593, 593, 593, 592, 591, 14, 218, 29,
98180	/* 1350 */ 621, 543, 414, 305, 304, 303, 179, 301, 411, 566,
98181	/* 1360 */ 454, 601, 80, 289, 335, 593, 593, 593, 592, 591,
98182	/* 1370 */ 14, 411, 287, 414, 151, 392, 246, 260, 411, 196,
98183	/* 1380 */ 195, 523, 601, 69, 411, 245, 414, 526, 537, 285,
98184	/* 1390 */ 389, 595, 621, 414, 536, 601, 17, 362, 153, 414,
98185	/* 1400 */ 466, 463, 601, 78, 154, 414, 462, 152, 601, 77,
98186	/* 1410 */ 355, 255, 621, 455, 601, 9, 621, 386, 444, 517,
98187	/* 1420 */ 247, 621, 593, 593, 593, 621, 621, 244, 621, 243,
98188	/* 1430 */ 430, 518, 292, 621, 329, 621, 145, 393, 280, 513,
98189	/* 1440 */ 291, 131, 621, 514, 621, 621, 311, 621, 259, 346,
98190	/* 1450 */ 249, 621, 621, 229, 314, 621, 228, 512, 227, 240,
98191	/* 1460 */ 494, 488, 310, 164, 487, 486, 373, 480, 163, 262,
98192	/* 1470 */ 369, 371, 162, 26, 212, 478, 477, 161, 141, 363,
98193	/* 1480 */ 467, 122, 339, 187, 119, 348, 347, 117, 116, 115,
98194	/* 1490 */ 114, 112, 182, 457, 320, 22, 433, 432, 448, 19,
98195	/* 1500 */ 609, 431, 428, 62, 193, 596, 573, 298, 555, 552,
98196	/* 1510 */ 571, 404, 290, 380, 498, 510, 495, 306, 281, 499,
98197	/* 1520 */ 250, 5, 497, 460, 345, 447, 569, 550, 238, 299,
98198	/* 1530 */ 527, 525, 508, 961, 502, 501, 961, 401, 961, 211,
98199	/* 1540 */ 490, 356, 256, 961, 483, 961, 961, 961, 961, 961,
98200	/* 1550 */ 961, 961, 961, 961, 961, 961, 370,
98201	};
98202	static const YYCODETYPE yy_lookahead[] = {
98203	/* 0 */ 19, 142, 143, 144, 145, 24, 1, 26, 77, 78,
98204	/* 10 */ 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
98205	/* 20 */ 89, 90, 91, 92, 15, 98, 26, 27, 7, 8,
98206	/* 30 */ 49, 50, 77, 78, 79, 80, 109, 82, 83, 84,
98207	/* 40 */ 85, 86, 87, 88, 89, 90, 91, 92, 22, 68,
98208	/* 50 */ 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
98209	/* 60 */ 79, 80, 23, 82, 83, 84, 85, 86, 87, 88,
98210	/* 70 */ 89, 90, 91, 92, 19, 94, 112, 19, 114, 115,
98211	/* 80 */ 25, 82, 83, 84, 85, 86, 87, 88, 89, 90,
98212	/* 90 */ 91, 92, 19, 22, 94, 95, 96, 150, 150, 99,
98213	/* 100 */ 100, 101, 76, 150, 49, 50, 105, 106, 107, 54,
98214	/* 110 */ 110, 158, 165, 165, 161, 162, 26, 27, 165, 113,
98215	/* 120 */ 16, 174, 175, 68, 69, 70, 71, 72, 73, 74,
98216	/* 130 */ 75, 76, 77, 78, 79, 80, 118, 82, 83, 84,
98217	/* 140 */ 85, 86, 87, 88, 89, 90, 91, 92, 19, 23,
98218	/* 150 */ 92, 97, 98, 24, 96, 97, 98, 99, 100, 101,
98219	/* 160 */ 102, 25, 97, 216, 60, 92, 62, 109, 221, 25,
98220	/* 170 */ 97, 98, 99, 100, 101, 102, 86, 87, 49, 50,
98221	/* 180 */ 118, 116, 109, 25, 94, 95, 32, 97, 88, 89,
98222	/* 190 */ 90, 91, 92, 128, 104, 41, 106, 68, 69, 70,
98223	/* 200 */ 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
98224	/* 210 */ 11, 82, 83, 84, 85, 86, 87, 88, 89, 90,
98225	/* 220 */ 91, 92, 19, 19, 86, 87, 88, 89, 90, 91,
98226	/* 230 */ 92, 27, 96, 150, 66, 99, 100, 101, 112, 150,
98227	/* 240 */ 114, 115, 138, 150, 161, 162, 110, 103, 165, 222,
98228	/* 250 */ 223, 224, 49, 50, 165, 22, 57, 24, 165, 170,
98229	/* 260 */ 171, 118, 94, 170, 171, 23, 98, 25, 185, 186,
98230	/* 270 */ 243, 68, 69, 70, 71, 72, 73, 74, 75, 76,
98231	/* 280 */ 77, 78, 79, 80, 126, 82, 83, 84, 85, 86,
98232	/* 290 */ 87, 88, 89, 90, 91, 92, 19, 129, 130, 131,
98233	/* 300 */ 88, 23, 172, 173, 105, 106, 107, 150, 22, 26,
98234	/* 310 */ 27, 181, 26, 27, 22, 116, 26, 27, 26, 230,
98235	/* 320 */ 231, 197, 165, 230, 231, 113, 49, 50, 204, 117,
98236	/* 330 */ 96, 174, 175, 99, 100, 101, 22, 26, 27, 136,
98237	/* 340 */ 26, 27, 118, 16, 110, 68, 69, 70, 71, 72,
98238	/* 350 */ 73, 74, 75, 76, 77, 78, 79, 80, 118, 82,
98239	/* 360 */ 83, 84, 85, 86, 87, 88, 89, 90, 91, 92,
98240	/* 370 */ 19, 214, 215, 150, 23, 23, 155, 94, 95, 22,
98241	/* 380 */ 94, 95, 116, 160, 94, 95, 94, 60, 165, 62,
98242	/* 390 */ 112, 26, 114, 115, 128, 23, 36, 174, 175, 88,
98243	/* 400 */ 49, 50, 57, 120, 22, 94, 95, 23, 94, 95,
98244	/* 410 */ 120, 51, 25, 136, 169, 170, 171, 194, 58, 68,
98245	/* 420 */ 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
98246	/* 430 */ 79, 80, 23, 82, 83, 84, 85, 86, 87, 88,
98247	/* 440 */ 89, 90, 91, 92, 19, 150, 12, 12, 23, 228,
98248	/* 450 */ 105, 106, 107, 23, 233, 25, 165, 19, 150, 94,
98249	/* 460 */ 165, 116, 28, 28, 112, 174, 114, 115, 108, 174,
98250	/* 470 */ 175, 26, 27, 165, 49, 50, 231, 11, 44, 44,
98251	/* 480 */ 46, 46, 174, 175, 112, 160, 114, 115, 50, 22,
98252	/* 490 */ 23, 57, 25, 68, 69, 70, 71, 72, 73, 74,
98253	/* 500 */ 75, 76, 77, 78, 79, 80, 119, 82, 83, 84,
98254	/* 510 */ 85, 86, 87, 88, 89, 90, 91, 92, 19, 194,
98255	/* 520 */ 225, 23, 23, 215, 19, 95, 105, 106, 107, 150,
98256	/* 530 */ 23, 150, 27, 23, 67, 25, 150, 206, 207, 94,
98257	/* 540 */ 95, 166, 104, 218, 165, 22, 165, 109, 49, 50,
98258	/* 550 */ 120, 165, 25, 174, 175, 174, 175, 23, 21, 234,
98259	/* 560 */ 174, 175, 22, 23, 239, 25, 25, 68, 69, 70,
98260	/* 570 */ 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
98261	/* 580 */ 205, 82, 83, 84, 85, 86, 87, 88, 89, 90,
98262	/* 590 */ 91, 92, 19, 22, 23, 216, 23, 222, 223, 224,
98263	/* 600 */ 63, 220, 35, 150, 150, 163, 220, 67, 166, 167,
98264	/* 610 */ 168, 150, 169, 170, 171, 161, 162, 25, 165, 165,
98265	/* 620 */ 150, 113, 49, 50, 25, 117, 165, 174, 175, 35,
98266	/* 630 */ 7, 8, 9, 160, 160, 165, 120, 100, 67, 247,
98267	/* 640 */ 248, 68, 69, 70, 71, 72, 73, 74, 75, 76,
98268	/* 650 */ 77, 78, 79, 80, 193, 82, 83, 84, 85, 86,
98269	/* 660 */ 87, 88, 89, 90, 91, 92, 19, 194, 194, 150,
98270	/* 670 */ 135, 24, 137, 35, 231, 138, 150, 129, 130, 206,
98271	/* 680 */ 207, 30, 27, 213, 165, 34, 118, 95, 0, 1,
98272	/* 690 */ 2, 165, 218, 174, 175, 50, 49, 50, 22, 48,
98273	/* 700 */ 174, 175, 22, 23, 23, 244, 222, 223, 224, 166,
98274	/* 710 */ 167, 168, 120, 239, 23, 68, 69, 70, 71, 72,
98275	/* 720 */ 73, 74, 75, 76, 77, 78, 79, 80, 150, 82,
98276	/* 730 */ 83, 84, 85, 86, 87, 88, 89, 90, 91, 92,
98277	/* 740 */ 19, 150, 173, 165, 181, 182, 24, 67, 26, 104,
98278	/* 750 */ 181, 188, 174, 175, 150, 39, 165, 150, 52, 150,
98279	/* 760 */ 150, 150, 150, 144, 145, 174, 175, 249, 250, 165,
98280	/* 770 */ 49, 50, 165, 52, 165, 165, 165, 165, 174, 175,
98281	/* 780 */ 29, 174, 175, 174, 175, 174, 175, 160, 22, 68,
98282	/* 790 */ 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
98283	/* 800 */ 79, 80, 150, 82, 83, 84, 85, 86, 87, 88,
98284	/* 810 */ 89, 90, 91, 92, 19, 150, 94, 165, 150, 150,
98285	/* 820 */ 160, 194, 150, 213, 160, 52, 174, 175, 23, 23,
98286	/* 830 */ 165, 25, 22, 165, 165, 150, 150, 165, 52, 174,
98287	/* 840 */ 175, 22, 174, 175, 49, 50, 174, 175, 190, 191,
98288	/* 850 */ 165, 165, 240, 23, 194, 25, 187, 109, 194, 174,
98289	/* 860 */ 175, 190, 191, 68, 69, 70, 71, 72, 73, 74,
98290	/* 870 */ 75, 76, 77, 78, 79, 80, 150, 82, 83, 84,
98291	/* 880 */ 85, 86, 87, 88, 89, 90, 91, 92, 19, 150,
98292	/* 890 */ 22, 165, 150, 23, 150, 25, 150, 166, 91, 92,
98293	/* 900 */ 174, 175, 22, 217, 165, 150, 102, 165, 150, 165,
98294	/* 910 */ 150, 165, 150, 174, 175, 19, 174, 175, 49, 50,
98295	/* 920 */ 165, 86, 87, 165, 23, 165, 25, 165, 24, 174,
98296	/* 930 */ 175, 187, 174, 175, 174, 175, 205, 68, 69, 70,
98297	/* 940 */ 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
98298	/* 950 */ 150, 82, 83, 84, 85, 86, 87, 88, 89, 90,
98299	/* 960 */ 91, 92, 19, 150, 150, 165, 150, 150, 166, 23,
98300	/* 970 */ 150, 25, 160, 20, 174, 175, 1, 2, 165, 165,
98301	/* 980 */ 104, 165, 165, 43, 150, 165, 240, 150, 49, 50,
98302	/* 990 */ 174, 175, 49, 50, 23, 23, 25, 25, 53, 165,
98303	/* 1000 */ 187, 187, 165, 23, 187, 25, 194, 205, 174, 175,
98304	/* 1010 */ 71, 72, 69, 70, 71, 72, 73, 74, 75, 76,
98305	/* 1020 */ 77, 78, 79, 80, 150, 82, 83, 84, 85, 86,
98306	/* 1030 */ 87, 88, 89, 90, 91, 92, 19, 98, 150, 165,
98307	/* 1040 */ 150, 160, 150, 59, 25, 53, 104, 22, 174, 175,
98308	/* 1050 */ 213, 138, 5, 165, 1, 165, 150, 165, 150, 150,
98309	/* 1060 */ 240, 150, 174, 175, 174, 175, 49, 50, 118, 150,
98310	/* 1070 */ 35, 165, 27, 165, 165, 194, 165, 108, 127, 76,
98311	/* 1080 */ 174, 175, 174, 175, 165, 174, 175, 70, 71, 72,
98312	/* 1090 */ 73, 74, 75, 76, 77, 78, 79, 80, 166, 82,
98313	/* 1100 */ 83, 84, 85, 86, 87, 88, 89, 90, 91, 92,
98314	/* 1110 */ 19, 20, 193, 22, 150, 150, 150, 26, 27, 76,
98315	/* 1120 */ 150, 22, 1, 150, 119, 121, 217, 20, 37, 165,
98316	/* 1130 */ 165, 165, 16, 19, 20, 165, 22, 205, 165, 119,
98317	/* 1140 */ 26, 27, 108, 128, 150, 150, 150, 56, 150, 22,
98318	/* 1150 */ 150, 37, 150, 127, 160, 23, 150, 66, 193, 165,
98319	/* 1160 */ 165, 165, 16, 165, 23, 165, 150, 165, 174, 175,
98320	/* 1170 */ 56, 165, 150, 65, 174, 175, 15, 86, 87, 88,
98321	/* 1180 */ 66, 165, 140, 150, 93, 94, 95, 165, 194, 98,
98322	/* 1190 */ 174, 175, 22, 3, 164, 193, 174, 175, 165, 150,
98323	/* 1200 */ 86, 87, 4, 180, 150, 248, 251, 93, 94, 95,
98324	/* 1210 */ 216, 180, 98, 251, 165, 221, 150, 149, 6, 165,
98325	/* 1220 */ 129, 130, 131, 132, 133, 134, 193, 150, 174, 175,
98326	/* 1230 */ 116, 165, 19, 20, 150, 22, 149, 151, 150, 26,
98327	/* 1240 */ 27, 149, 165, 129, 130, 131, 132, 133, 134, 165,
98328	/* 1250 */ 37, 174, 175, 165, 149, 19, 20, 13, 22, 150,
98329	/* 1260 */ 150, 150, 26, 27, 146, 147, 151, 150, 25, 56,
98330	/* 1270 */ 152, 159, 154, 37, 165, 165, 165, 193, 160, 66,
98331	/* 1280 */ 116, 193, 165, 174, 175, 174, 175, 194, 199, 150,
98332	/* 1290 */ 200, 126, 56, 124, 123, 150, 201, 122, 150, 86,
98333	/* 1300 */ 87, 150, 66, 193, 165, 202, 93, 94, 95, 150,
98334	/* 1310 */ 165, 98, 194, 165, 125, 22, 165, 150, 150, 26,
98335	/* 1320 */ 27, 135, 86, 87, 165, 174, 175, 203, 226, 93,
98336	/* 1330 */ 94, 95, 165, 165, 98, 150, 218, 150, 193, 157,
98337	/* 1340 */ 118, 157, 129, 130, 131, 132, 133, 134, 5, 104,
98338	/* 1350 */ 165, 211, 165, 10, 11, 12, 13, 14, 150, 66,
98339	/* 1360 */ 17, 174, 175, 210, 246, 129, 130, 131, 132, 133,
98340	/* 1370 */ 134, 150, 210, 165, 31, 121, 33, 150, 150, 86,
98341	/* 1380 */ 87, 176, 174, 175, 150, 42, 165, 94, 211, 210,
98342	/* 1390 */ 150, 98, 165, 165, 211, 174, 175, 150, 55, 165,
98343	/* 1400 */ 57, 150, 174, 175, 61, 165, 150, 64, 174, 175,
98344	/* 1410 */ 150, 150, 165, 150, 174, 175, 165, 104, 150, 184,
98345	/* 1420 */ 150, 165, 129, 130, 131, 165, 165, 150, 165, 150,
98346	/* 1430 */ 150, 176, 150, 165, 47, 165, 150, 150, 176, 103,
98347	/* 1440 */ 150, 22, 165, 178, 165, 165, 179, 165, 105, 106,
98348	/* 1450 */ 107, 165, 165, 229, 111, 165, 92, 176, 229, 116,
98349	/* 1460 */ 184, 176, 179, 156, 176, 176, 18, 157, 156, 237,
98350	/* 1470 */ 45, 157, 156, 135, 157, 157, 238, 156, 68, 157,
98351	/* 1480 */ 189, 189, 139, 219, 22, 157, 18, 192, 192, 192,
98352	/* 1490 */ 192, 189, 219, 199, 157, 242, 40, 157, 199, 242,
98353	/* 1500 */ 153, 157, 38, 245, 196, 166, 232, 198, 177, 177,
98354	/* 1510 */ 232, 227, 209, 178, 166, 182, 166, 148, 177, 177,
98355	/* 1520 */ 209, 196, 177, 199, 209, 199, 166, 208, 92, 195,
98356	/* 1530 */ 174, 174, 183, 252, 183, 183, 252, 191, 252, 235,
98357	/* 1540 */ 186, 241, 241, 252, 186, 252, 252, 252, 252, 252,
98358	/* 1550 */ 252, 252, 252, 252, 252, 252, 236,
98359	};
98360	#define YY_SHIFT_USE_DFLT (-74)
98361	#define YY_SHIFT_COUNT (418)
98362	#define YY_SHIFT_MIN (-73)
98363	#define YY_SHIFT_MAX (1468)
98364	static const short yy_shift_ofst[] = {
98365	/* 0 */ 975, 1114, 1343, 1114, 1213, 1213, 90, 90, 0, -19,
98366	/* 10 */ 1213, 1213, 1213, 1213, 1213, 345, 445, 721, 1091, 1213,
98367	/* 20 */ 1213, 1213, 1213, 1213, 1213, 1213, 1213, 1213, 1213, 1213,
98368	/* 30 */ 1213, 1213, 1213, 1213, 1213, 1213, 1213, 1213, 1213, 1213,
98369	/* 40 */ 1213, 1213, 1213, 1213, 1213, 1213, 1213, 1236, 1213, 1213,
98370	/* 50 */ 1213, 1213, 1213, 1213, 1213, 1213, 1213, 1213, 1213, 1213,
98371	/* 60 */ 1213, 199, 445, 445, 835, 835, 365, 1164, 55, 647,
98372	/* 70 */ 573, 499, 425, 351, 277, 203, 129, 795, 795, 795,
98373	/* 80 */ 795, 795, 795, 795, 795, 795, 795, 795, 795, 795,
98374	/* 90 */ 795, 795, 795, 795, 795, 869, 795, 943, 1017, 1017,
98375	/* 100 */ -69, -45, -45, -45, -45, -45, -1, 58, 138, 100,
98376	/* 110 */ 445, 445, 445, 445, 445, 445, 445, 445, 445, 445,
98377	/* 120 */ 445, 445, 445, 445, 445, 445, 537, 438, 445, 445,
98378	/* 130 */ 445, 445, 445, 365, 807, 1436, -74, -74, -74, 1293,
98379	/* 140 */ 73, 434, 434, 311, 314, 290, 283, 286, 540, 467,
98380	/* 150 */ 445, 445, 445, 445, 445, 445, 445, 445, 445, 445,
98381	/* 160 */ 445, 445, 445, 445, 445, 445, 445, 445, 445, 445,
98382	/* 170 */ 445, 445, 445, 445, 445, 445, 445, 445, 445, 445,
98383	/* 180 */ 445, 445, 65, 722, 722, 722, 688, 266, 1164, 1164,
98384	/* 190 */ 1164, -74, -74, -74, 136, 168, 168, 234, 360, 360,
98385	/* 200 */ 360, 430, 372, 435, 352, 278, 126, -36, -36, -36,
98386	/* 210 */ -36, 421, 651, -36, -36, 592, 292, 212, 623, 158,
98387	/* 220 */ 204, 204, 505, 158, 505, 144, 365, 154, 365, 154,
98388	/* 230 */ 645, 154, 204, 154, 154, 535, 548, 548, 365, 387,
98389	/* 240 */ 508, 233, 1464, 1222, 1222, 1456, 1456, 1222, 1462, 1410,
98390	/* 250 */ 1165, 1468, 1468, 1468, 1468, 1222, 1165, 1462, 1410, 1410,
98391	/* 260 */ 1222, 1448, 1338, 1425, 1222, 1222, 1448, 1222, 1448, 1222,
98392	/* 270 */ 1448, 1419, 1313, 1313, 1313, 1387, 1364, 1364, 1419, 1313,
98393	/* 280 */ 1336, 1313, 1387, 1313, 1313, 1254, 1245, 1254, 1245, 1254,
98394	/* 290 */ 1245, 1222, 1222, 1186, 1189, 1175, 1169, 1171, 1165, 1164,
98395	/* 300 */ 1243, 1244, 1244, 1212, 1212, 1212, 1212, -74, -74, -74,
98396	/* 310 */ -74, -74, -74, 939, 104, 680, 571, 327, 1, 980,
98397	/* 320 */ 26, 972, 971, 946, 901, 870, 830, 806, 54, 21,
98398	/* 330 */ -73, 510, 242, 1198, 1190, 1170, 1042, 1161, 1108, 1146,
98399	/* 340 */ 1141, 1132, 1015, 1127, 1026, 1034, 1020, 1107, 1004, 1116,
98400	/* 350 */ 1121, 1005, 1099, 951, 1043, 1003, 969, 1045, 1035, 950,
98401	/* 360 */ 1053, 1047, 1025, 942, 913, 992, 1019, 945, 984, 940,
98402	/* 370 */ 876, 904, 953, 896, 748, 804, 880, 786, 868, 819,
98403	/* 380 */ 805, 810, 773, 751, 766, 706, 716, 691, 681, 568,
98404	/* 390 */ 655, 638, 676, 516, 541, 594, 599, 567, 541, 534,
98405	/* 400 */ 507, 527, 498, 523, 466, 382, 409, 384, 357, 6,
98406	/* 410 */ 240, 224, 143, 62, 18, 71, 39, 9, 5,
98407	};
98408	#define YY_REDUCE_USE_DFLT (-142)
98409	#define YY_REDUCE_COUNT (312)
98410	#define YY_REDUCE_MIN (-141)
98411	#define YY_REDUCE_MAX (1369)
98412	static const short yy_reduce_ofst[] = {
98413	/* 0 */ -141, 994, 1118, 223, 157, -53, 93, 89, 83, 375,
98414	/* 10 */ 386, 381, 379, 308, 295, 325, -47, 27, 1240, 1234,
98415	/* 20 */ 1228, 1221, 1208, 1187, 1151, 1111, 1109, 1077, 1054, 1022,
98416	/* 30 */ 1016, 1000, 911, 908, 906, 890, 888, 874, 834, 816,
98417	/* 40 */ 800, 760, 758, 755, 742, 739, 726, 685, 672, 668,
98418	/* 50 */ 665, 652, 611, 609, 607, 604, 591, 578, 526, 519,
98419	/* 60 */ 453, 474, 454, 461, 443, 245, 442, 473, 484, 484,
98420	/* 70 */ 484, 484, 484, 484, 484, 484, 484, 484, 484, 484,
98421	/* 80 */ 484, 484, 484, 484, 484, 484, 484, 484, 484, 484,
98422	/* 90 */ 484, 484, 484, 484, 484, 484, 484, 484, 484, 484,
98423	/* 100 */ 484, 484, 484, 484, 484, 484, 484, 130, 484, 484,
98424	/* 110 */ 1145, 909, 1110, 1088, 1084, 1033, 1002, 965, 820, 837,
98425	/* 120 */ 746, 686, 612, 817, 610, 919, 221, 563, 814, 813,
98426	/* 130 */ 744, 669, 470, 543, 484, 484, 484, 484, 484, 291,
98427	/* 140 */ 569, 671, 658, 970, 1290, 1287, 1286, 1282, 518, 518,
98428	/* 150 */ 1280, 1279, 1277, 1270, 1268, 1263, 1261, 1260, 1256, 1251,
98429	/* 160 */ 1247, 1227, 1185, 1168, 1167, 1159, 1148, 1139, 1117, 1066,
98430	/* 170 */ 1049, 1006, 998, 996, 995, 973, 970, 966, 964, 892,
98431	/* 180 */ 762, -52, 881, 932, 802, 731, 619, 812, 664, 660,
98432	/* 190 */ 627, 392, 331, 124, 1358, 1357, 1356, 1354, 1352, 1351,
98433	/* 200 */ 1349, 1319, 1334, 1346, 1334, 1334, 1334, 1334, 1334, 1334,
98434	/* 210 */ 1334, 1320, 1304, 1334, 1334, 1319, 1360, 1325, 1369, 1326,
98435	/* 220 */ 1315, 1311, 1301, 1324, 1300, 1335, 1350, 1345, 1348, 1342,
98436	/* 230 */ 1333, 1341, 1303, 1332, 1331, 1284, 1278, 1274, 1339, 1309,
98437	/* 240 */ 1308, 1347, 1258, 1344, 1340, 1257, 1253, 1337, 1273, 1302,
98438	/* 250 */ 1299, 1298, 1297, 1296, 1295, 1328, 1294, 1264, 1292, 1291,
98439	/* 260 */ 1322, 1321, 1238, 1232, 1318, 1317, 1316, 1314, 1312, 1310,
98440	/* 270 */ 1307, 1283, 1289, 1288, 1285, 1276, 1229, 1224, 1267, 1281,
98441	/* 280 */ 1265, 1262, 1235, 1255, 1205, 1183, 1179, 1177, 1162, 1140,
98442	/* 290 */ 1153, 1184, 1182, 1102, 1124, 1103, 1095, 1090, 1089, 1093,
98443	/* 300 */ 1112, 1115, 1086, 1105, 1092, 1087, 1068, 962, 955, 957,
98444	/* 310 */ 1031, 1023, 1030,
98445	};
98446	static const YYACTIONTYPE yy_default[] = {
98447	/* 0 */ 635, 870, 959, 959, 959, 870, 899, 899, 959, 759,
98448	/* 10 */ 959, 959, 959, 959, 868, 959, 959, 933, 959, 959,
98449	/* 20 */ 959, 959, 959, 959, 959, 959, 959, 959, 959, 959,
98450	/* 30 */ 959, 959, 959, 959, 959, 959, 959, 959, 959, 959,
98451	/* 40 */ 959, 959, 959, 959, 959, 959, 959, 959, 959, 959,
98452	/* 50 */ 959, 959, 959, 959, 959, 959, 959, 959, 959, 959,
98453	/* 60 */ 959, 959, 959, 959, 899, 899, 674, 763, 794, 959,
98454	/* 70 */ 959, 959, 959, 959, 959, 959, 959, 932, 934, 809,
98455	/* 80 */ 808, 802, 801, 912, 774, 799, 792, 785, 796, 871,
98456	/* 90 */ 864, 865, 863, 867, 872, 959, 795, 831, 848, 830,
98457	/* 100 */ 842, 847, 854, 846, 843, 833, 832, 666, 834, 835,
98458	/* 110 */ 959, 959, 959, 959, 959, 959, 959, 959, 959, 959,
98459	/* 120 */ 959, 959, 959, 959, 959, 959, 661, 728, 959, 959,
98460	/* 130 */ 959, 959, 959, 959, 836, 837, 851, 850, 849, 959,
98461	/* 140 */ 959, 959, 959, 959, 959, 959, 959, 959, 959, 959,
98462	/* 150 */ 959, 939, 937, 959, 883, 959, 959, 959, 959, 959,
98463	/* 160 */ 959, 959, 959, 959, 959, 959, 959, 959, 959, 959,
98464	/* 170 */ 959, 959, 959, 959, 959, 959, 959, 959, 959, 959,
98465	/* 180 */ 959, 641, 959, 759, 759, 759, 635, 959, 959, 959,
98466	/* 190 */ 959, 951, 763, 753, 719, 959, 959, 959, 959, 959,
98467	/* 200 */ 959, 959, 959, 959, 959, 959, 959, 804, 742, 922,
98468	/* 210 */ 924, 959, 905, 740, 663, 761, 676, 751, 643, 798,
98469	/* 220 */ 776, 776, 917, 798, 917, 700, 959, 788, 959, 788,
98470	/* 230 */ 697, 788, 776, 788, 788, 866, 959, 959, 959, 760,
98471	/* 240 */ 751, 959, 944, 767, 767, 936, 936, 767, 810, 732,
98472	/* 250 */ 798, 739, 739, 739, 739, 767, 798, 810, 732, 732,
98473	/* 260 */ 767, 658, 911, 909, 767, 767, 658, 767, 658, 767,
98474	/* 270 */ 658, 876, 730, 730, 730, 715, 880, 880, 876, 730,
98475	/* 280 */ 700, 730, 715, 730, 730, 780, 775, 780, 775, 780,
98476	/* 290 */ 775, 767, 767, 959, 793, 781, 791, 789, 798, 959,
98477	/* 300 */ 718, 651, 651, 640, 640, 640, 640, 956, 956, 951,
98478	/* 310 */ 702, 702, 684, 959, 959, 959, 959, 959, 959, 959,
98479	/* 320 */ 885, 959, 959, 959, 959, 959, 959, 959, 959, 959,
98480	/* 330 */ 959, 959, 959, 959, 636, 946, 959, 959, 943, 959,
98481	/* 340 */ 959, 959, 959, 959, 959, 959, 959, 959, 959, 959,
98482	/* 350 */ 959, 959, 959, 959, 959, 959, 959, 959, 959, 915,
98483	/* 360 */ 959, 959, 959, 959, 959, 959, 908, 907, 959, 959,
98484	/* 370 */ 959, 959, 959, 959, 959, 959, 959, 959, 959, 959,
98485	/* 380 */ 959, 959, 959, 959, 959, 959, 959, 959, 959, 959,
98486	/* 390 */ 959, 959, 959, 959, 790, 959, 782, 959, 869, 959,
98487	/* 400 */ 959, 959, 959, 959, 959, 959, 959, 959, 959, 745,
98488	/* 410 */ 819, 959, 818, 822, 817, 668, 959, 649, 959, 632,
98489	/* 420 */ 637, 955, 958, 957, 954, 953, 952, 947, 945, 942,
98490	/* 430 */ 941, 940, 938, 935, 931, 889, 887, 894, 893, 892,
98491	/* 440 */ 891, 890, 888, 886, 884, 805, 803, 800, 797, 930,
98492	/* 450 */ 882, 741, 738, 737, 657, 948, 914, 923, 921, 811,
98493	/* 460 */ 920, 919, 918, 916, 913, 900, 807, 806, 733, 874,
98494	/* 470 */ 873, 660, 904, 903, 902, 906, 910, 901, 769, 659,
98495	/* 480 */ 656, 665, 722, 721, 729, 727, 726, 725, 724, 723,
98496	/* 490 */ 720, 667, 675, 686, 714, 699, 698, 879, 881, 878,
98497	/* 500 */ 877, 707, 706, 712, 711, 710, 709, 708, 705, 704,
98498	/* 510 */ 703, 696, 695, 701, 694, 717, 716, 713, 693, 736,
98499	/* 520 */ 735, 734, 731, 692, 691, 690, 822, 689, 688, 828,
98500	/* 530 */ 827, 815, 858, 756, 755, 754, 766, 765, 778, 777,
98501	/* 540 */ 813, 812, 779, 764, 758, 757, 773, 772, 771, 770,
98502	/* 550 */ 762, 752, 784, 787, 786, 783, 860, 768, 857, 929,
98503	/* 560 */ 928, 927, 926, 925, 862, 861, 829, 826, 679, 680,
98504	/* 570 */ 898, 896, 897, 895, 682, 681, 678, 677, 859, 747,
98505	/* 580 */ 746, 855, 852, 844, 840, 856, 853, 845, 841, 839,
98506	/* 590 */ 838, 824, 823, 821, 820, 816, 825, 670, 748, 744,
98507	/* 600 */ 743, 814, 750, 749, 687, 685, 683, 664, 662, 655,
98508	/* 610 */ 653, 652, 654, 650, 648, 647, 646, 645, 644, 673,
98509	/* 620 */ 672, 671, 669, 668, 642, 639, 638, 634, 633, 631,

98510	};
98511
98512	/* The next table maps tokens into fallback tokens. If a construct
98513	** like the following:
98514	**
	@@ -98491,19 +98718,18 @@
98718	"groupby_opt", "having_opt", "orderby_opt", "limit_opt",
98719	"sclp", "as", "seltablist", "stl_prefix",
98720	"joinop", "indexed_opt", "on_opt", "using_opt",
98721	"joinop2", "inscollist", "sortlist", "sortitem",
98722	"nexprlist", "setlist", "insert_cmd", "inscollist_opt",
98723	"itemlist", "exprlist", "likeop", "between_op",
98724	"in_op", "case_operand", "case_exprlist", "case_else",
98725	"uniqueflag", "collate", "nmnum", "plus_opt",
98726	"number", "trigger_decl", "trigger_cmd_list", "trigger_time",
98727	"trigger_event", "foreach_clause", "when_clause", "trigger_cmd",
98728	"trnm", "tridxby", "database_kw_opt", "key_opt",
98729	"add_column_fullname", "kwcolumn_opt", "create_vtab", "vtabarglist",
98730	"vtabarg", "vtabargtoken", "lp", "anylist",

98731	};
98732	#endif /* NDEBUG */
98733
98734	#ifndef NDEBUG
98735	/* For tracing reduce actions, the names of all rules are required.
	@@ -98719,128 +98945,127 @@
98945	/* 207 */ "expr ::= expr CONCAT expr",
98946	/* 208 */ "likeop ::= LIKE_KW",
98947	/* 209 */ "likeop ::= NOT LIKE_KW",
98948	/* 210 */ "likeop ::= MATCH",
98949	/* 211 */ "likeop ::= NOT MATCH",
98950	/* 212 */ "expr ::= expr likeop expr",
98951	/* 213 */ "expr ::= expr likeop expr ESCAPE expr",
98952	/* 214 */ "expr ::= expr ISNULL\|NOTNULL",
98953	/* 215 */ "expr ::= expr NOT NULL",
98954	/* 216 */ "expr ::= expr IS expr",
98955	/* 217 */ "expr ::= expr IS NOT expr",
98956	/* 218 */ "expr ::= NOT expr",
98957	/* 219 */ "expr ::= BITNOT expr",
98958	/* 220 */ "expr ::= MINUS expr",
98959	/* 221 */ "expr ::= PLUS expr",
98960	/* 222 */ "between_op ::= BETWEEN",
98961	/* 223 */ "between_op ::= NOT BETWEEN",
98962	/* 224 */ "expr ::= expr between_op expr AND expr",
98963	/* 225 */ "in_op ::= IN",
98964	/* 226 */ "in_op ::= NOT IN",
98965	/* 227 */ "expr ::= expr in_op LP exprlist RP",
98966	/* 228 */ "expr ::= LP select RP",
98967	/* 229 */ "expr ::= expr in_op LP select RP",
98968	/* 230 */ "expr ::= expr in_op nm dbnm",
98969	/* 231 */ "expr ::= EXISTS LP select RP",
98970	/* 232 */ "expr ::= CASE case_operand case_exprlist case_else END",
98971	/* 233 */ "case_exprlist ::= case_exprlist WHEN expr THEN expr",
98972	/* 234 */ "case_exprlist ::= WHEN expr THEN expr",
98973	/* 235 */ "case_else ::= ELSE expr",
98974	/* 236 */ "case_else ::=",
98975	/* 237 */ "case_operand ::= expr",
98976	/* 238 */ "case_operand ::=",
98977	/* 239 */ "exprlist ::= nexprlist",
98978	/* 240 */ "exprlist ::=",
98979	/* 241 */ "nexprlist ::= nexprlist COMMA expr",
98980	/* 242 */ "nexprlist ::= expr",
98981	/* 243 */ "cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP idxlist RP",
98982	/* 244 */ "uniqueflag ::= UNIQUE",
98983	/* 245 */ "uniqueflag ::=",
98984	/* 246 */ "idxlist_opt ::=",
98985	/* 247 */ "idxlist_opt ::= LP idxlist RP",
98986	/* 248 */ "idxlist ::= idxlist COMMA nm collate sortorder",
98987	/* 249 */ "idxlist ::= nm collate sortorder",
98988	/* 250 */ "collate ::=",
98989	/* 251 */ "collate ::= COLLATE ids",
98990	/* 252 */ "cmd ::= DROP INDEX ifexists fullname",
98991	/* 253 */ "cmd ::= VACUUM",
98992	/* 254 */ "cmd ::= VACUUM nm",
98993	/* 255 */ "cmd ::= PRAGMA nm dbnm",
98994	/* 256 */ "cmd ::= PRAGMA nm dbnm EQ nmnum",
98995	/* 257 */ "cmd ::= PRAGMA nm dbnm LP nmnum RP",
98996	/* 258 */ "cmd ::= PRAGMA nm dbnm EQ minus_num",
98997	/* 259 */ "cmd ::= PRAGMA nm dbnm LP minus_num RP",
98998	/* 260 */ "nmnum ::= plus_num",
98999	/* 261 */ "nmnum ::= nm",
99000	/* 262 */ "nmnum ::= ON",
99001	/* 263 */ "nmnum ::= DELETE",
99002	/* 264 */ "nmnum ::= DEFAULT",
99003	/* 265 */ "plus_num ::= plus_opt number",
99004	/* 266 */ "minus_num ::= MINUS number",
99005	/* 267 */ "number ::= INTEGER\|FLOAT",
99006	/* 268 */ "plus_opt ::= PLUS",
99007	/* 269 */ "plus_opt ::=",
99008	/* 270 */ "cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END",
99009	/* 271 */ "trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause",
99010	/* 272 */ "trigger_time ::= BEFORE",
99011	/* 273 */ "trigger_time ::= AFTER",
99012	/* 274 */ "trigger_time ::= INSTEAD OF",
99013	/* 275 */ "trigger_time ::=",
99014	/* 276 */ "trigger_event ::= DELETE\|INSERT",
99015	/* 277 */ "trigger_event ::= UPDATE",
99016	/* 278 */ "trigger_event ::= UPDATE OF inscollist",
99017	/* 279 */ "foreach_clause ::=",
99018	/* 280 */ "foreach_clause ::= FOR EACH ROW",
99019	/* 281 */ "when_clause ::=",
99020	/* 282 */ "when_clause ::= WHEN expr",
99021	/* 283 */ "trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI",
99022	/* 284 */ "trigger_cmd_list ::= trigger_cmd SEMI",
99023	/* 285 */ "trnm ::= nm",
99024	/* 286 */ "trnm ::= nm DOT nm",
99025	/* 287 */ "tridxby ::=",
99026	/* 288 */ "tridxby ::= INDEXED BY nm",
99027	/* 289 */ "tridxby ::= NOT INDEXED",
99028	/* 290 */ "trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist where_opt",
99029	/* 291 */ "trigger_cmd ::= insert_cmd INTO trnm inscollist_opt VALUES LP itemlist RP",
99030	/* 292 */ "trigger_cmd ::= insert_cmd INTO trnm inscollist_opt select",
99031	/* 293 */ "trigger_cmd ::= DELETE FROM trnm tridxby where_opt",
99032	/* 294 */ "trigger_cmd ::= select",
99033	/* 295 */ "expr ::= RAISE LP IGNORE RP",
99034	/* 296 */ "expr ::= RAISE LP raisetype COMMA nm RP",
99035	/* 297 */ "raisetype ::= ROLLBACK",
99036	/* 298 */ "raisetype ::= ABORT",
99037	/* 299 */ "raisetype ::= FAIL",
99038	/* 300 */ "cmd ::= DROP TRIGGER ifexists fullname",
99039	/* 301 */ "cmd ::= ATTACH database_kw_opt expr AS expr key_opt",
99040	/* 302 */ "cmd ::= DETACH database_kw_opt expr",
99041	/* 303 */ "key_opt ::=",
99042	/* 304 */ "key_opt ::= KEY expr",
99043	/* 305 */ "database_kw_opt ::= DATABASE",
99044	/* 306 */ "database_kw_opt ::=",
99045	/* 307 */ "cmd ::= REINDEX",
99046	/* 308 */ "cmd ::= REINDEX nm dbnm",
99047	/* 309 */ "cmd ::= ANALYZE",
99048	/* 310 */ "cmd ::= ANALYZE nm dbnm",
99049	/* 311 */ "cmd ::= ALTER TABLE fullname RENAME TO nm",
99050	/* 312 */ "cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt column",
99051	/* 313 */ "add_column_fullname ::= fullname",
99052	/* 314 */ "kwcolumn_opt ::=",
99053	/* 315 */ "kwcolumn_opt ::= COLUMNKW",
99054	/* 316 */ "cmd ::= create_vtab",
99055	/* 317 */ "cmd ::= create_vtab LP vtabarglist RP",
99056	/* 318 */ "create_vtab ::= createkw VIRTUAL TABLE nm dbnm USING nm",
99057	/* 319 */ "vtabarglist ::= vtabarg",
99058	/* 320 */ "vtabarglist ::= vtabarglist COMMA vtabarg",
99059	/* 321 */ "vtabarg ::=",
99060	/* 322 */ "vtabarg ::= vtabarg vtabargtoken",
99061	/* 323 */ "vtabargtoken ::= ANY",
99062	/* 324 */ "vtabargtoken ::= lp anylist RP",
99063	/* 325 */ "lp ::= LP",
99064	/* 326 */ "anylist ::=",
99065	/* 327 */ "anylist ::= anylist LP anylist RP",
99066	/* 328 */ "anylist ::= anylist ANY",

99067	};
99068	#endif /* NDEBUG */
99069
99070
99071	#if YYSTACKDEPTH<=0
	@@ -98918,18 +99143,17 @@
99143	** inside the C code.
99144	*/
99145	case 160: /* select */
99146	case 194: /* oneselect */
99147	{
99148	sqlite3SelectDelete(pParse->db, (yypminor->yy387));
99149	}
99150	break;
99151	case 174: /* term */
99152	case 175: /* expr */

99153	{
99154	sqlite3ExprDelete(pParse->db, (yypminor->yy118).pExpr);
99155	}
99156	break;
99157	case 179: /* idxlist_opt */
99158	case 187: /* idxlist */
99159	case 197: /* selcollist */
	@@ -98939,51 +99163,51 @@
99163	case 214: /* sortlist */
99164	case 216: /* nexprlist */
99165	case 217: /* setlist */
99166	case 220: /* itemlist */
99167	case 221: /* exprlist */
99168	case 226: /* case_exprlist */
99169	{
99170	sqlite3ExprListDelete(pParse->db, (yypminor->yy322));
99171	}
99172	break;
99173	case 193: /* fullname */
99174	case 198: /* from */
99175	case 206: /* seltablist */
99176	case 207: /* stl_prefix */
99177	{
99178	sqlite3SrcListDelete(pParse->db, (yypminor->yy259));
99179	}
99180	break;
99181	case 199: /* where_opt */
99182	case 201: /* having_opt */
99183	case 210: /* on_opt */
99184	case 215: /* sortitem */
99185	case 225: /* case_operand */
99186	case 227: /* case_else */
99187	case 238: /* when_clause */
99188	case 243: /* key_opt */
99189	{
99190	sqlite3ExprDelete(pParse->db, (yypminor->yy314));
99191	}
99192	break;
99193	case 211: /* using_opt */
99194	case 213: /* inscollist */
99195	case 219: /* inscollist_opt */
99196	{
99197	sqlite3IdListDelete(pParse->db, (yypminor->yy384));
99198	}
99199	break;
99200	case 234: /* trigger_cmd_list */
99201	case 239: /* trigger_cmd */
99202	{
99203	sqlite3DeleteTriggerStep(pParse->db, (yypminor->yy203));
99204	}
99205	break;
99206	case 236: /* trigger_event */
99207	{
99208	sqlite3IdListDelete(pParse->db, (yypminor->yy90).b);
99209	}
99210	break;
99211	default: break; /* If no destructor action specified: do nothing */
99212	}
99213	}
	@@ -99437,128 +99661,127 @@
99661	{ 175, 3 },
99662	{ 222, 1 },
99663	{ 222, 2 },
99664	{ 222, 1 },
99665	{ 222, 2 },
99666	{ 175, 3 },
99667	{ 175, 5 },

99668	{ 175, 2 },
99669	{ 175, 3 },
99670	{ 175, 3 },
99671	{ 175, 4 },
99672	{ 175, 2 },
99673	{ 175, 2 },
99674	{ 175, 2 },
99675	{ 175, 2 },
99676	{ 223, 1 },
99677	{ 223, 2 },
99678	{ 175, 5 },
99679	{ 224, 1 },
99680	{ 224, 2 },



99681	{ 175, 5 },
99682	{ 175, 3 },
99683	{ 175, 5 },
99684	{ 175, 4 },
99685	{ 175, 4 },
99686	{ 175, 5 },
99687	{ 226, 5 },
99688	{ 226, 4 },
99689	{ 227, 2 },
99690	{ 227, 0 },
99691	{ 225, 1 },
99692	{ 225, 0 },
99693	{ 221, 1 },
99694	{ 221, 0 },
99695	{ 216, 3 },
99696	{ 216, 1 },
99697	{ 147, 11 },
99698	{ 228, 1 },
99699	{ 228, 0 },
99700	{ 179, 0 },
99701	{ 179, 3 },
99702	{ 187, 5 },
99703	{ 187, 3 },
99704	{ 229, 0 },
99705	{ 229, 2 },
99706	{ 147, 4 },
99707	{ 147, 1 },
99708	{ 147, 2 },
99709	{ 147, 3 },
99710	{ 147, 5 },
99711	{ 147, 6 },
99712	{ 147, 5 },
99713	{ 147, 6 },
99714	{ 230, 1 },
99715	{ 230, 1 },
99716	{ 230, 1 },
99717	{ 230, 1 },
99718	{ 230, 1 },
99719	{ 170, 2 },
99720	{ 171, 2 },

99721	{ 232, 1 },
99722	{ 231, 1 },
99723	{ 231, 0 },
99724	{ 147, 5 },
99725	{ 233, 11 },
99726	{ 235, 1 },
99727	{ 235, 1 },
99728	{ 235, 2 },
99729	{ 235, 0 },
99730	{ 236, 1 },
99731	{ 236, 1 },
99732	{ 236, 3 },
99733	{ 237, 0 },


99734	{ 237, 3 },
99735	{ 238, 0 },
99736	{ 238, 2 },
99737	{ 234, 3 },
99738	{ 234, 2 },
99739	{ 240, 1 },
99740	{ 240, 3 },
99741	{ 241, 0 },
99742	{ 241, 3 },
99743	{ 241, 2 },
99744	{ 239, 7 },
99745	{ 239, 8 },
99746	{ 239, 5 },
99747	{ 239, 5 },
99748	{ 239, 1 },


99749	{ 175, 4 },
99750	{ 175, 6 },
99751	{ 191, 1 },
99752	{ 191, 1 },
99753	{ 191, 1 },
99754	{ 147, 4 },
99755	{ 147, 6 },
99756	{ 147, 3 },



99757	{ 243, 0 },
99758	{ 243, 2 },
99759	{ 242, 1 },
99760	{ 242, 0 },
99761	{ 147, 1 },
99762	{ 147, 3 },
99763	{ 147, 1 },
99764	{ 147, 3 },
99765	{ 147, 6 },
99766	{ 147, 6 },
99767	{ 244, 1 },
99768	{ 245, 0 },
99769	{ 245, 1 },


99770	{ 147, 1 },
99771	{ 147, 4 },
99772	{ 246, 7 },
99773	{ 247, 1 },
99774	{ 247, 3 },
99775	{ 248, 0 },
99776	{ 248, 2 },
99777	{ 249, 1 },
99778	{ 249, 3 },
99779	{ 250, 1 },
99780	{ 251, 0 },
99781	{ 251, 4 },
99782	{ 251, 2 },


99783	};
99784
99785	static void yy_accept(yyParser); / Forward Declaration */
99786
99787	/*
	@@ -99622,21 +99845,21 @@
99845	break;
99846	case 8: /* cmdx ::= cmd */
99847	{ sqlite3FinishCoding(pParse); }
99848	break;
99849	case 9: /* cmd ::= BEGIN transtype trans_opt */
99850	{sqlite3BeginTransaction(pParse, yymsp[-1].minor.yy4);}
99851	break;
99852	case 13: /* transtype ::= */
99853	{yygotominor.yy4 = TK_DEFERRED;}
99854	break;
99855	case 14: /* transtype ::= DEFERRED */
99856	case 15: /* transtype ::= IMMEDIATE */ yytestcase(yyruleno==15);
99857	case 16: /* transtype ::= EXCLUSIVE */ yytestcase(yyruleno==16);
99858	case 115: /* multiselect_op ::= UNION */ yytestcase(yyruleno==115);
99859	case 117: /* multiselect_op ::= EXCEPT\|INTERSECT */ yytestcase(yyruleno==117);
99860	{yygotominor.yy4 = yymsp[0].major;}
99861	break;
99862	case 17: /* cmd ::= COMMIT trans_opt */
99863	case 18: /* cmd ::= END trans_opt */ yytestcase(yyruleno==18);
99864	{sqlite3CommitTransaction(pParse);}
99865	break;
	@@ -99658,11 +99881,11 @@
99881	sqlite3Savepoint(pParse, SAVEPOINT_ROLLBACK, &yymsp[0].minor.yy0);
99882	}
99883	break;
99884	case 26: /* create_table ::= createkw temp TABLE ifnotexists nm dbnm */
99885	{
99886	sqlite3StartTable(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,yymsp[-4].minor.yy4,0,0,yymsp[-2].minor.yy4);
99887	}
99888	break;
99889	case 27: /* createkw ::= CREATE */
99890	{
99891	pParse->db->lookaside.bEnabled = 0;
	@@ -99677,33 +99900,33 @@
99900	case 87: /* init_deferred_pred_opt ::= INITIALLY IMMEDIATE */ yytestcase(yyruleno==87);
99901	case 98: /* defer_subclause_opt ::= */ yytestcase(yyruleno==98);
99902	case 109: /* ifexists ::= */ yytestcase(yyruleno==109);
99903	case 120: /* distinct ::= ALL */ yytestcase(yyruleno==120);
99904	case 121: /* distinct ::= */ yytestcase(yyruleno==121);
99905	case 222: /* between_op ::= BETWEEN */ yytestcase(yyruleno==222);
99906	case 225: /* in_op ::= IN */ yytestcase(yyruleno==225);
99907	{yygotominor.yy4 = 0;}
99908	break;
99909	case 29: /* ifnotexists ::= IF NOT EXISTS */
99910	case 30: /* temp ::= TEMP */ yytestcase(yyruleno==30);
99911	case 71: /* autoinc ::= AUTOINCR */ yytestcase(yyruleno==71);
99912	case 86: /* init_deferred_pred_opt ::= INITIALLY DEFERRED */ yytestcase(yyruleno==86);
99913	case 108: /* ifexists ::= IF EXISTS */ yytestcase(yyruleno==108);
99914	case 119: /* distinct ::= DISTINCT */ yytestcase(yyruleno==119);
99915	case 223: /* between_op ::= NOT BETWEEN */ yytestcase(yyruleno==223);
99916	case 226: /* in_op ::= NOT IN */ yytestcase(yyruleno==226);
99917	{yygotominor.yy4 = 1;}
99918	break;
99919	case 32: /* create_table_args ::= LP columnlist conslist_opt RP */
99920	{
99921	sqlite3EndTable(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,0);
99922	}
99923	break;
99924	case 33: /* create_table_args ::= AS select */
99925	{
99926	sqlite3EndTable(pParse,0,0,yymsp[0].minor.yy387);
99927	sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy387);
99928	}
99929	break;
99930	case 36: /* column ::= columnid type carglist */
99931	{
99932	yygotominor.yy0.z = yymsp[-2].minor.yy0.z;
	@@ -99726,20 +99949,20 @@
99949	case 49: /* typename ::= ids */ yytestcase(yyruleno==49);
99950	case 127: /* as ::= AS nm */ yytestcase(yyruleno==127);
99951	case 128: /* as ::= ids */ yytestcase(yyruleno==128);
99952	case 138: /* dbnm ::= DOT nm */ yytestcase(yyruleno==138);
99953	case 147: /* indexed_opt ::= INDEXED BY nm */ yytestcase(yyruleno==147);
99954	case 251: /* collate ::= COLLATE ids */ yytestcase(yyruleno==251);
99955	case 260: /* nmnum ::= plus_num */ yytestcase(yyruleno==260);
99956	case 261: /* nmnum ::= nm */ yytestcase(yyruleno==261);
99957	case 262: /* nmnum ::= ON */ yytestcase(yyruleno==262);
99958	case 263: /* nmnum ::= DELETE */ yytestcase(yyruleno==263);
99959	case 264: /* nmnum ::= DEFAULT */ yytestcase(yyruleno==264);
99960	case 265: /* plus_num ::= plus_opt number */ yytestcase(yyruleno==265);
99961	case 266: /* minus_num ::= MINUS number */ yytestcase(yyruleno==266);
99962	case 267: /* number ::= INTEGER\|FLOAT */ yytestcase(yyruleno==267);
99963	case 285: /* trnm ::= nm */ yytestcase(yyruleno==285);
99964	{yygotominor.yy0 = yymsp[0].minor.yy0;}
99965	break;
99966	case 45: /* type ::= typetoken */
99967	{sqlite3AddColumnType(pParse,&yymsp[0].minor.yy0);}
99968	break;
	@@ -99758,21 +99981,21 @@
99981	case 50: /* typename ::= typename ids */
99982	{yygotominor.yy0.z=yymsp[-1].minor.yy0.z; yygotominor.yy0.n=yymsp[0].minor.yy0.n+(int)(yymsp[0].minor.yy0.z-yymsp[-1].minor.yy0.z);}
99983	break;
99984	case 57: /* ccons ::= DEFAULT term */
99985	case 59: /* ccons ::= DEFAULT PLUS term */ yytestcase(yyruleno==59);
99986	{sqlite3AddDefaultValue(pParse,&yymsp[0].minor.yy118);}
99987	break;
99988	case 58: /* ccons ::= DEFAULT LP expr RP */
99989	{sqlite3AddDefaultValue(pParse,&yymsp[-1].minor.yy118);}
99990	break;
99991	case 60: /* ccons ::= DEFAULT MINUS term */
99992	{
99993	ExprSpan v;
99994	v.pExpr = sqlite3PExpr(pParse, TK_UMINUS, yymsp[0].minor.yy118.pExpr, 0, 0);
99995	v.zStart = yymsp[-1].minor.yy0.z;
99996	v.zEnd = yymsp[0].minor.yy118.zEnd;
99997	sqlite3AddDefaultValue(pParse,&v);
99998	}
99999	break;
100000	case 61: /* ccons ::= DEFAULT id */
100001	{
	@@ -99780,454 +100003,453 @@
100003	spanExpr(&v, pParse, TK_STRING, &yymsp[0].minor.yy0);
100004	sqlite3AddDefaultValue(pParse,&v);
100005	}
100006	break;
100007	case 63: /* ccons ::= NOT NULL onconf */
100008	{sqlite3AddNotNull(pParse, yymsp[0].minor.yy4);}
100009	break;
100010	case 64: /* ccons ::= PRIMARY KEY sortorder onconf autoinc */
100011	{sqlite3AddPrimaryKey(pParse,0,yymsp[-1].minor.yy4,yymsp[0].minor.yy4,yymsp[-2].minor.yy4);}
100012	break;
100013	case 65: /* ccons ::= UNIQUE onconf */
100014	{sqlite3CreateIndex(pParse,0,0,0,0,yymsp[0].minor.yy4,0,0,0,0);}
100015	break;
100016	case 66: /* ccons ::= CHECK LP expr RP */
100017	{sqlite3AddCheckConstraint(pParse,yymsp[-1].minor.yy118.pExpr);}
100018	break;
100019	case 67: /* ccons ::= REFERENCES nm idxlist_opt refargs */
100020	{sqlite3CreateForeignKey(pParse,0,&yymsp[-2].minor.yy0,yymsp[-1].minor.yy322,yymsp[0].minor.yy4);}
100021	break;
100022	case 68: /* ccons ::= defer_subclause */
100023	{sqlite3DeferForeignKey(pParse,yymsp[0].minor.yy4);}
100024	break;
100025	case 69: /* ccons ::= COLLATE ids */
100026	{sqlite3AddCollateType(pParse, &yymsp[0].minor.yy0);}
100027	break;
100028	case 72: /* refargs ::= */
100029	{ yygotominor.yy4 = OE_None0x0101; / EV: R-19803-45884 */}
100030	break;
100031	case 73: /* refargs ::= refargs refarg */
100032	{ yygotominor.yy4 = (yymsp[-1].minor.yy4 & ~yymsp[0].minor.yy215.mask) \| yymsp[0].minor.yy215.value; }
100033	break;
100034	case 74: /* refarg ::= MATCH nm */
100035	case 75: /* refarg ::= ON INSERT refact */ yytestcase(yyruleno==75);
100036	{ yygotominor.yy215.value = 0; yygotominor.yy215.mask = 0x000000; }
100037	break;
100038	case 76: /* refarg ::= ON DELETE refact */
100039	{ yygotominor.yy215.value = yymsp[0].minor.yy4; yygotominor.yy215.mask = 0x0000ff; }
100040	break;
100041	case 77: /* refarg ::= ON UPDATE refact */
100042	{ yygotominor.yy215.value = yymsp[0].minor.yy4<<8; yygotominor.yy215.mask = 0x00ff00; }
100043	break;
100044	case 78: /* refact ::= SET NULL */
100045	{ yygotominor.yy4 = OE_SetNull; /* EV: R-33326-45252 */}
100046	break;
100047	case 79: /* refact ::= SET DEFAULT */
100048	{ yygotominor.yy4 = OE_SetDflt; /* EV: R-33326-45252 */}
100049	break;
100050	case 80: /* refact ::= CASCADE */
100051	{ yygotominor.yy4 = OE_Cascade; /* EV: R-33326-45252 */}
100052	break;
100053	case 81: /* refact ::= RESTRICT */
100054	{ yygotominor.yy4 = OE_Restrict; /* EV: R-33326-45252 */}
100055	break;
100056	case 82: /* refact ::= NO ACTION */
100057	{ yygotominor.yy4 = OE_None; /* EV: R-33326-45252 */}
100058	break;
100059	case 84: /* defer_subclause ::= DEFERRABLE init_deferred_pred_opt */
100060	case 99: /* defer_subclause_opt ::= defer_subclause */ yytestcase(yyruleno==99);
100061	case 101: /* onconf ::= ON CONFLICT resolvetype */ yytestcase(yyruleno==101);
100062	case 104: /* resolvetype ::= raisetype */ yytestcase(yyruleno==104);
100063	{yygotominor.yy4 = yymsp[0].minor.yy4;}
100064	break;
100065	case 88: /* conslist_opt ::= */
100066	{yygotominor.yy0.n = 0; yygotominor.yy0.z = 0;}
100067	break;
100068	case 89: /* conslist_opt ::= COMMA conslist */
100069	{yygotominor.yy0 = yymsp[-1].minor.yy0;}
100070	break;
100071	case 94: /* tcons ::= PRIMARY KEY LP idxlist autoinc RP onconf */
100072	{sqlite3AddPrimaryKey(pParse,yymsp[-3].minor.yy322,yymsp[0].minor.yy4,yymsp[-2].minor.yy4,0);}
100073	break;
100074	case 95: /* tcons ::= UNIQUE LP idxlist RP onconf */
100075	{sqlite3CreateIndex(pParse,0,0,0,yymsp[-2].minor.yy322,yymsp[0].minor.yy4,0,0,0,0);}
100076	break;
100077	case 96: /* tcons ::= CHECK LP expr RP onconf */
100078	{sqlite3AddCheckConstraint(pParse,yymsp[-2].minor.yy118.pExpr);}
100079	break;
100080	case 97: /* tcons ::= FOREIGN KEY LP idxlist RP REFERENCES nm idxlist_opt refargs defer_subclause_opt */
100081	{
100082	sqlite3CreateForeignKey(pParse, yymsp[-6].minor.yy322, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy322, yymsp[-1].minor.yy4);
100083	sqlite3DeferForeignKey(pParse, yymsp[0].minor.yy4);
100084	}
100085	break;
100086	case 100: /* onconf ::= */
100087	{yygotominor.yy4 = OE_Default;}
100088	break;
100089	case 102: /* orconf ::= */
100090	{yygotominor.yy210 = OE_Default;}
100091	break;
100092	case 103: /* orconf ::= OR resolvetype */
100093	{yygotominor.yy210 = (u8)yymsp[0].minor.yy4;}
100094	break;
100095	case 105: /* resolvetype ::= IGNORE */
100096	{yygotominor.yy4 = OE_Ignore;}
100097	break;
100098	case 106: /* resolvetype ::= REPLACE */
100099	{yygotominor.yy4 = OE_Replace;}
100100	break;
100101	case 107: /* cmd ::= DROP TABLE ifexists fullname */
100102	{
100103	sqlite3DropTable(pParse, yymsp[0].minor.yy259, 0, yymsp[-1].minor.yy4);
100104	}
100105	break;
100106	case 110: /* cmd ::= createkw temp VIEW ifnotexists nm dbnm AS select */
100107	{
100108	sqlite3CreateView(pParse, &yymsp[-7].minor.yy0, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0, yymsp[0].minor.yy387, yymsp[-6].minor.yy4, yymsp[-4].minor.yy4);
100109	}
100110	break;
100111	case 111: /* cmd ::= DROP VIEW ifexists fullname */
100112	{
100113	sqlite3DropTable(pParse, yymsp[0].minor.yy259, 1, yymsp[-1].minor.yy4);
100114	}
100115	break;
100116	case 112: /* cmd ::= select */
100117	{
100118	SelectDest dest = {SRT_Output, 0, 0, 0, 0};
100119	sqlite3Select(pParse, yymsp[0].minor.yy387, &dest);
100120	sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy387);
100121	}
100122	break;
100123	case 113: /* select ::= oneselect */
100124	{yygotominor.yy387 = yymsp[0].minor.yy387;}
100125	break;
100126	case 114: /* select ::= select multiselect_op oneselect */
100127	{
100128	if( yymsp[0].minor.yy387 ){
100129	yymsp[0].minor.yy387->op = (u8)yymsp[-1].minor.yy4;
100130	yymsp[0].minor.yy387->pPrior = yymsp[-2].minor.yy387;
100131	}else{
100132	sqlite3SelectDelete(pParse->db, yymsp[-2].minor.yy387);
100133	}
100134	yygotominor.yy387 = yymsp[0].minor.yy387;
100135	}
100136	break;
100137	case 116: /* multiselect_op ::= UNION ALL */
100138	{yygotominor.yy4 = TK_ALL;}
100139	break;
100140	case 118: /* oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */
100141	{
100142	yygotominor.yy387 = sqlite3SelectNew(pParse,yymsp[-6].minor.yy322,yymsp[-5].minor.yy259,yymsp[-4].minor.yy314,yymsp[-3].minor.yy322,yymsp[-2].minor.yy314,yymsp[-1].minor.yy322,yymsp[-7].minor.yy4,yymsp[0].minor.yy292.pLimit,yymsp[0].minor.yy292.pOffset);
100143	}
100144	break;
100145	case 122: /* sclp ::= selcollist COMMA */
100146	case 247: /* idxlist_opt ::= LP idxlist RP */ yytestcase(yyruleno==247);
100147	{yygotominor.yy322 = yymsp[-1].minor.yy322;}
100148	break;
100149	case 123: /* sclp ::= */
100150	case 151: /* orderby_opt ::= */ yytestcase(yyruleno==151);
100151	case 159: /* groupby_opt ::= */ yytestcase(yyruleno==159);
100152	case 240: /* exprlist ::= */ yytestcase(yyruleno==240);
100153	case 246: /* idxlist_opt ::= */ yytestcase(yyruleno==246);
100154	{yygotominor.yy322 = 0;}
100155	break;
100156	case 124: /* selcollist ::= sclp expr as */
100157	{
100158	yygotominor.yy322 = sqlite3ExprListAppend(pParse, yymsp[-2].minor.yy322, yymsp[-1].minor.yy118.pExpr);
100159	if( yymsp[0].minor.yy0.n>0 ) sqlite3ExprListSetName(pParse, yygotominor.yy322, &yymsp[0].minor.yy0, 1);
100160	sqlite3ExprListSetSpan(pParse,yygotominor.yy322,&yymsp[-1].minor.yy118);
100161	}
100162	break;
100163	case 125: /* selcollist ::= sclp STAR */
100164	{
100165	Expr *p = sqlite3Expr(pParse->db, TK_ALL, 0);
100166	yygotominor.yy322 = sqlite3ExprListAppend(pParse, yymsp[-1].minor.yy322, p);
100167	}
100168	break;
100169	case 126: /* selcollist ::= sclp nm DOT STAR */
100170	{
100171	Expr *pRight = sqlite3PExpr(pParse, TK_ALL, 0, 0, &yymsp[0].minor.yy0);
100172	Expr *pLeft = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[-2].minor.yy0);
100173	Expr *pDot = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight, 0);
100174	yygotominor.yy322 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy322, pDot);
100175	}
100176	break;
100177	case 129: /* as ::= */
100178	{yygotominor.yy0.n = 0;}
100179	break;
100180	case 130: /* from ::= */
100181	{yygotominor.yy259 = sqlite3DbMallocZero(pParse->db, sizeof(*yygotominor.yy259));}
100182	break;
100183	case 131: /* from ::= FROM seltablist */
100184	{
100185	yygotominor.yy259 = yymsp[0].minor.yy259;
100186	sqlite3SrcListShiftJoinType(yygotominor.yy259);
100187	}
100188	break;
100189	case 132: /* stl_prefix ::= seltablist joinop */
100190	{
100191	yygotominor.yy259 = yymsp[-1].minor.yy259;
100192	if( ALWAYS(yygotominor.yy259 && yygotominor.yy259->nSrc>0) ) yygotominor.yy259->a[yygotominor.yy259->nSrc-1].jointype = (u8)yymsp[0].minor.yy4;
100193	}
100194	break;
100195	case 133: /* stl_prefix ::= */
100196	{yygotominor.yy259 = 0;}
100197	break;
100198	case 134: /* seltablist ::= stl_prefix nm dbnm as indexed_opt on_opt using_opt */
100199	{
100200	yygotominor.yy259 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy259,&yymsp[-5].minor.yy0,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,0,yymsp[-1].minor.yy314,yymsp[0].minor.yy384);
100201	sqlite3SrcListIndexedBy(pParse, yygotominor.yy259, &yymsp[-2].minor.yy0);
100202	}
100203	break;
100204	case 135: /* seltablist ::= stl_prefix LP select RP as on_opt using_opt */
100205	{
100206	yygotominor.yy259 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy259,0,0,&yymsp[-2].minor.yy0,yymsp[-4].minor.yy387,yymsp[-1].minor.yy314,yymsp[0].minor.yy384);
100207	}
100208	break;
100209	case 136: /* seltablist ::= stl_prefix LP seltablist RP as on_opt using_opt */
100210	{
100211	if( yymsp[-6].minor.yy259==0 && yymsp[-2].minor.yy0.n==0 && yymsp[-1].minor.yy314==0 && yymsp[0].minor.yy384==0 ){
100212	yygotominor.yy259 = yymsp[-4].minor.yy259;
100213	}else{
100214	Select *pSubquery;
100215	sqlite3SrcListShiftJoinType(yymsp[-4].minor.yy259);
100216	pSubquery = sqlite3SelectNew(pParse,0,yymsp[-4].minor.yy259,0,0,0,0,0,0,0);
100217	yygotominor.yy259 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy259,0,0,&yymsp[-2].minor.yy0,pSubquery,yymsp[-1].minor.yy314,yymsp[0].minor.yy384);
100218	}
100219	}
100220	break;
100221	case 137: /* dbnm ::= */
100222	case 146: /* indexed_opt ::= */ yytestcase(yyruleno==146);
100223	{yygotominor.yy0.z=0; yygotominor.yy0.n=0;}
100224	break;
100225	case 139: /* fullname ::= nm dbnm */
100226	{yygotominor.yy259 = sqlite3SrcListAppend(pParse->db,0,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0);}
100227	break;
100228	case 140: /* joinop ::= COMMA\|JOIN */
100229	{ yygotominor.yy4 = JT_INNER; }
100230	break;
100231	case 141: /* joinop ::= JOIN_KW JOIN */
100232	{ yygotominor.yy4 = sqlite3JoinType(pParse,&yymsp[-1].minor.yy0,0,0); }
100233	break;
100234	case 142: /* joinop ::= JOIN_KW nm JOIN */
100235	{ yygotominor.yy4 = sqlite3JoinType(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,0); }
100236	break;
100237	case 143: /* joinop ::= JOIN_KW nm nm JOIN */
100238	{ yygotominor.yy4 = sqlite3JoinType(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0); }
100239	break;
100240	case 144: /* on_opt ::= ON expr */
100241	case 155: /* sortitem ::= expr */ yytestcase(yyruleno==155);
100242	case 162: /* having_opt ::= HAVING expr */ yytestcase(yyruleno==162);
100243	case 169: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==169);
100244	case 235: /* case_else ::= ELSE expr */ yytestcase(yyruleno==235);
100245	case 237: /* case_operand ::= expr */ yytestcase(yyruleno==237);
100246	{yygotominor.yy314 = yymsp[0].minor.yy118.pExpr;}
100247	break;
100248	case 145: /* on_opt ::= */
100249	case 161: /* having_opt ::= */ yytestcase(yyruleno==161);
100250	case 168: /* where_opt ::= */ yytestcase(yyruleno==168);
100251	case 236: /* case_else ::= */ yytestcase(yyruleno==236);
100252	case 238: /* case_operand ::= */ yytestcase(yyruleno==238);
100253	{yygotominor.yy314 = 0;}
100254	break;
100255	case 148: /* indexed_opt ::= NOT INDEXED */
100256	{yygotominor.yy0.z=0; yygotominor.yy0.n=1;}
100257	break;
100258	case 149: /* using_opt ::= USING LP inscollist RP */
100259	case 181: /* inscollist_opt ::= LP inscollist RP */ yytestcase(yyruleno==181);
100260	{yygotominor.yy384 = yymsp[-1].minor.yy384;}
100261	break;
100262	case 150: /* using_opt ::= */
100263	case 180: /* inscollist_opt ::= */ yytestcase(yyruleno==180);
100264	{yygotominor.yy384 = 0;}
100265	break;
100266	case 152: /* orderby_opt ::= ORDER BY sortlist */
100267	case 160: /* groupby_opt ::= GROUP BY nexprlist */ yytestcase(yyruleno==160);
100268	case 239: /* exprlist ::= nexprlist */ yytestcase(yyruleno==239);
100269	{yygotominor.yy322 = yymsp[0].minor.yy322;}
100270	break;
100271	case 153: /* sortlist ::= sortlist COMMA sortitem sortorder */
100272	{
100273	yygotominor.yy322 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy322,yymsp[-1].minor.yy314);
100274	if( yygotominor.yy322 ) yygotominor.yy322->a[yygotominor.yy322->nExpr-1].sortOrder = (u8)yymsp[0].minor.yy4;
100275	}
100276	break;
100277	case 154: /* sortlist ::= sortitem sortorder */
100278	{
100279	yygotominor.yy322 = sqlite3ExprListAppend(pParse,0,yymsp[-1].minor.yy314);
100280	if( yygotominor.yy322 && ALWAYS(yygotominor.yy322->a) ) yygotominor.yy322->a[0].sortOrder = (u8)yymsp[0].minor.yy4;
100281	}
100282	break;
100283	case 156: /* sortorder ::= ASC */
100284	case 158: /* sortorder ::= */ yytestcase(yyruleno==158);
100285	{yygotominor.yy4 = SQLITE_SO_ASC;}
100286	break;
100287	case 157: /* sortorder ::= DESC */
100288	{yygotominor.yy4 = SQLITE_SO_DESC;}
100289	break;
100290	case 163: /* limit_opt ::= */
100291	{yygotominor.yy292.pLimit = 0; yygotominor.yy292.pOffset = 0;}
100292	break;
100293	case 164: /* limit_opt ::= LIMIT expr */
100294	{yygotominor.yy292.pLimit = yymsp[0].minor.yy118.pExpr; yygotominor.yy292.pOffset = 0;}
100295	break;
100296	case 165: /* limit_opt ::= LIMIT expr OFFSET expr */
100297	{yygotominor.yy292.pLimit = yymsp[-2].minor.yy118.pExpr; yygotominor.yy292.pOffset = yymsp[0].minor.yy118.pExpr;}
100298	break;
100299	case 166: /* limit_opt ::= LIMIT expr COMMA expr */
100300	{yygotominor.yy292.pOffset = yymsp[-2].minor.yy118.pExpr; yygotominor.yy292.pLimit = yymsp[0].minor.yy118.pExpr;}
100301	break;
100302	case 167: /* cmd ::= DELETE FROM fullname indexed_opt where_opt */
100303	{
100304	sqlite3SrcListIndexedBy(pParse, yymsp[-2].minor.yy259, &yymsp[-1].minor.yy0);
100305	sqlite3DeleteFrom(pParse,yymsp[-2].minor.yy259,yymsp[0].minor.yy314);
100306	}
100307	break;
100308	case 170: /* cmd ::= UPDATE orconf fullname indexed_opt SET setlist where_opt */
100309	{
100310	sqlite3SrcListIndexedBy(pParse, yymsp[-4].minor.yy259, &yymsp[-3].minor.yy0);
100311	sqlite3ExprListCheckLength(pParse,yymsp[-1].minor.yy322,"set list");
100312	sqlite3Update(pParse,yymsp[-4].minor.yy259,yymsp[-1].minor.yy322,yymsp[0].minor.yy314,yymsp[-5].minor.yy210);
100313	}
100314	break;
100315	case 171: /* setlist ::= setlist COMMA nm EQ expr */
100316	{
100317	yygotominor.yy322 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy322, yymsp[0].minor.yy118.pExpr);
100318	sqlite3ExprListSetName(pParse, yygotominor.yy322, &yymsp[-2].minor.yy0, 1);
100319	}
100320	break;
100321	case 172: /* setlist ::= nm EQ expr */
100322	{
100323	yygotominor.yy322 = sqlite3ExprListAppend(pParse, 0, yymsp[0].minor.yy118.pExpr);
100324	sqlite3ExprListSetName(pParse, yygotominor.yy322, &yymsp[-2].minor.yy0, 1);
100325	}
100326	break;
100327	case 173: /* cmd ::= insert_cmd INTO fullname inscollist_opt VALUES LP itemlist RP */
100328	{sqlite3Insert(pParse, yymsp[-5].minor.yy259, yymsp[-1].minor.yy322, 0, yymsp[-4].minor.yy384, yymsp[-7].minor.yy210);}
100329	break;
100330	case 174: /* cmd ::= insert_cmd INTO fullname inscollist_opt select */
100331	{sqlite3Insert(pParse, yymsp[-2].minor.yy259, 0, yymsp[0].minor.yy387, yymsp[-1].minor.yy384, yymsp[-4].minor.yy210);}
100332	break;
100333	case 175: /* cmd ::= insert_cmd INTO fullname inscollist_opt DEFAULT VALUES */
100334	{sqlite3Insert(pParse, yymsp[-3].minor.yy259, 0, 0, yymsp[-2].minor.yy384, yymsp[-5].minor.yy210);}
100335	break;
100336	case 176: /* insert_cmd ::= INSERT orconf */
100337	{yygotominor.yy210 = yymsp[0].minor.yy210;}
100338	break;
100339	case 177: /* insert_cmd ::= REPLACE */
100340	{yygotominor.yy210 = OE_Replace;}
100341	break;
100342	case 178: /* itemlist ::= itemlist COMMA expr */
100343	case 241: /* nexprlist ::= nexprlist COMMA expr */ yytestcase(yyruleno==241);
100344	{yygotominor.yy322 = sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy322,yymsp[0].minor.yy118.pExpr);}
100345	break;
100346	case 179: /* itemlist ::= expr */
100347	case 242: /* nexprlist ::= expr */ yytestcase(yyruleno==242);
100348	{yygotominor.yy322 = sqlite3ExprListAppend(pParse,0,yymsp[0].minor.yy118.pExpr);}
100349	break;
100350	case 182: /* inscollist ::= inscollist COMMA nm */
100351	{yygotominor.yy384 = sqlite3IdListAppend(pParse->db,yymsp[-2].minor.yy384,&yymsp[0].minor.yy0);}
100352	break;
100353	case 183: /* inscollist ::= nm */
100354	{yygotominor.yy384 = sqlite3IdListAppend(pParse->db,0,&yymsp[0].minor.yy0);}
100355	break;
100356	case 184: /* expr ::= term */
100357	{yygotominor.yy118 = yymsp[0].minor.yy118;}

100358	break;
100359	case 185: /* expr ::= LP expr RP */
100360	{yygotominor.yy118.pExpr = yymsp[-1].minor.yy118.pExpr; spanSet(&yygotominor.yy118,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0);}
100361	break;
100362	case 186: /* term ::= NULL */
100363	case 191: /* term ::= INTEGER\|FLOAT\|BLOB */ yytestcase(yyruleno==191);
100364	case 192: /* term ::= STRING */ yytestcase(yyruleno==192);
100365	{spanExpr(&yygotominor.yy118, pParse, yymsp[0].major, &yymsp[0].minor.yy0);}
100366	break;
100367	case 187: /* expr ::= id */
100368	case 188: /* expr ::= JOIN_KW */ yytestcase(yyruleno==188);
100369	{spanExpr(&yygotominor.yy118, pParse, TK_ID, &yymsp[0].minor.yy0);}
100370	break;
100371	case 189: /* expr ::= nm DOT nm */
100372	{
100373	Expr *temp1 = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[-2].minor.yy0);
100374	Expr *temp2 = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[0].minor.yy0);
100375	yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_DOT, temp1, temp2, 0);
100376	spanSet(&yygotominor.yy118,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0);
100377	}
100378	break;
100379	case 190: /* expr ::= nm DOT nm DOT nm */
100380	{
100381	Expr *temp1 = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[-4].minor.yy0);
100382	Expr *temp2 = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[-2].minor.yy0);
100383	Expr *temp3 = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[0].minor.yy0);
100384	Expr *temp4 = sqlite3PExpr(pParse, TK_DOT, temp2, temp3, 0);
100385	yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_DOT, temp1, temp4, 0);
100386	spanSet(&yygotominor.yy118,&yymsp[-4].minor.yy0,&yymsp[0].minor.yy0);
100387	}
100388	break;
100389	case 193: /* expr ::= REGISTER */
100390	{
100391	/* When doing a nested parse, one can include terms in an expression
100392	** that look like this: #1 #2 ... These terms refer to registers
100393	** in the virtual machine. #N is the N-th register. */
100394	if( pParse->nested==0 ){
100395	sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", &yymsp[0].minor.yy0);
100396	yygotominor.yy118.pExpr = 0;
100397	}else{
100398	yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_REGISTER, 0, 0, &yymsp[0].minor.yy0);
100399	if( yygotominor.yy118.pExpr ) sqlite3GetInt32(&yymsp[0].minor.yy0.z[1], &yygotominor.yy118.pExpr->iTable);
100400	}
100401	spanSet(&yygotominor.yy118, &yymsp[0].minor.yy0, &yymsp[0].minor.yy0);
100402	}
100403	break;
100404	case 194: /* expr ::= VARIABLE */
100405	{
100406	spanExpr(&yygotominor.yy118, pParse, TK_VARIABLE, &yymsp[0].minor.yy0);
100407	sqlite3ExprAssignVarNumber(pParse, yygotominor.yy118.pExpr);
100408	spanSet(&yygotominor.yy118, &yymsp[0].minor.yy0, &yymsp[0].minor.yy0);
100409	}
100410	break;
100411	case 195: /* expr ::= expr COLLATE ids */
100412	{
100413	yygotominor.yy118.pExpr = sqlite3ExprSetColl(pParse, yymsp[-2].minor.yy118.pExpr, &yymsp[0].minor.yy0);
100414	yygotominor.yy118.zStart = yymsp[-2].minor.yy118.zStart;
100415	yygotominor.yy118.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
100416	}
100417	break;
100418	case 196: /* expr ::= CAST LP expr AS typetoken RP */
100419	{
100420	yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_CAST, yymsp[-3].minor.yy118.pExpr, 0, &yymsp[-1].minor.yy0);
100421	spanSet(&yygotominor.yy118,&yymsp[-5].minor.yy0,&yymsp[0].minor.yy0);
100422	}
100423	break;
100424	case 197: /* expr ::= ID LP distinct exprlist RP */
100425	{
100426	if( yymsp[-1].minor.yy322 && yymsp[-1].minor.yy322->nExpr>pParse->db->aLimit[SQLITE_LIMIT_FUNCTION_ARG] ){
100427	sqlite3ErrorMsg(pParse, "too many arguments on function %T", &yymsp[-4].minor.yy0);
100428	}
100429	yygotominor.yy118.pExpr = sqlite3ExprFunction(pParse, yymsp[-1].minor.yy322, &yymsp[-4].minor.yy0);
100430	spanSet(&yygotominor.yy118,&yymsp[-4].minor.yy0,&yymsp[0].minor.yy0);
100431	if( yymsp[-2].minor.yy4 && yygotominor.yy118.pExpr ){
100432	yygotominor.yy118.pExpr->flags \|= EP_Distinct;
100433	}
100434	}
100435	break;
100436	case 198: /* expr ::= ID LP STAR RP */
100437	{
100438	yygotominor.yy118.pExpr = sqlite3ExprFunction(pParse, 0, &yymsp[-3].minor.yy0);
100439	spanSet(&yygotominor.yy118,&yymsp[-3].minor.yy0,&yymsp[0].minor.yy0);
100440	}
100441	break;
100442	case 199: /* term ::= CTIME_KW */
100443	{
100444	/* The CURRENT_TIME, CURRENT_DATE, and CURRENT_TIMESTAMP values are
100445	** treated as functions that return constants */
100446	yygotominor.yy118.pExpr = sqlite3ExprFunction(pParse, 0,&yymsp[0].minor.yy0);
100447	if( yygotominor.yy118.pExpr ){
100448	yygotominor.yy118.pExpr->op = TK_CONST_FUNC;
100449	}
100450	spanSet(&yygotominor.yy118, &yymsp[0].minor.yy0, &yymsp[0].minor.yy0);
100451	}
100452	break;
100453	case 200: /* expr ::= expr AND expr */
100454	case 201: /* expr ::= expr OR expr */ yytestcase(yyruleno==201);
100455	case 202: /* expr ::= expr LT\|GT\|GE\|LE expr */ yytestcase(yyruleno==202);
	@@ -100234,421 +100456,441 @@
100456	case 203: /* expr ::= expr EQ\|NE expr */ yytestcase(yyruleno==203);
100457	case 204: /* expr ::= expr BITAND\|BITOR\|LSHIFT\|RSHIFT expr */ yytestcase(yyruleno==204);
100458	case 205: /* expr ::= expr PLUS\|MINUS expr */ yytestcase(yyruleno==205);
100459	case 206: /* expr ::= expr STAR\|SLASH\|REM expr */ yytestcase(yyruleno==206);
100460	case 207: /* expr ::= expr CONCAT expr */ yytestcase(yyruleno==207);
100461	{spanBinaryExpr(&yygotominor.yy118,pParse,yymsp[-1].major,&yymsp[-2].minor.yy118,&yymsp[0].minor.yy118);}
100462	break;
100463	case 208: /* likeop ::= LIKE_KW */
100464	case 210: /* likeop ::= MATCH */ yytestcase(yyruleno==210);
100465	{yygotominor.yy342.eOperator = yymsp[0].minor.yy0; yygotominor.yy342.not = 0;}
100466	break;
100467	case 209: /* likeop ::= NOT LIKE_KW */
100468	case 211: /* likeop ::= NOT MATCH */ yytestcase(yyruleno==211);
100469	{yygotominor.yy342.eOperator = yymsp[0].minor.yy0; yygotominor.yy342.not = 1;}
100470	break;
100471	case 212: /* expr ::= expr likeop expr */
100472	{
100473	ExprList *pList;
100474	pList = sqlite3ExprListAppend(pParse,0, yymsp[0].minor.yy118.pExpr);
100475	pList = sqlite3ExprListAppend(pParse,pList, yymsp[-2].minor.yy118.pExpr);
100476	yygotominor.yy118.pExpr = sqlite3ExprFunction(pParse, pList, &yymsp[-1].minor.yy342.eOperator);
100477	if( yymsp[-1].minor.yy342.not ) yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy118.pExpr, 0, 0);
100478	yygotominor.yy118.zStart = yymsp[-2].minor.yy118.zStart;
100479	yygotominor.yy118.zEnd = yymsp[0].minor.yy118.zEnd;
100480	if( yygotominor.yy118.pExpr ) yygotominor.yy118.pExpr->flags \|= EP_InfixFunc;
100481	}
100482	break;
100483	case 213: /* expr ::= expr likeop expr ESCAPE expr */
100484	{
100485	ExprList *pList;
100486	pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy118.pExpr);
100487	pList = sqlite3ExprListAppend(pParse,pList, yymsp[-4].minor.yy118.pExpr);
100488	pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy118.pExpr);
100489	yygotominor.yy118.pExpr = sqlite3ExprFunction(pParse, pList, &yymsp[-3].minor.yy342.eOperator);
100490	if( yymsp[-3].minor.yy342.not ) yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy118.pExpr, 0, 0);
100491	yygotominor.yy118.zStart = yymsp[-4].minor.yy118.zStart;
100492	yygotominor.yy118.zEnd = yymsp[0].minor.yy118.zEnd;
100493	if( yygotominor.yy118.pExpr ) yygotominor.yy118.pExpr->flags \|= EP_InfixFunc;
100494	}
100495	break;
100496	case 214: /* expr ::= expr ISNULL\|NOTNULL */
100497	{spanUnaryPostfix(&yygotominor.yy118,pParse,yymsp[0].major,&yymsp[-1].minor.yy118,&yymsp[0].minor.yy0);}
100498	break;
100499	case 215: /* expr ::= expr NOT NULL */
100500	{spanUnaryPostfix(&yygotominor.yy118,pParse,TK_NOTNULL,&yymsp[-2].minor.yy118,&yymsp[0].minor.yy0);}
100501	break;
100502	case 216: /* expr ::= expr IS expr */
100503	{
100504	spanBinaryExpr(&yygotominor.yy118,pParse,TK_IS,&yymsp[-2].minor.yy118,&yymsp[0].minor.yy118);
100505	binaryToUnaryIfNull(pParse, yymsp[0].minor.yy118.pExpr, yygotominor.yy118.pExpr, TK_ISNULL);
100506	}
100507	break;
100508	case 217: /* expr ::= expr IS NOT expr */
100509	{
100510	spanBinaryExpr(&yygotominor.yy118,pParse,TK_ISNOT,&yymsp[-3].minor.yy118,&yymsp[0].minor.yy118);
100511	binaryToUnaryIfNull(pParse, yymsp[0].minor.yy118.pExpr, yygotominor.yy118.pExpr, TK_NOTNULL);
100512	}
100513	break;
100514	case 218: /* expr ::= NOT expr */
100515	case 219: /* expr ::= BITNOT expr */ yytestcase(yyruleno==219);
100516	{spanUnaryPrefix(&yygotominor.yy118,pParse,yymsp[-1].major,&yymsp[0].minor.yy118,&yymsp[-1].minor.yy0);}
100517	break;
100518	case 220: /* expr ::= MINUS expr */
100519	{spanUnaryPrefix(&yygotominor.yy118,pParse,TK_UMINUS,&yymsp[0].minor.yy118,&yymsp[-1].minor.yy0);}
100520	break;
100521	case 221: /* expr ::= PLUS expr */
100522	{spanUnaryPrefix(&yygotominor.yy118,pParse,TK_UPLUS,&yymsp[0].minor.yy118,&yymsp[-1].minor.yy0);}
100523	break;
100524	case 224: /* expr ::= expr between_op expr AND expr */
100525	{
100526	ExprList *pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy118.pExpr);
100527	pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy118.pExpr);
100528	yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_BETWEEN, yymsp[-4].minor.yy118.pExpr, 0, 0);
100529	if( yygotominor.yy118.pExpr ){
100530	yygotominor.yy118.pExpr->x.pList = pList;


100531	}else{
100532	sqlite3ExprListDelete(pParse->db, pList);
100533	}
100534	if( yymsp[-3].minor.yy4 ) yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy118.pExpr, 0, 0);
100535	yygotominor.yy118.zStart = yymsp[-4].minor.yy118.zStart;
100536	yygotominor.yy118.zEnd = yymsp[0].minor.yy118.zEnd;
100537	}
100538	break;
100539	case 227: /* expr ::= expr in_op LP exprlist RP */
100540	{
100541	if( yymsp[-1].minor.yy322==0 ){
100542	/* Expressions of the form
100543	**
100544	** expr1 IN ()
100545	** expr1 NOT IN ()
100546	**
100547	** simplify to constants 0 (false) and 1 (true), respectively,
100548	** regardless of the value of expr1.
100549	*/
100550	yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_INTEGER, 0, 0, &sqlite3IntTokens[yymsp[-3].minor.yy4]);
100551	sqlite3ExprDelete(pParse->db, yymsp[-4].minor.yy118.pExpr);
100552	}else{
100553	yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy118.pExpr, 0, 0);
100554	if( yygotominor.yy118.pExpr ){
100555	yygotominor.yy118.pExpr->x.pList = yymsp[-1].minor.yy322;
100556	sqlite3ExprSetHeight(pParse, yygotominor.yy118.pExpr);
100557	}else{
100558	sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy322);
100559	}
100560	if( yymsp[-3].minor.yy4 ) yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy118.pExpr, 0, 0);
100561	}
100562	yygotominor.yy118.zStart = yymsp[-4].minor.yy118.zStart;
100563	yygotominor.yy118.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
100564	}
100565	break;
100566	case 228: /* expr ::= LP select RP */
100567	{
100568	yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_SELECT, 0, 0, 0);
100569	if( yygotominor.yy118.pExpr ){
100570	yygotominor.yy118.pExpr->x.pSelect = yymsp[-1].minor.yy387;
100571	ExprSetProperty(yygotominor.yy118.pExpr, EP_xIsSelect);
100572	sqlite3ExprSetHeight(pParse, yygotominor.yy118.pExpr);
100573	}else{
100574	sqlite3SelectDelete(pParse->db, yymsp[-1].minor.yy387);
100575	}
100576	yygotominor.yy118.zStart = yymsp[-2].minor.yy0.z;
100577	yygotominor.yy118.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
100578	}
100579	break;
100580	case 229: /* expr ::= expr in_op LP select RP */
100581	{
100582	yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy118.pExpr, 0, 0);
100583	if( yygotominor.yy118.pExpr ){
100584	yygotominor.yy118.pExpr->x.pSelect = yymsp[-1].minor.yy387;
100585	ExprSetProperty(yygotominor.yy118.pExpr, EP_xIsSelect);
100586	sqlite3ExprSetHeight(pParse, yygotominor.yy118.pExpr);
100587	}else{
100588	sqlite3SelectDelete(pParse->db, yymsp[-1].minor.yy387);
100589	}
100590	if( yymsp[-3].minor.yy4 ) yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy118.pExpr, 0, 0);
100591	yygotominor.yy118.zStart = yymsp[-4].minor.yy118.zStart;
100592	yygotominor.yy118.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
100593	}
100594	break;
100595	case 230: /* expr ::= expr in_op nm dbnm */
100596	{
100597	SrcList *pSrc = sqlite3SrcListAppend(pParse->db, 0,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0);
100598	yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_IN, yymsp[-3].minor.yy118.pExpr, 0, 0);
100599	if( yygotominor.yy118.pExpr ){
100600	yygotominor.yy118.pExpr->x.pSelect = sqlite3SelectNew(pParse, 0,pSrc,0,0,0,0,0,0,0);
100601	ExprSetProperty(yygotominor.yy118.pExpr, EP_xIsSelect);
100602	sqlite3ExprSetHeight(pParse, yygotominor.yy118.pExpr);
100603	}else{
100604	sqlite3SrcListDelete(pParse->db, pSrc);
100605	}
100606	if( yymsp[-2].minor.yy4 ) yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy118.pExpr, 0, 0);
100607	yygotominor.yy118.zStart = yymsp[-3].minor.yy118.zStart;
100608	yygotominor.yy118.zEnd = yymsp[0].minor.yy0.z ? &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n] : &yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n];
100609	}
100610	break;
100611	case 231: /* expr ::= EXISTS LP select RP */
100612	{
100613	Expr *p = yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_EXISTS, 0, 0, 0);
100614	if( p ){
100615	p->x.pSelect = yymsp[-1].minor.yy387;
100616	ExprSetProperty(p, EP_xIsSelect);
100617	sqlite3ExprSetHeight(pParse, p);
100618	}else{
100619	sqlite3SelectDelete(pParse->db, yymsp[-1].minor.yy387);
100620	}
100621	yygotominor.yy118.zStart = yymsp[-3].minor.yy0.z;
100622	yygotominor.yy118.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
100623	}
100624	break;
100625	case 232: /* expr ::= CASE case_operand case_exprlist case_else END */
100626	{
100627	yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_CASE, yymsp[-3].minor.yy314, yymsp[-1].minor.yy314, 0);
100628	if( yygotominor.yy118.pExpr ){
100629	yygotominor.yy118.pExpr->x.pList = yymsp[-2].minor.yy322;
100630	sqlite3ExprSetHeight(pParse, yygotominor.yy118.pExpr);
100631	}else{
100632	sqlite3ExprListDelete(pParse->db, yymsp[-2].minor.yy322);
100633	}
100634	yygotominor.yy118.zStart = yymsp[-4].minor.yy0.z;
100635	yygotominor.yy118.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
100636	}
100637	break;
100638	case 233: /* case_exprlist ::= case_exprlist WHEN expr THEN expr */
100639	{
100640	yygotominor.yy322 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy322, yymsp[-2].minor.yy118.pExpr);
100641	yygotominor.yy322 = sqlite3ExprListAppend(pParse,yygotominor.yy322, yymsp[0].minor.yy118.pExpr);
100642	}
100643	break;
100644	case 234: /* case_exprlist ::= WHEN expr THEN expr */
100645	{
100646	yygotominor.yy322 = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy118.pExpr);
100647	yygotominor.yy322 = sqlite3ExprListAppend(pParse,yygotominor.yy322, yymsp[0].minor.yy118.pExpr);
100648	}
100649	break;
100650	case 243: /* cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP idxlist RP */
100651	{
100652	sqlite3CreateIndex(pParse, &yymsp[-6].minor.yy0, &yymsp[-5].minor.yy0,
100653	sqlite3SrcListAppend(pParse->db,0,&yymsp[-3].minor.yy0,0), yymsp[-1].minor.yy322, yymsp[-9].minor.yy4,
100654	&yymsp[-10].minor.yy0, &yymsp[0].minor.yy0, SQLITE_SO_ASC, yymsp[-7].minor.yy4);
100655	}
100656	break;
100657	case 244: /* uniqueflag ::= UNIQUE */
100658	case 298: /* raisetype ::= ABORT */ yytestcase(yyruleno==298);
100659	{yygotominor.yy4 = OE_Abort;}
100660	break;
100661	case 245: /* uniqueflag ::= */
100662	{yygotominor.yy4 = OE_None;}
100663	break;
100664	case 248: /* idxlist ::= idxlist COMMA nm collate sortorder */
100665	{
100666	Expr *p = 0;
100667	if( yymsp[-1].minor.yy0.n>0 ){
100668	p = sqlite3Expr(pParse->db, TK_COLUMN, 0);
100669	sqlite3ExprSetColl(pParse, p, &yymsp[-1].minor.yy0);
100670	}
100671	yygotominor.yy322 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy322, p);
100672	sqlite3ExprListSetName(pParse,yygotominor.yy322,&yymsp[-2].minor.yy0,1);
100673	sqlite3ExprListCheckLength(pParse, yygotominor.yy322, "index");
100674	if( yygotominor.yy322 ) yygotominor.yy322->a[yygotominor.yy322->nExpr-1].sortOrder = (u8)yymsp[0].minor.yy4;
100675	}
100676	break;
100677	case 249: /* idxlist ::= nm collate sortorder */
100678	{
100679	Expr *p = 0;
100680	if( yymsp[-1].minor.yy0.n>0 ){
100681	p = sqlite3PExpr(pParse, TK_COLUMN, 0, 0, 0);
100682	sqlite3ExprSetColl(pParse, p, &yymsp[-1].minor.yy0);
100683	}
100684	yygotominor.yy322 = sqlite3ExprListAppend(pParse,0, p);
100685	sqlite3ExprListSetName(pParse, yygotominor.yy322, &yymsp[-2].minor.yy0, 1);
100686	sqlite3ExprListCheckLength(pParse, yygotominor.yy322, "index");
100687	if( yygotominor.yy322 ) yygotominor.yy322->a[yygotominor.yy322->nExpr-1].sortOrder = (u8)yymsp[0].minor.yy4;
100688	}
100689	break;
100690	case 250: /* collate ::= */
100691	{yygotominor.yy0.z = 0; yygotominor.yy0.n = 0;}
100692	break;
100693	case 252: /* cmd ::= DROP INDEX ifexists fullname */
100694	{sqlite3DropIndex(pParse, yymsp[0].minor.yy259, yymsp[-1].minor.yy4);}
100695	break;
100696	case 253: /* cmd ::= VACUUM */
100697	case 254: /* cmd ::= VACUUM nm */ yytestcase(yyruleno==254);
100698	{sqlite3Vacuum(pParse);}
100699	break;
100700	case 255: /* cmd ::= PRAGMA nm dbnm */
100701	{sqlite3Pragma(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,0,0);}
100702	break;
100703	case 256: /* cmd ::= PRAGMA nm dbnm EQ nmnum */
100704	{sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,0);}
100705	break;
100706	case 257: /* cmd ::= PRAGMA nm dbnm LP nmnum RP */
100707	{sqlite3Pragma(pParse,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,0);}
100708	break;
100709	case 258: /* cmd ::= PRAGMA nm dbnm EQ minus_num */
100710	{sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,1);}
100711	break;
100712	case 259: /* cmd ::= PRAGMA nm dbnm LP minus_num RP */
100713	{sqlite3Pragma(pParse,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,1);}
100714	break;
100715	case 270: /* cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
100716	{
100717	Token all;
100718	all.z = yymsp[-3].minor.yy0.z;
100719	all.n = (int)(yymsp[0].minor.yy0.z - yymsp[-3].minor.yy0.z) + yymsp[0].minor.yy0.n;
100720	sqlite3FinishTrigger(pParse, yymsp[-1].minor.yy203, &all);
100721	}
100722	break;
100723	case 271: /* trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
100724	{
100725	sqlite3BeginTrigger(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0, yymsp[-5].minor.yy4, yymsp[-4].minor.yy90.a, yymsp[-4].minor.yy90.b, yymsp[-2].minor.yy259, yymsp[0].minor.yy314, yymsp[-10].minor.yy4, yymsp[-8].minor.yy4);
100726	yygotominor.yy0 = (yymsp[-6].minor.yy0.n==0?yymsp[-7].minor.yy0:yymsp[-6].minor.yy0);
100727	}
100728	break;
100729	case 272: /* trigger_time ::= BEFORE */
100730	case 275: /* trigger_time ::= */ yytestcase(yyruleno==275);
100731	{ yygotominor.yy4 = TK_BEFORE; }
100732	break;
100733	case 273: /* trigger_time ::= AFTER */
100734	{ yygotominor.yy4 = TK_AFTER; }
100735	break;
100736	case 274: /* trigger_time ::= INSTEAD OF */
100737	{ yygotominor.yy4 = TK_INSTEAD;}
100738	break;
100739	case 276: /* trigger_event ::= DELETE\|INSERT */
100740	case 277: /* trigger_event ::= UPDATE */ yytestcase(yyruleno==277);
100741	{yygotominor.yy90.a = yymsp[0].major; yygotominor.yy90.b = 0;}
100742	break;
100743	case 278: /* trigger_event ::= UPDATE OF inscollist */
100744	{yygotominor.yy90.a = TK_UPDATE; yygotominor.yy90.b = yymsp[0].minor.yy384;}
100745	break;
100746	case 281: /* when_clause ::= */
100747	case 303: /* key_opt ::= */ yytestcase(yyruleno==303);
100748	{ yygotominor.yy314 = 0; }
100749	break;
100750	case 282: /* when_clause ::= WHEN expr */
100751	case 304: /* key_opt ::= KEY expr */ yytestcase(yyruleno==304);
100752	{ yygotominor.yy314 = yymsp[0].minor.yy118.pExpr; }
100753	break;
100754	case 283: /* trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
100755	{
100756	assert( yymsp[-2].minor.yy203!=0 );
100757	yymsp[-2].minor.yy203->pLast->pNext = yymsp[-1].minor.yy203;
100758	yymsp[-2].minor.yy203->pLast = yymsp[-1].minor.yy203;
100759	yygotominor.yy203 = yymsp[-2].minor.yy203;
100760	}
100761	break;
100762	case 284: /* trigger_cmd_list ::= trigger_cmd SEMI */
100763	{
100764	assert( yymsp[-1].minor.yy203!=0 );
100765	yymsp[-1].minor.yy203->pLast = yymsp[-1].minor.yy203;
100766	yygotominor.yy203 = yymsp[-1].minor.yy203;
100767	}
100768	break;
100769	case 286: /* trnm ::= nm DOT nm */
100770	{
100771	yygotominor.yy0 = yymsp[0].minor.yy0;
100772	sqlite3ErrorMsg(pParse,
100773	"qualified table names are not allowed on INSERT, UPDATE, and DELETE "
100774	"statements within triggers");
100775	}
100776	break;
100777	case 288: /* tridxby ::= INDEXED BY nm */
100778	{
100779	sqlite3ErrorMsg(pParse,
100780	"the INDEXED BY clause is not allowed on UPDATE or DELETE statements "
100781	"within triggers");
100782	}
100783	break;
100784	case 289: /* tridxby ::= NOT INDEXED */
100785	{
100786	sqlite3ErrorMsg(pParse,
100787	"the NOT INDEXED clause is not allowed on UPDATE or DELETE statements "
100788	"within triggers");
100789	}
100790	break;
100791	case 290: /* trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist where_opt */
100792	{ yygotominor.yy203 = sqlite3TriggerUpdateStep(pParse->db, &yymsp[-4].minor.yy0, yymsp[-1].minor.yy322, yymsp[0].minor.yy314, yymsp[-5].minor.yy210); }
100793	break;
100794	case 291: /* trigger_cmd ::= insert_cmd INTO trnm inscollist_opt VALUES LP itemlist RP */
100795	{yygotominor.yy203 = sqlite3TriggerInsertStep(pParse->db, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy384, yymsp[-1].minor.yy322, 0, yymsp[-7].minor.yy210);}
100796	break;
100797	case 292: /* trigger_cmd ::= insert_cmd INTO trnm inscollist_opt select */
100798	{yygotominor.yy203 = sqlite3TriggerInsertStep(pParse->db, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy384, 0, yymsp[0].minor.yy387, yymsp[-4].minor.yy210);}
100799	break;
100800	case 293: /* trigger_cmd ::= DELETE FROM trnm tridxby where_opt */
100801	{yygotominor.yy203 = sqlite3TriggerDeleteStep(pParse->db, &yymsp[-2].minor.yy0, yymsp[0].minor.yy314);}
100802	break;
100803	case 294: /* trigger_cmd ::= select */
100804	{yygotominor.yy203 = sqlite3TriggerSelectStep(pParse->db, yymsp[0].minor.yy387); }
100805	break;
100806	case 295: /* expr ::= RAISE LP IGNORE RP */
100807	{
100808	yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_RAISE, 0, 0, 0);
100809	if( yygotominor.yy118.pExpr ){
100810	yygotominor.yy118.pExpr->affinity = OE_Ignore;
100811	}
100812	yygotominor.yy118.zStart = yymsp[-3].minor.yy0.z;
100813	yygotominor.yy118.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
100814	}
100815	break;
100816	case 296: /* expr ::= RAISE LP raisetype COMMA nm RP */
100817	{
100818	yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_RAISE, 0, 0, &yymsp[-1].minor.yy0);
100819	if( yygotominor.yy118.pExpr ) {
100820	yygotominor.yy118.pExpr->affinity = (char)yymsp[-3].minor.yy4;
100821	}
100822	yygotominor.yy118.zStart = yymsp[-5].minor.yy0.z;
100823	yygotominor.yy118.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
100824	}
100825	break;
100826	case 297: /* raisetype ::= ROLLBACK */
100827	{yygotominor.yy4 = OE_Rollback;}
100828	break;
100829	case 299: /* raisetype ::= FAIL */
100830	{yygotominor.yy4 = OE_Fail;}
100831	break;
100832	case 300: /* cmd ::= DROP TRIGGER ifexists fullname */
100833	{
100834	sqlite3DropTrigger(pParse,yymsp[0].minor.yy259,yymsp[-1].minor.yy4);
100835	}
100836	break;
100837	case 301: /* cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
100838	{
100839	sqlite3Attach(pParse, yymsp[-3].minor.yy118.pExpr, yymsp[-1].minor.yy118.pExpr, yymsp[0].minor.yy314);
100840	}
100841	break;
100842	case 302: /* cmd ::= DETACH database_kw_opt expr */
100843	{
100844	sqlite3Detach(pParse, yymsp[0].minor.yy118.pExpr);
100845	}
100846	break;
100847	case 307: /* cmd ::= REINDEX */
100848	{sqlite3Reindex(pParse, 0, 0);}
100849	break;
100850	case 308: /* cmd ::= REINDEX nm dbnm */
100851	{sqlite3Reindex(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);}
100852	break;
100853	case 309: /* cmd ::= ANALYZE */
100854	{sqlite3Analyze(pParse, 0, 0);}
100855	break;
100856	case 310: /* cmd ::= ANALYZE nm dbnm */
100857	{sqlite3Analyze(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);}
100858	break;
100859	case 311: /* cmd ::= ALTER TABLE fullname RENAME TO nm */
100860	{
100861	sqlite3AlterRenameTable(pParse,yymsp[-3].minor.yy259,&yymsp[0].minor.yy0);
100862	}
100863	break;
100864	case 312: /* cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt column */
100865	{
100866	sqlite3AlterFinishAddColumn(pParse, &yymsp[0].minor.yy0);
100867	}
100868	break;
100869	case 313: /* add_column_fullname ::= fullname */
100870	{
100871	pParse->db->lookaside.bEnabled = 0;
100872	sqlite3AlterBeginAddColumn(pParse, yymsp[0].minor.yy259);
100873	}
100874	break;
100875	case 316: /* cmd ::= create_vtab */
100876	{sqlite3VtabFinishParse(pParse,0);}
100877	break;
100878	case 317: /* cmd ::= create_vtab LP vtabarglist RP */
100879	{sqlite3VtabFinishParse(pParse,&yymsp[0].minor.yy0);}
100880	break;
100881	case 318: /* create_vtab ::= createkw VIRTUAL TABLE nm dbnm USING nm */
100882	{
100883	sqlite3VtabBeginParse(pParse, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
100884	}
100885	break;
100886	case 321: /* vtabarg ::= */
100887	{sqlite3VtabArgInit(pParse);}
100888	break;
100889	case 323: /* vtabargtoken ::= ANY */
100890	case 324: /* vtabargtoken ::= lp anylist RP */ yytestcase(yyruleno==324);
100891	case 325: /* lp ::= LP */ yytestcase(yyruleno==325);
100892	{sqlite3VtabArgExtend(pParse,&yymsp[0].minor.yy0);}
100893	break;
100894	default:
100895	/* (0) input ::= cmdlist */ yytestcase(yyruleno==0);
100896	/* (1) cmdlist ::= cmdlist ecmd */ yytestcase(yyruleno==1);
	@@ -100673,25 +100915,25 @@
100915	/* (62) ccons ::= NULL onconf */ yytestcase(yyruleno==62);
100916	/* (90) conslist ::= conslist COMMA tcons */ yytestcase(yyruleno==90);
100917	/* (91) conslist ::= conslist tcons */ yytestcase(yyruleno==91);
100918	/* (92) conslist ::= tcons */ yytestcase(yyruleno==92);
100919	/* (93) tcons ::= CONSTRAINT nm */ yytestcase(yyruleno==93);
100920	/* (268) plus_opt ::= PLUS */ yytestcase(yyruleno==268);
100921	/* (269) plus_opt ::= */ yytestcase(yyruleno==269);
100922	/* (279) foreach_clause ::= */ yytestcase(yyruleno==279);
100923	/* (280) foreach_clause ::= FOR EACH ROW */ yytestcase(yyruleno==280);
100924	/* (287) tridxby ::= */ yytestcase(yyruleno==287);
100925	/* (305) database_kw_opt ::= DATABASE */ yytestcase(yyruleno==305);
100926	/* (306) database_kw_opt ::= */ yytestcase(yyruleno==306);
100927	/* (314) kwcolumn_opt ::= */ yytestcase(yyruleno==314);
100928	/* (315) kwcolumn_opt ::= COLUMNKW */ yytestcase(yyruleno==315);
100929	/* (319) vtabarglist ::= vtabarg */ yytestcase(yyruleno==319);
100930	/* (320) vtabarglist ::= vtabarglist COMMA vtabarg */ yytestcase(yyruleno==320);
100931	/* (322) vtabarg ::= vtabarg vtabargtoken */ yytestcase(yyruleno==322);
100932	/* (326) anylist ::= */ yytestcase(yyruleno==326);
100933	/* (327) anylist ::= anylist LP anylist RP */ yytestcase(yyruleno==327);
100934	/* (328) anylist ::= anylist ANY */ yytestcase(yyruleno==328);
100935	break;
100936	};
100937	yygoto = yyRuleInfo[yyruleno].lhs;
100938	yysize = yyRuleInfo[yyruleno].nrhs;
100939	yypParser->yyidx -= yysize;
	@@ -107179,13 +107421,61 @@
107421	** argument to sqlite3Fts3SegReaderIterate()
107422	*/
107423	typedef struct TermSelect TermSelect;
107424	struct TermSelect {
107425	int isReqPos;
107426	char aaOutput[16]; / Malloc'd output buffer */
107427	int anOutput[16]; /* Size of output in bytes */
107428	};
107429
107430	/*
107431	** Merge all doclists in the TermSelect.aaOutput[] array into a single
107432	** doclist stored in TermSelect.aaOutput[0]. If successful, delete all
107433	** other doclists (except the aaOutput[0] one) and return SQLITE_OK.
107434	**
107435	** If an OOM error occurs, return SQLITE_NOMEM. In this case it is
107436	** the responsibility of the caller to free any doclists left in the
107437	** TermSelect.aaOutput[] array.
107438	*/
107439	static int fts3TermSelectMerge(TermSelect *pTS){
107440	int mergetype = (pTS->isReqPos ? MERGE_POS_OR : MERGE_OR);
107441	char *aOut = 0;
107442	int nOut = 0;
107443	int i;
107444
107445	/* Loop through the doclists in the aaOutput[] array. Merge them all
107446	** into a single doclist.
107447	*/
107448	for(i=0; i<SizeofArray(pTS->aaOutput); i++){
107449	if( pTS->aaOutput[i] ){
107450	if( !aOut ){
107451	aOut = pTS->aaOutput[i];
107452	nOut = pTS->anOutput[i];
107453	pTS->aaOutput[0] = 0;
107454	}else{
107455	int nNew = nOut + pTS->anOutput[i];
107456	char *aNew = sqlite3_malloc(nNew);
107457	if( !aNew ){
107458	sqlite3_free(aOut);
107459	return SQLITE_NOMEM;
107460	}
107461	fts3DoclistMerge(mergetype, 0, 0,
107462	aNew, &nNew, pTS->aaOutput[i], pTS->anOutput[i], aOut, nOut
107463	);
107464	sqlite3_free(pTS->aaOutput[i]);
107465	sqlite3_free(aOut);
107466	pTS->aaOutput[i] = 0;
107467	aOut = aNew;
107468	nOut = nNew;
107469	}
107470	}
107471	}
107472
107473	pTS->aaOutput[0] = aOut;
107474	pTS->anOutput[0] = nOut;
107475	return SQLITE_OK;
107476	}
107477
107478	/*
107479	** This function is used as the sqlite3Fts3SegReaderIterate() callback when
107480	** querying the full-text index for a doclist associated with a term or
107481	** term-prefix.
	@@ -107197,42 +107487,67 @@
107487	int nTerm,
107488	char *aDoclist,
107489	int nDoclist
107490	){
107491	TermSelect pTS = (TermSelect )pContext;


107492
107493	UNUSED_PARAMETER(p);
107494	UNUSED_PARAMETER(zTerm);
107495	UNUSED_PARAMETER(nTerm);
107496
107497	if( pTS->aaOutput[0]==0 ){




107498	/* If this is the first term selected, copy the doclist to the output
107499	** buffer using memcpy(). TODO: Add a way to transfer control of the
107500	** aDoclist buffer from the caller so as to avoid the memcpy().
107501	*/
107502	pTS->aaOutput[0] = sqlite3_malloc(nDoclist);
107503	pTS->anOutput[0] = nDoclist;
107504	if( pTS->aaOutput[0] ){
107505	memcpy(pTS->aaOutput[0], aDoclist, nDoclist);
107506	}else{
107507	return SQLITE_NOMEM;
107508	}
107509	}else{




107510	int mergetype = (pTS->isReqPos ? MERGE_POS_OR : MERGE_OR);
107511	char *aMerge = aDoclist;
107512	int nMerge = nDoclist;
107513	int iOut;
107514
107515	for(iOut=0; iOut<SizeofArray(pTS->aaOutput); iOut++){
107516	char *aNew;
107517	int nNew;
107518	if( pTS->aaOutput[iOut]==0 ){
107519	assert( iOut>0 );
107520	pTS->aaOutput[iOut] = aMerge;
107521	pTS->anOutput[iOut] = nMerge;
107522	break;
107523	}
107524
107525	nNew = nMerge + pTS->anOutput[iOut];
107526	aNew = sqlite3_malloc(nNew);
107527	if( !aNew ){
107528	if( aMerge!=aDoclist ){
107529	sqlite3_free(aMerge);
107530	}
107531	return SQLITE_NOMEM;
107532	}
107533	fts3DoclistMerge(mergetype, 0, 0,
107534	aNew, &nNew, pTS->aaOutput[iOut], pTS->anOutput[iOut], aMerge, nMerge
107535	);
107536
107537	if( iOut>0 ) sqlite3_free(aMerge);
107538	sqlite3_free(pTS->aaOutput[iOut]);
107539	pTS->aaOutput[iOut] = 0;
107540
107541	aMerge = aNew;
107542	nMerge = nNew;
107543	if( (iOut+1)==SizeofArray(pTS->aaOutput) ){
107544	pTS->aaOutput[iOut] = aMerge;
107545	pTS->anOutput[iOut] = nMerge;
107546	}
107547	}
107548	}
107549	return SQLITE_OK;
107550	}
107551
107552	/*
107553	** This function retreives the doclist for the specified term (or term
	@@ -107352,16 +107667,21 @@
107667	filter.nTerm = nTerm;
107668
107669	rc = sqlite3Fts3SegReaderIterate(p, apSegment, nSegment, &filter,
107670	fts3TermSelectCb, (void *)&tsc
107671	);
107672	if( rc==SQLITE_OK ){
107673	rc = fts3TermSelectMerge(&tsc);
107674	}
107675
107676	if( rc==SQLITE_OK ){
107677	*ppOut = tsc.aaOutput[0];
107678	*pnOut = tsc.anOutput[0];
107679	}else{
107680	for(i=0; i<SizeofArray(tsc.aaOutput); i++){
107681	sqlite3_free(tsc.aaOutput[i]);
107682	}
107683	}
107684
107685	finished:
107686	sqlite3_reset(pStmt);
107687	for(i=0; i<nSegment; i++){
107688

M src/sqlite3.h

+17 -10

		--- src/sqlite3.h
		+++ src/sqlite3.h
		@@ -107,11 +107,11 @@
107	107	** [sqlite3_libversion_number()], [sqlite3_sourceid()],
108	108	** [sqlite_version()] and [sqlite_source_id()].
109	109	*/
110	110	#define SQLITE_VERSION "3.7.0"
111	111	#define SQLITE_VERSION_NUMBER 3007000
112		-#define SQLITE_SOURCE_ID "2010-07-08 17:40:38 e396184cd3bdb96e29ac33af5d1f631cac553341"
	112	+#define SQLITE_SOURCE_ID "2010-07-21 16:16:28 b36b105eab6fd3195f4bfba6cb5cda0f063b7460"
113	113
114	114	/*
115	115	** CAPI3REF: Run-Time Library Version Numbers
116	116	** KEYWORDS: sqlite3_version, sqlite3_sourceid
117	117	**
		@@ -479,15 +479,16 @@
479	479	#define SQLITE_OPEN_MASTER_JOURNAL 0x00004000 /* VFS only */
480	480	#define SQLITE_OPEN_NOMUTEX 0x00008000 /* Ok for sqlite3_open_v2() */
481	481	#define SQLITE_OPEN_FULLMUTEX 0x00010000 /* Ok for sqlite3_open_v2() */
482	482	#define SQLITE_OPEN_SHAREDCACHE 0x00020000 /* Ok for sqlite3_open_v2() */
483	483	#define SQLITE_OPEN_PRIVATECACHE 0x00040000 /* Ok for sqlite3_open_v2() */
	484	+#define SQLITE_OPEN_WAL 0x00080000 /* VFS only */
484	485
485	486	/*
486	487	** CAPI3REF: Device Characteristics
487	488	**
488		-** The xDeviceCapabilities method of the [sqlite3_io_methods]
	489	+** The xDeviceCharacteristics method of the [sqlite3_io_methods]
489	490	** object returns an integer which is a vector of the these
490	491	** bit values expressing I/O characteristics of the mass storage
491	492	** device that holds the file that the [sqlite3_io_methods]
492	493	** refers to.
493	494	**
		@@ -663,15 +664,14 @@
663	664	int (xCheckReservedLock)(sqlite3_file, int *pResOut);
664	665	int (xFileControl)(sqlite3_file, int op, void *pArg);
665	666	int (xSectorSize)(sqlite3_file);
666	667	int (xDeviceCharacteristics)(sqlite3_file);
667	668	/* Methods above are valid for version 1 */
668		- int (xShmOpen)(sqlite3_file);
	669	+ int (xShmMap)(sqlite3_file, int iPg, int pgsz, int, void volatile**);
669	670	int (xShmLock)(sqlite3_file, int offset, int n, int flags);
670		- int (xShmMap)(sqlite3_file, int iPage, int pgsz, int, void volatile**);
671	671	void (xShmBarrier)(sqlite3_file);
672		- int (xShmClose)(sqlite3_file, int deleteFlag);
	672	+ int (xShmUnmap)(sqlite3_file, int deleteFlag);
673	673	/* Methods above are valid for version 2 */
674	674	/* Additional methods may be added in future releases */
675	675	};
676	676
677	677	/*
		@@ -890,17 +890,24 @@
890	890	** the xAccess method of an [sqlite3_vfs] object. They determine
891	891	** what kind of permissions the xAccess method is looking for.
892	892	** With SQLITE_ACCESS_EXISTS, the xAccess method
893	893	** simply checks whether the file exists.
894	894	** With SQLITE_ACCESS_READWRITE, the xAccess method
895		-** checks whether the file is both readable and writable.
	895	+** checks whether the named directory is both readable and writable
	896	+** (in other words, if files can be added, removed, and renamed within
	897	+** the directory).
	898	+** The SQLITE_ACCESS_READWRITE constant is currently used only by the
	899	+** [temp_store_directory pragma], though this could change in a future
	900	+** release of SQLite.
896	901	** With SQLITE_ACCESS_READ, the xAccess method
897		-** checks whether the file is readable.
	902	+** checks whether the file is readable. The SQLITE_ACCESS_READ constant is
	903	+** currently unused, though it might be used in a future release of
	904	+** SQLite.
898	905	*/
899	906	#define SQLITE_ACCESS_EXISTS 0
900		-#define SQLITE_ACCESS_READWRITE 1
901		-#define SQLITE_ACCESS_READ 2
	907	+#define SQLITE_ACCESS_READWRITE 1 /* Used by PRAGMA temp_store_directory */
	908	+#define SQLITE_ACCESS_READ 2 /* Unused */
902	909
903	910	/*
904	911	** CAPI3REF: Flags for the xShmLock VFS method
905	912	**
906	913	** These integer constants define the various locking operations
		@@ -5231,11 +5238,11 @@
5231	5238	**
5232	5239	** <dt>SQLITE_DBSTATUS_CACHE_USED</dt>
5233	5240	** <dd>^This parameter returns the approximate number of of bytes of heap
5234	5241	** memory used by all pager caches associated with the database connection.
5235	5242	** ^The highwater mark associated with SQLITE_DBSTATUS_CACHE_USED is always 0.
5236		-** checked out.</dd>)^
	5243	+** </dd>
5237	5244	** </dl>
5238	5245	*/
5239	5246	#define SQLITE_DBSTATUS_LOOKASIDE_USED 0
5240	5247	#define SQLITE_DBSTATUS_CACHE_USED 1
5241	5248	#define SQLITE_DBSTATUS_MAX 1 /* Largest defined DBSTATUS */
5242	5249

	--- src/sqlite3.h
	+++ src/sqlite3.h
	@@ -107,11 +107,11 @@
107	** [sqlite3_libversion_number()], [sqlite3_sourceid()],
108	** [sqlite_version()] and [sqlite_source_id()].
109	*/
110	#define SQLITE_VERSION "3.7.0"
111	#define SQLITE_VERSION_NUMBER 3007000
112	#define SQLITE_SOURCE_ID "2010-07-08 17:40:38 e396184cd3bdb96e29ac33af5d1f631cac553341"
113
114	/*
115	** CAPI3REF: Run-Time Library Version Numbers
116	** KEYWORDS: sqlite3_version, sqlite3_sourceid
117	**
	@@ -479,15 +479,16 @@
479	#define SQLITE_OPEN_MASTER_JOURNAL 0x00004000 /* VFS only */
480	#define SQLITE_OPEN_NOMUTEX 0x00008000 /* Ok for sqlite3_open_v2() */
481	#define SQLITE_OPEN_FULLMUTEX 0x00010000 /* Ok for sqlite3_open_v2() */
482	#define SQLITE_OPEN_SHAREDCACHE 0x00020000 /* Ok for sqlite3_open_v2() */
483	#define SQLITE_OPEN_PRIVATECACHE 0x00040000 /* Ok for sqlite3_open_v2() */

484
485	/*
486	** CAPI3REF: Device Characteristics
487	**
488	** The xDeviceCapabilities method of the [sqlite3_io_methods]
489	** object returns an integer which is a vector of the these
490	** bit values expressing I/O characteristics of the mass storage
491	** device that holds the file that the [sqlite3_io_methods]
492	** refers to.
493	**
	@@ -663,15 +664,14 @@
663	int (xCheckReservedLock)(sqlite3_file, int *pResOut);
664	int (xFileControl)(sqlite3_file, int op, void *pArg);
665	int (xSectorSize)(sqlite3_file);
666	int (xDeviceCharacteristics)(sqlite3_file);
667	/* Methods above are valid for version 1 */
668	int (xShmOpen)(sqlite3_file);
669	int (xShmLock)(sqlite3_file, int offset, int n, int flags);
670	int (xShmMap)(sqlite3_file, int iPage, int pgsz, int, void volatile**);
671	void (xShmBarrier)(sqlite3_file);
672	int (xShmClose)(sqlite3_file, int deleteFlag);
673	/* Methods above are valid for version 2 */
674	/* Additional methods may be added in future releases */
675	};
676
677	/*
	@@ -890,17 +890,24 @@
890	** the xAccess method of an [sqlite3_vfs] object. They determine
891	** what kind of permissions the xAccess method is looking for.
892	** With SQLITE_ACCESS_EXISTS, the xAccess method
893	** simply checks whether the file exists.
894	** With SQLITE_ACCESS_READWRITE, the xAccess method
895	** checks whether the file is both readable and writable.





896	** With SQLITE_ACCESS_READ, the xAccess method
897	** checks whether the file is readable.


898	*/
899	#define SQLITE_ACCESS_EXISTS 0
900	#define SQLITE_ACCESS_READWRITE 1
901	#define SQLITE_ACCESS_READ 2
902
903	/*
904	** CAPI3REF: Flags for the xShmLock VFS method
905	**
906	** These integer constants define the various locking operations
	@@ -5231,11 +5238,11 @@
5231	**
5232	** <dt>SQLITE_DBSTATUS_CACHE_USED</dt>
5233	** <dd>^This parameter returns the approximate number of of bytes of heap
5234	** memory used by all pager caches associated with the database connection.
5235	** ^The highwater mark associated with SQLITE_DBSTATUS_CACHE_USED is always 0.
5236	** checked out.</dd>)^
5237	** </dl>
5238	*/
5239	#define SQLITE_DBSTATUS_LOOKASIDE_USED 0
5240	#define SQLITE_DBSTATUS_CACHE_USED 1
5241	#define SQLITE_DBSTATUS_MAX 1 /* Largest defined DBSTATUS */
5242

	--- src/sqlite3.h
	+++ src/sqlite3.h
	@@ -107,11 +107,11 @@
107	** [sqlite3_libversion_number()], [sqlite3_sourceid()],
108	** [sqlite_version()] and [sqlite_source_id()].
109	*/
110	#define SQLITE_VERSION "3.7.0"
111	#define SQLITE_VERSION_NUMBER 3007000
112	#define SQLITE_SOURCE_ID "2010-07-21 16:16:28 b36b105eab6fd3195f4bfba6cb5cda0f063b7460"
113
114	/*
115	** CAPI3REF: Run-Time Library Version Numbers
116	** KEYWORDS: sqlite3_version, sqlite3_sourceid
117	**
	@@ -479,15 +479,16 @@
479	#define SQLITE_OPEN_MASTER_JOURNAL 0x00004000 /* VFS only */
480	#define SQLITE_OPEN_NOMUTEX 0x00008000 /* Ok for sqlite3_open_v2() */
481	#define SQLITE_OPEN_FULLMUTEX 0x00010000 /* Ok for sqlite3_open_v2() */
482	#define SQLITE_OPEN_SHAREDCACHE 0x00020000 /* Ok for sqlite3_open_v2() */
483	#define SQLITE_OPEN_PRIVATECACHE 0x00040000 /* Ok for sqlite3_open_v2() */
484	#define SQLITE_OPEN_WAL 0x00080000 /* VFS only */
485
486	/*
487	** CAPI3REF: Device Characteristics
488	**
489	** The xDeviceCharacteristics method of the [sqlite3_io_methods]
490	** object returns an integer which is a vector of the these
491	** bit values expressing I/O characteristics of the mass storage
492	** device that holds the file that the [sqlite3_io_methods]
493	** refers to.
494	**
	@@ -663,15 +664,14 @@
664	int (xCheckReservedLock)(sqlite3_file, int *pResOut);
665	int (xFileControl)(sqlite3_file, int op, void *pArg);
666	int (xSectorSize)(sqlite3_file);
667	int (xDeviceCharacteristics)(sqlite3_file);
668	/* Methods above are valid for version 1 */
669	int (xShmMap)(sqlite3_file, int iPg, int pgsz, int, void volatile**);
670	int (xShmLock)(sqlite3_file, int offset, int n, int flags);

671	void (xShmBarrier)(sqlite3_file);
672	int (xShmUnmap)(sqlite3_file, int deleteFlag);
673	/* Methods above are valid for version 2 */
674	/* Additional methods may be added in future releases */
675	};
676
677	/*
	@@ -890,17 +890,24 @@
890	** the xAccess method of an [sqlite3_vfs] object. They determine
891	** what kind of permissions the xAccess method is looking for.
892	** With SQLITE_ACCESS_EXISTS, the xAccess method
893	** simply checks whether the file exists.
894	** With SQLITE_ACCESS_READWRITE, the xAccess method
895	** checks whether the named directory is both readable and writable
896	** (in other words, if files can be added, removed, and renamed within
897	** the directory).
898	** The SQLITE_ACCESS_READWRITE constant is currently used only by the
899	** [temp_store_directory pragma], though this could change in a future
900	** release of SQLite.
901	** With SQLITE_ACCESS_READ, the xAccess method
902	** checks whether the file is readable. The SQLITE_ACCESS_READ constant is
903	** currently unused, though it might be used in a future release of
904	** SQLite.
905	*/
906	#define SQLITE_ACCESS_EXISTS 0
907	#define SQLITE_ACCESS_READWRITE 1 /* Used by PRAGMA temp_store_directory */
908	#define SQLITE_ACCESS_READ 2 /* Unused */
909
910	/*
911	** CAPI3REF: Flags for the xShmLock VFS method
912	**
913	** These integer constants define the various locking operations
	@@ -5231,11 +5238,11 @@
5238	**
5239	** <dt>SQLITE_DBSTATUS_CACHE_USED</dt>
5240	** <dd>^This parameter returns the approximate number of of bytes of heap
5241	** memory used by all pager caches associated with the database connection.
5242	** ^The highwater mark associated with SQLITE_DBSTATUS_CACHE_USED is always 0.
5243	** </dd>
5244	** </dl>
5245	*/
5246	#define SQLITE_DBSTATUS_LOOKASIDE_USED 0
5247	#define SQLITE_DBSTATUS_CACHE_USED 1
5248	#define SQLITE_DBSTATUS_MAX 1 /* Largest defined DBSTATUS */
5249

Fossil SCM

Keyboard Shortcuts