/******************************************************************************
** This file is an amalgamation of many separate C source files from SQLite
-** version 3.6.12. By combining all the individual C code files into this
+** version 3.6.13. By combining all the individual C code files into this
** single large file, the entire code can be compiled as a one translation
** unit. This allows many compilers to do optimizations that would not be
** possible if the files were compiled separately. Performance improvements
** programs, you need this file and the "sqlite3.h" header file that defines
** the programming interface to the SQLite library. (If you do not have
** the "sqlite3.h" header file at hand, you will find a copy in the first
-** 5487 lines past this header comment.) Additional code files may be
+** 5503 lines past this header comment.) Additional code files may be
** needed if you want a wrapper to interface SQLite with your choice of
** programming language. The code for the "sqlite3" command-line shell
** is also in a separate file. This file contains only code for the core
** SQLite library.
**
-** This amalgamation was generated on 2009-03-31 11:53:51 UTC.
+** This amalgamation was generated on 2009-04-13 09:10:17 UTC.
*/
#define SQLITE_CORE 1
#define SQLITE_AMALGAMATION 1
**
** Requirements: [H10011] [H10014]
*/
-#define SQLITE_VERSION "3.6.12"
-#define SQLITE_VERSION_NUMBER 3006012
+#define SQLITE_VERSION "3.6.13"
+#define SQLITE_VERSION_NUMBER 3006013
/*
** CAPI3REF: Run-Time Library Version Numbers {H10020} <S60100>
#define SQLITE_IOERR_LOCK (SQLITE_IOERR | (15<<8))
#define SQLITE_IOERR_CLOSE (SQLITE_IOERR | (16<<8))
#define SQLITE_IOERR_DIR_CLOSE (SQLITE_IOERR | (17<<8))
-
#define SQLITE_LOCKED_SHAREDCACHE (SQLITE_LOCKED | (1<<8) )
/*
**
** When the SQLITE_SYNC_DATAONLY flag is used, it means that the
** sync operation only needs to flush data to mass storage. Inode
-** information need not be flushed. The SQLITE_SYNC_NORMAL flag means
-** to use normal fsync() semantics. The SQLITE_SYNC_FULL flag means
+** information need not be flushed. If the lower four bits of the flag
+** equal SQLITE_SYNC_NORMAL, that means to use normal fsync() semantics.
+** If the lower four bits equal SQLITE_SYNC_FULL, that means
** to use Mac OS X style fullsync instead of fsync().
*/
#define SQLITE_SYNC_NORMAL 0x00002
** program using one of these routines.
**
** The first argument, "db", is a [database connection] obtained from a
-** prior call to [sqlite3_open()], [sqlite3_open_v2()] or [sqlite3_open16()].
+** prior successful call to [sqlite3_open()], [sqlite3_open_v2()] or
+** [sqlite3_open16()]. The database connection must not have been closed.
**
** The second argument, "zSql", is the statement to be compiled, encoded
** as either UTF-8 or UTF-16. The sqlite3_prepare() and sqlite3_prepare_v2()
** is equal to the number of bytes in the input string <i>including</i>
** the nul-terminator bytes.
**
-** *pzTail is made to point to the first byte past the end of the
-** first SQL statement in zSql. These routines only compile the first
-** statement in zSql, so *pzTail is left pointing to what remains
-** uncompiled.
+** If pzTail is not NULL then *pzTail is made to point to the first byte
+** past the end of the first SQL statement in zSql. These routines only
+** compile the first statement in zSql, so *pzTail is left pointing to
+** what remains uncompiled.
**
** *ppStmt is left pointing to a compiled [prepared statement] that can be
** executed using [sqlite3_step()]. If there is an error, *ppStmt is set
** to NULL. If the input text contains no SQL (if the input is an empty
** string or a comment) then *ppStmt is set to NULL.
-** {A13018} The calling procedure is responsible for deleting the compiled
+** The calling procedure is responsible for deleting the compiled
** SQL statement using [sqlite3_finalize()] after it has finished with it.
+** ppStmt may not be NULL.
**
** On success, [SQLITE_OK] is returned, otherwise an [error code] is returned.
**
** is a NULL pointer, then SQLite performs a search for an appropriate
** temporary file directory.
**
-** It is not safe to modify this variable once a [database connection]
-** has been opened. It is intended that this variable be set once
+** It is not safe to read or modify this variable in more than one
+** thread at a time. It is not safe to read or modify this variable
+** if a [database connection] is being used at the same time in a separate
+** thread.
+** It is intended that this variable be set once
** as part of process initialization and before any SQLite interface
-** routines have been call and remain unchanged thereafter.
+** routines have been called and that this variable remain unchanged
+** thereafter.
+**
+** The [temp_store_directory pragma] may modify this variable and cause
+** it to point to memory obtained from [sqlite3_malloc]. Furthermore,
+** the [temp_store_directory pragma] always assumes that any string
+** that this variable points to is held in memory obtained from
+** [sqlite3_malloc] and the pragma may attempt to free that memory
+** using [sqlite3_free].
+** Hence, if this variable is modified directly, either it should be
+** made NULL or made to point to memory obtained from [sqlite3_malloc]
+** or else the use of the [temp_store_directory pragma] should be avoided.
*/
SQLITE_API char *sqlite3_temp_directory;
*/
#define ROUNDDOWN8(x) ((x)&~7)
+/*
+** Assert that the pointer X is aligned to an 8-byte boundary.
+*/
+#define EIGHT_BYTE_ALIGNMENT(X) ((((char*)(X) - (char*)0)&7)==0)
+
/*
** An instance of the following structure is used to store the busy-handler
** callback for a given sqlite handle.
SQLITE_PRIVATE int sqlite3BtreeSetCacheSize(Btree*,int);
SQLITE_PRIVATE int sqlite3BtreeSetSafetyLevel(Btree*,int,int);
SQLITE_PRIVATE int sqlite3BtreeSyncDisabled(Btree*);
-SQLITE_PRIVATE int sqlite3BtreeSetPageSize(Btree*,int,int);
+SQLITE_PRIVATE int sqlite3BtreeSetPageSize(Btree*,int,int,int);
SQLITE_PRIVATE int sqlite3BtreeGetPageSize(Btree*);
SQLITE_PRIVATE int sqlite3BtreeMaxPageCount(Btree*,int);
SQLITE_PRIVATE int sqlite3BtreeGetReserve(Btree*);
** use mutexes to access the BtShared structures. So make the
** Enter and Leave procedures no-ops.
*/
-#if !defined(SQLITE_OMIT_SHARED_CACHE) && SQLITE_THREADSAFE
+#ifndef SQLITE_OMIT_SHARED_CACHE
SQLITE_PRIVATE void sqlite3BtreeEnter(Btree*);
-SQLITE_PRIVATE void sqlite3BtreeLeave(Btree*);
-#ifndef NDEBUG
- /* This routine is used inside assert() statements only. */
-SQLITE_PRIVATE int sqlite3BtreeHoldsMutex(Btree*);
+SQLITE_PRIVATE void sqlite3BtreeEnterAll(sqlite3*);
+#else
+# define sqlite3BtreeEnter(X)
+# define sqlite3BtreeEnterAll(X)
#endif
+
+#if !defined(SQLITE_OMIT_SHARED_CACHE) && SQLITE_THREADSAFE
+SQLITE_PRIVATE void sqlite3BtreeLeave(Btree*);
SQLITE_PRIVATE void sqlite3BtreeEnterCursor(BtCursor*);
SQLITE_PRIVATE void sqlite3BtreeLeaveCursor(BtCursor*);
-SQLITE_PRIVATE void sqlite3BtreeEnterAll(sqlite3*);
SQLITE_PRIVATE void sqlite3BtreeLeaveAll(sqlite3*);
-#ifndef NDEBUG
- /* This routine is used inside assert() statements only. */
-SQLITE_PRIVATE int sqlite3BtreeHoldsAllMutexes(sqlite3*);
-#endif
SQLITE_PRIVATE void sqlite3BtreeMutexArrayEnter(BtreeMutexArray*);
SQLITE_PRIVATE void sqlite3BtreeMutexArrayLeave(BtreeMutexArray*);
SQLITE_PRIVATE void sqlite3BtreeMutexArrayInsert(BtreeMutexArray*, Btree*);
-#else
-# define sqlite3BtreeEnter(X)
-# define sqlite3BtreeLeave(X)
#ifndef NDEBUG
- /* This routine is used inside assert() statements only. */
-# define sqlite3BtreeHoldsMutex(X) 1
+ /* These routines are used inside assert() statements only. */
+SQLITE_PRIVATE int sqlite3BtreeHoldsMutex(Btree*);
+SQLITE_PRIVATE int sqlite3BtreeHoldsAllMutexes(sqlite3*);
#endif
+#else
+
+# define sqlite3BtreeLeave(X)
# define sqlite3BtreeEnterCursor(X)
# define sqlite3BtreeLeaveCursor(X)
-# define sqlite3BtreeEnterAll(X)
# define sqlite3BtreeLeaveAll(X)
-#ifndef NDEBUG
- /* This routine is used inside assert() statements only. */
-# define sqlite3BtreeHoldsAllMutexes(X) 1
-#endif
# define sqlite3BtreeMutexArrayEnter(X)
# define sqlite3BtreeMutexArrayLeave(X)
# define sqlite3BtreeMutexArrayInsert(X,Y)
+
+# define sqlite3BtreeHoldsMutex(X) 1
+# define sqlite3BtreeHoldsAllMutexes(X) 1
#endif
#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
SQLITE_PRIVATE int sqlite3VdbeReleaseMemory(int);
#endif
-SQLITE_PRIVATE UnpackedRecord *sqlite3VdbeRecordUnpack(KeyInfo*,int,const void*,
- UnpackedRecord*,int);
+SQLITE_PRIVATE UnpackedRecord *sqlite3VdbeRecordUnpack(KeyInfo*,int,const void*,char*,int);
SQLITE_PRIVATE void sqlite3VdbeDeleteUnpackedRecord(UnpackedRecord*);
SQLITE_PRIVATE int sqlite3VdbeRecordCompare(int,const void*,UnpackedRecord*);
#ifdef SQLITE_ENABLE_UNLOCK_NOTIFY
/* The following variables are all protected by the STATIC_MASTER
** mutex, not by sqlite3.mutex. They are used by code in notify.c.
+ **
+ ** When X.pUnlockConnection==Y, that means that X is waiting for Y to
+ ** unlock so that it can proceed.
+ **
+ ** When X.pBlockingConnection==Y, that means that something that X tried
+ ** tried to do recently failed with an SQLITE_LOCKED error due to locks
+ ** held by Y.
*/
sqlite3 *pBlockingConnection; /* Connection that caused SQLITE_LOCKED */
sqlite3 *pUnlockConnection; /* Connection to watch for unlock */
#define SQLITE_RecoveryMode 0x00040000 /* Ignore schema errors */
#define SQLITE_SharedCache 0x00080000 /* Cache sharing is enabled */
-#define SQLITE_Vtab 0x00100000 /* There exists a virtual table */
#define SQLITE_CommitBusy 0x00200000 /* In the process of committing */
#define SQLITE_ReverseOrder 0x00400000 /* Reverse unordered SELECTs */
**
** ALLOCATION NOTES:
**
-** Expr structures may be stored as part of the in-memory database schema,
-** for example as part of trigger, view or table definitions. In this case,
-** the amount of memory consumed by complex expressions may be significant.
-** For this reason, less than sizeof(Expr) bytes may be allocated for some
-** Expr structs stored as part of the in-memory database schema.
-**
-** If the EP_Reduced flag is set in Expr.flags, then only EXPR_REDUCEDSIZE
-** bytes of space are allocated for the expression structure. This is enough
-** space to store all fields up to and including the "Token span;" field.
+** Expr objects can use a lot of memory space in database schema. To
+** help reduce memory requirements, sometimes an Expr object will be
+** truncated. And to reduce the number of memory allocations, sometimes
+** two or more Expr objects will be stored in a single memory allocation,
+** together with Expr.token and/or Expr.span strings.
**
-** If the EP_TokenOnly flag is set in Expr.flags, then only EXPR_TOKENONLYSIZE
-** bytes of space are allocated for the expression structure. This is enough
-** space to store all fields up to and including the "Token token;" field.
+** If the EP_Reduced, EP_SpanToken, and EP_TokenOnly flags are set when
+** an Expr object is truncated. When EP_Reduced is set, then all
+** the child Expr objects in the Expr.pLeft and Expr.pRight subtrees
+** are contained within the same memory allocation. Note, however, that
+** the subtrees in Expr.x.pList or Expr.x.pSelect are always separately
+** allocated, regardless of whether or not EP_Reduced is set.
*/
struct Expr {
u8 op; /* Operation performed by this node */
Token span; /* Complete text of the expression */
- /* If the EP_SpanOnly flag is set in the Expr.flags mask, then no
+ /* If the EP_SpanToken flag is set in the Expr.flags mask, then no
** space is allocated for the fields below this point. An attempt to
** access them will result in a segfault or malfunction.
*********************************************************************/
#define EP_Reduced 0x2000 /* Expr struct is EXPR_REDUCEDSIZE bytes only */
#define EP_TokenOnly 0x4000 /* Expr struct is EXPR_TOKENONLYSIZE bytes only */
-#define EP_SpanOnly 0x8000 /* Expr struct is EXPR_SPANONLYSIZE bytes only */
+#define EP_SpanToken 0x8000 /* Expr size is EXPR_SPANTOKENSIZE bytes */
/*
** The following are the meanings of bits in the Expr.vvaFlags field.
** struct, an Expr struct with the EP_Reduced flag set in Expr.flags
** and an Expr struct with the EP_TokenOnly flag set.
*/
-#define EXPR_FULLSIZE sizeof(Expr)
-#define EXPR_REDUCEDSIZE offsetof(Expr,iTable)
-#define EXPR_TOKENONLYSIZE offsetof(Expr,span)
-#define EXPR_SPANONLYSIZE offsetof(Expr,pLeft)
+#define EXPR_FULLSIZE sizeof(Expr) /* Full size */
+#define EXPR_REDUCEDSIZE offsetof(Expr,iTable) /* Common features */
+#define EXPR_SPANTOKENSIZE offsetof(Expr,pLeft) /* Fewer features */
+#define EXPR_TOKENONLYSIZE offsetof(Expr,span) /* Smallest possible */
/*
** Flags passed to the sqlite3ExprDup() function. See the header comment
** above sqlite3ExprDup() for details.
*/
-#define EXPRDUP_REDUCE 0x0001
-#define EXPRDUP_SPAN 0x0002
-#define EXPRDUP_DISTINCTSPAN 0x0004
+#define EXPRDUP_REDUCE 0x0001 /* Used reduced-size Expr nodes */
+#define EXPRDUP_SPAN 0x0002 /* Make a copy of Expr.span */
/*
** A list of expressions. Each expression may optionally have a
# define sqlite3DropTriggerPtr(A,B)
# define sqlite3UnlinkAndDeleteTrigger(A,B,C)
# define sqlite3CodeRowTrigger(A,B,C,D,E,F,G,H,I,J,K,L) 0
+# define sqlite3TriggerList(X, Y) 0
#endif
SQLITE_PRIVATE int sqlite3JoinType(Parse*, Token*, Token*, Token*);
SQLITE_PRIVATE int sqlite3FitsIn64Bits(const char *, int);
SQLITE_PRIVATE int sqlite3Utf16ByteLen(const void *pData, int nChar);
SQLITE_PRIVATE int sqlite3Utf8CharLen(const char *pData, int nByte);
-SQLITE_PRIVATE int sqlite3Utf8Read(const u8*, const u8*, const u8**);
+SQLITE_PRIVATE int sqlite3Utf8Read(const u8*, const u8**);
/*
** Routines to read and write variable-length integers. These used to
case 'm': sqlite3_snprintf(3, &z[j],"%02d",x.M); j+=2; break;
case 'M': sqlite3_snprintf(3, &z[j],"%02d",x.m); j+=2; break;
case 's': {
- sqlite3_snprintf(30,&z[j],"%d",
- (int)(x.iJD/1000.0 - 210866760000.0));
+ sqlite3_snprintf(30,&z[j],"%lld",
+ (i64)(x.iJD/1000 - 21086676*(i64)10000));
j += sqlite3Strlen30(&z[j]);
break;
}
#define etSQLESCAPE3 15 /* %w -> Strings with '\"' doubled */
#define etORDINAL 16 /* %r -> 1st, 2nd, 3rd, 4th, etc. English only */
+#define etINVALID 0 /* Any unrecognized conversion type */
+
/*
** An "etByte" is an 8-bit unsigned value.
{ 'n', 0, 0, etSIZE, 0, 0 },
{ '%', 0, 0, etPERCENT, 0, 0 },
{ 'p', 16, 0, etPOINTER, 0, 1 },
+
+/* All the rest have the FLAG_INTERN bit set and are thus for internal
+** use only */
{ 'T', 0, 2, etTOKEN, 0, 0 },
{ 'S', 0, 2, etSRCLIST, 0, 0 },
{ 'r', 10, 3, etORDINAL, 0, 0 },
flag_long = flag_longlong = 0;
}
/* Fetch the info entry for the field */
- infop = 0;
+ infop = &fmtinfo[0];
+ xtype = etINVALID;
for(idx=0; idx<ArraySize(fmtinfo); idx++){
if( c==fmtinfo[idx].fmttype ){
infop = &fmtinfo[idx];
}
}
zExtra = 0;
- if( infop==0 ){
- return;
- }
/* Limit the precision to prevent overflowing buf[] during conversion */
length = width = 0;
break;
}
+ default: {
+ assert( xtype==etINVALID );
+ return;
+ }
}/* End switch over the format type */
/*
** The text of the conversion is pointed to by "bufpt" and is
** Append N bytes of text from z to the StrAccum object.
*/
SQLITE_PRIVATE void sqlite3StrAccumAppend(StrAccum *p, const char *z, int N){
+ assert( z!=0 || N==0 );
if( p->tooBig | p->mallocFailed ){
+ testcase(p->tooBig);
+ testcase(p->mallocFailed);
return;
}
if( N<0 ){
N = sqlite3Strlen30(z);
}
- if( N==0 || z==0 ){
+ if( N==0 || NEVER(z==0) ){
return;
}
if( p->nChar+N >= p->nAlloc ){
char *z;
char zBase[SQLITE_PRINT_BUF_SIZE];
StrAccum acc;
+ assert( db!=0 );
sqlite3StrAccumInit(&acc, zBase, sizeof(zBase),
- db ? db->aLimit[SQLITE_LIMIT_LENGTH] : SQLITE_MAX_LENGTH);
+ db->aLimit[SQLITE_LIMIT_LENGTH]);
acc.db = db;
sqlite3VXPrintf(&acc, 1, zFormat, ap);
z = sqlite3StrAccumFinish(&acc);
- if( acc.mallocFailed && db ){
+ if( acc.mallocFailed ){
db->mallocFailed = 1;
}
return z;
SQLITE_PRIVATE int sqlite3VdbeReleaseBuffers(Vdbe *p);
#endif
+#ifndef SQLITE_OMIT_SHARED_CACHE
+SQLITE_PRIVATE void sqlite3VdbeMutexArrayEnter(Vdbe *p);
+#else
+# define sqlite3VdbeMutexArrayEnter(p)
+#endif
+
SQLITE_PRIVATE int sqlite3VdbeMemTranslate(Mem*, u8);
#ifdef SQLITE_DEBUG
SQLITE_PRIVATE void sqlite3VdbePrintSql(Vdbe*);
#define READ_UTF16LE(zIn, c){ \
c = (*zIn++); \
c += ((*zIn++)<<8); \
- if( c>=0xD800 && c<0xE000 ){ \
+ if( c>=0xD800 && c<0xE000 ){ \
int c2 = (*zIn++); \
c2 += ((*zIn++)<<8); \
c = (c2&0x03FF) + ((c&0x003F)<<10) + (((c&0x03C0)+0x0040)<<10); \
- if( (c & 0xFFFF0000)==0 ) c = 0xFFFD; \
} \
}
#define READ_UTF16BE(zIn, c){ \
c = ((*zIn++)<<8); \
c += (*zIn++); \
- if( c>=0xD800 && c<0xE000 ){ \
+ if( c>=0xD800 && c<0xE000 ){ \
int c2 = ((*zIn++)<<8); \
c2 += (*zIn++); \
c = (c2&0x03FF) + ((c&0x003F)<<10) + (((c&0x03C0)+0x0040)<<10); \
- if( (c & 0xFFFF0000)==0 ) c = 0xFFFD; \
} \
}
|| (c&0xFFFFFFFE)==0xFFFE ){ c = 0xFFFD; } \
}
SQLITE_PRIVATE int sqlite3Utf8Read(
- const unsigned char *z, /* First byte of UTF-8 character */
- const unsigned char *zTerm, /* Pretend this byte is 0x00 */
+ const unsigned char *zIn, /* First byte of UTF-8 character */
const unsigned char **pzNext /* Write first byte past UTF-8 char here */
){
int c;
- READ_UTF8(z, zTerm, c);
- *pzNext = z;
+
+ /* Same as READ_UTF8() above but without the zTerm parameter.
+ ** For this routine, we assume the UTF8 string is always zero-terminated.
+ */
+ c = *(zIn++);
+ if( c>=0xc0 ){
+ c = sqlite3Utf8Trans1[c-0xc0];
+ while( (*zIn & 0xc0)==0x80 ){
+ c = (c<<6) + (0x3f & *(zIn++));
+ }
+ if( c<0x80
+ || (c&0xFFFFF800)==0xD800
+ || (c&0xFFFFFFFE)==0xFFFE ){ c = 0xFFFD; }
+ }
+ *pzNext = zIn;
return c;
}
int rc = SQLITE_OK;
u8 bom = 0;
- if( pMem->n<0 || pMem->n>1 ){
+ assert( pMem->n>=0 );
+ if( pMem->n>1 ){
u8 b1 = *(u8 *)pMem->z;
u8 b2 = *(((u8 *)pMem->z) + 1);
if( b1==0xFE && b2==0xFF ){
SQLITE_PRIVATE int sqlite3Utf8To8(unsigned char *zIn){
unsigned char *zOut = zIn;
unsigned char *zStart = zIn;
- unsigned char *zTerm = &zIn[sqlite3Strlen30((char *)zIn)];
u32 c;
while( zIn[0] ){
- c = sqlite3Utf8Read(zIn, zTerm, (const u8**)&zIn);
+ c = sqlite3Utf8Read(zIn, (const u8**)&zIn);
if( c!=0xfffd ){
WRITE_UTF8(zOut, c);
}
}
/*
-** pZ is a UTF-16 encoded unicode string. If nChar is less than zero,
-** return the number of bytes up to (but not including), the first pair
-** of consecutive 0x00 bytes in pZ. If nChar is not less than zero,
-** then return the number of bytes in the first nChar unicode characters
-** in pZ (or up until the first pair of 0x00 bytes, whichever comes first).
+** pZ is a UTF-16 encoded unicode string at least nChar characters long.
+** Return the number of bytes in the first nChar unicode characters
+** in pZ. nChar must be non-negative.
*/
SQLITE_PRIVATE int sqlite3Utf16ByteLen(const void *zIn, int nChar){
- unsigned int c = 1;
- char const *z = zIn;
+ int c;
+ unsigned char const *z = zIn;
int n = 0;
if( SQLITE_UTF16NATIVE==SQLITE_UTF16BE ){
/* Using an "if (SQLITE_UTF16NATIVE==SQLITE_UTF16BE)" construct here
** which branch will be followed. It is therefore assumed that no runtime
** penalty is paid for this "if" statement.
*/
- while( c && ((nChar<0) || n<nChar) ){
+ while( n<nChar ){
READ_UTF16BE(z, c);
n++;
}
}else{
- while( c && ((nChar<0) || n<nChar) ){
+ while( n<nChar ){
READ_UTF16LE(z, c);
n++;
}
}
- return (int)(z-(char const *)zIn)-((c==0)?2:0);
+ return (int)(z-(unsigned char const *)zIn);
}
#if defined(SQLITE_TEST)
unsigned int i, t;
unsigned char zBuf[20];
unsigned char *z;
- unsigned char *zTerm;
int n;
unsigned int c;
n = (int)(z-zBuf);
assert( n>0 && n<=4 );
z[0] = 0;
- zTerm = z;
z = zBuf;
- c = sqlite3Utf8Read(z, zTerm, (const u8**)&z);
+ c = sqlite3Utf8Read(z, (const u8**)&z);
t = i;
if( i>=0xD800 && i<=0xDFFF ) t = 0xFFFD;
if( (i&0xFFFFFFFE)==0xFFFE ) t = 0xFFFD;
unixEnterMutex();
releaseLockInfo(pFile->pLock);
releaseOpenCnt(pFile->pOpen);
- closeUnixFile(id);
unixLeaveMutex();
+ closeUnixFile(id);
}
return SQLITE_OK;
}
dotlockCheckReservedLock /* xCheckReservedLock method */
)
-#if SQLITE_ENABLE_LOCKING_STYLE
+#if SQLITE_ENABLE_LOCKING_STYLE && !OS_VXWORKS
IOMETHODS(
flockIoFinder, /* Finder function name */
flockIoMethods, /* sqlite3_io_methods object name */
#endif /* defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE */
+#if OS_VXWORKS && SQLITE_ENABLE_LOCKING_STYLE
+/*
+** This "finder" function attempts to determine the best locking strategy
+** for the database file "filePath". It then returns the sqlite3_io_methods
+** object that implements that strategy.
+**
+** This is for VXWorks only.
+*/
+static const sqlite3_io_methods *autolockIoFinderImpl(
+ const char *filePath, /* name of the database file */
+ int fd /* file descriptor open on the database file */
+){
+ struct flock lockInfo;
+
+ if( !filePath ){
+ /* If filePath==NULL that means we are dealing with a transient file
+ ** that does not need to be locked. */
+ return &nolockIoMethods;
+ }
+
+ /* Test if fcntl() is supported and use POSIX style locks.
+ ** Otherwise fall back to the named semaphore method.
+ */
+ lockInfo.l_len = 1;
+ lockInfo.l_start = 0;
+ lockInfo.l_whence = SEEK_SET;
+ lockInfo.l_type = F_RDLCK;
+ if( fcntl(fd, F_GETLK, &lockInfo)!=-1 ) {
+ return &posixIoMethods;
+ }else{
+ return &semIoMethods;
+ }
+}
+static const sqlite3_io_methods *(*const autolockIoFinder)(const char*,int)
+ = autolockIoFinderImpl;
+
+#endif /* OS_VXWORKS && SQLITE_ENABLE_LOCKING_STYLE */
+
/*
** An abstract type for a pointer to a IO method finder function:
*/
int flags, /* Input flags to control the opening */
int *pOutFlags /* Output flags returned to SQLite core */
){
- int fd = 0; /* File descriptor returned by open() */
+ int fd = -1; /* File descriptor returned by open() */
int dirfd = -1; /* Directory file descriptor */
int openFlags = 0; /* Flags to pass to open() */
int eType = flags&0xFFFFFF00; /* Type of file to open */
}
#endif
- assert(fd!=0);
+ assert( fd>=0 );
if( isOpenDirectory ){
rc = openDirectory(zPath, &dirfd);
if( rc!=SQLITE_OK ){
** array cannot be const.
*/
static sqlite3_vfs aVfs[] = {
-#if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__)
+#if SQLITE_ENABLE_LOCKING_STYLE && (OS_VXWORKS || defined(__APPLE__))
UNIXVFS("unix", autolockIoFinder ),
#else
UNIXVFS("unix", posixIoFinder ),
#endif
#if SQLITE_ENABLE_LOCKING_STYLE
UNIXVFS("unix-posix", posixIoFinder ),
+#if !OS_VXWORKS
UNIXVFS("unix-flock", flockIoFinder ),
#endif
+#endif
#if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__)
UNIXVFS("unix-afp", afpIoFinder ),
UNIXVFS("unix-proxy", proxyIoFinder ),
DWORD bytesPerSector = SQLITE_DEFAULT_SECTOR_SIZE;
char zFullpath[MAX_PATH+1];
int rc;
- DWORD dwRet = 0;
+ DWORD dwRet = 0, dwDummy;
/*
** We need to get the full path name of the file
}
}
dwRet = GetDiskFreeSpaceW((WCHAR*)zConverted,
- NULL,
+ &dwDummy,
&bytesPerSector,
- NULL,
- NULL);
+ &dwDummy,
+ &dwDummy);
#if SQLITE_OS_WINCE==0
}else{
int i;
}
}
dwRet = GetDiskFreeSpaceA((CHAR*)zConverted,
- NULL,
+ &dwDummy,
&bytesPerSector,
- NULL,
- NULL);
+ &dwDummy,
+ &dwDummy);
#endif
}
free(zConverted);
*/
struct Bitvec {
u32 iSize; /* Maximum bit index. Max iSize is 4,294,967,296. */
- u32 nSet; /* Number of bits that are set - only valid for aHash element */
- /* Max nSet is BITVEC_NINT. For BITVEC_SZ of 512, this would be 125. */
+ u32 nSet; /* Number of bits that are set - only valid for aHash
+ ** element. Max is BITVEC_NINT. For BITVEC_SZ of 512,
+ ** this would be 125. */
u32 iDivisor; /* Number of bits handled by each apSub[] entry. */
/* Should >=0 for apSub element. */
/* Max iDivisor is max(u32) / BITVEC_NPTR + 1. */
** is found.
*/
rc = sqlite3BitvecTest(0,0) + sqlite3BitvecTest(pBitvec, sz+1)
- + sqlite3BitvecTest(pBitvec, 0);
+ + sqlite3BitvecTest(pBitvec, 0)
+ + (sqlite3BitvecSize(pBitvec) - sz);
for(i=1; i<=sz; i++){
if( (TESTBIT(pV,i))!=sqlite3BitvecTest(pBitvec,i) ){
rc = i;
SQLITE_PRIVATE void sqlite3RowSetInsert(RowSet *p, i64 rowid){
struct RowSetEntry *pEntry;
struct RowSetEntry *pLast;
- if( p==0 ) return; /* Must have been a malloc failure */
+ assert( p!=0 );
if( p->nFresh==0 ){
struct RowSetChunk *pNew;
pNew = sqlite3DbMallocRaw(p->db, sizeof(*pNew));
pPager->journalOff = szJ;
break;
}else{
- /* If we are unable to rollback, then the database is probably
- ** going to end up being corrupt. It is corrupt to us, anyhow.
- ** Perhaps the next process to come along can fix it....
+ /* If we are unable to rollback, quit and return the error
+ ** code. This will cause the pager to enter the error state
+ ** so that no further harm will be done. Perhaps the next
+ ** process to come along will be able to rollback the database.
*/
- rc = SQLITE_CORRUPT_BKPT;
goto end_playback;
}
}
** source file journal.c).
*/
if( sqlite3JournalSize(pVfs)>sqlite3MemJournalSize() ){
- journalFileSize = sqlite3JournalSize(pVfs);
+ journalFileSize = ROUND8(sqlite3JournalSize(pVfs));
}else{
- journalFileSize = sqlite3MemJournalSize();
+ journalFileSize = ROUND8(sqlite3MemJournalSize());
}
/* Set the output variable to NULL in case an error occurs. */
** Journal file name (nPathname+8+1 bytes)
*/
pPtr = (u8 *)sqlite3MallocZero(
- sizeof(*pPager) + /* Pager structure */
- pcacheSize + /* PCache object */
- pVfs->szOsFile + /* The main db file */
- journalFileSize * 2 + /* The two journal files */
- nPathname + 1 + /* zFilename */
- nPathname + 8 + 1 /* zJournal */
+ ROUND8(sizeof(*pPager)) + /* Pager structure */
+ ROUND8(pcacheSize) + /* PCache object */
+ ROUND8(pVfs->szOsFile) + /* The main db file */
+ journalFileSize * 2 + /* The two journal files */
+ nPathname + 1 + /* zFilename */
+ nPathname + 8 + 1 /* zJournal */
);
+ assert( EIGHT_BYTE_ALIGNMENT(journalFileSize) );
if( !pPtr ){
sqlite3_free(zPathname);
return SQLITE_NOMEM;
}
pPager = (Pager*)(pPtr);
- pPager->pPCache = (PCache*)(pPtr += sizeof(*pPager));
- pPager->fd = (sqlite3_file*)(pPtr += pcacheSize);
- pPager->sjfd = (sqlite3_file*)(pPtr += pVfs->szOsFile);
+ pPager->pPCache = (PCache*)(pPtr += ROUND8(sizeof(*pPager)));
+ pPager->fd = (sqlite3_file*)(pPtr += ROUND8(pcacheSize));
+ pPager->sjfd = (sqlite3_file*)(pPtr += ROUND8(pVfs->szOsFile));
pPager->jfd = (sqlite3_file*)(pPtr += journalFileSize);
pPager->zFilename = (char*)(pPtr += journalFileSize);
+ assert( EIGHT_BYTE_ALIGNMENT(pPager->jfd) );
/* Fill in the Pager.zFilename and Pager.zJournal buffers, if required. */
if( zPathname ){
assert( !pPgOld || pPgOld->nRef==1 );
if( pPgOld ){
pPg->flags |= (pPgOld->flags&PGHDR_NEED_SYNC);
+ sqlite3PcacheDrop(pPgOld);
}
origPgno = pPg->pgno;
sqlite3PcacheMove(pPg, pgno);
- if( pPgOld ){
- sqlite3PcacheDrop(pPgOld);
- }
-
sqlite3PcacheMakeDirty(pPg);
pPager->dbModified = 1;
** PAGER_JOURNALMODE_MEMORY
**
** If the parameter is not _QUERY, then the journal-mode is set to the
-** value specified.
+** value specified. Except, an in-memory database can only have its
+** journal mode set to _OFF or _MEMORY. Attempts to change the journal
+** mode of an in-memory database to something other than _OFF or _MEMORY
+** are silently ignored.
**
** The returned indicate the current (possibly updated) journal-mode.
*/
SQLITE_PRIVATE int sqlite3PagerJournalMode(Pager *pPager, int eMode){
- if( !MEMDB ){
- assert( eMode==PAGER_JOURNALMODE_QUERY
- || eMode==PAGER_JOURNALMODE_DELETE
- || eMode==PAGER_JOURNALMODE_TRUNCATE
- || eMode==PAGER_JOURNALMODE_PERSIST
- || eMode==PAGER_JOURNALMODE_OFF
- || eMode==PAGER_JOURNALMODE_MEMORY );
- assert( PAGER_JOURNALMODE_QUERY<0 );
- if( eMode>=0 ){
- pPager->journalMode = (u8)eMode;
- }else{
- assert( eMode==PAGER_JOURNALMODE_QUERY );
- }
+ assert( eMode==PAGER_JOURNALMODE_QUERY
+ || eMode==PAGER_JOURNALMODE_DELETE
+ || eMode==PAGER_JOURNALMODE_TRUNCATE
+ || eMode==PAGER_JOURNALMODE_PERSIST
+ || eMode==PAGER_JOURNALMODE_OFF
+ || eMode==PAGER_JOURNALMODE_MEMORY );
+ assert( PAGER_JOURNALMODE_QUERY<0 );
+ if( eMode>=0 && (!MEMDB || eMode==PAGER_JOURNALMODE_MEMORY
+ || eMode==PAGER_JOURNALMODE_OFF) ){
+ pPager->journalMode = (u8)eMode;
}
return (int)pPager->journalMode;
}
/*
** Get/set the size-limit used for persistent journal files.
+**
+** Setting the size limit to -1 means no limit is enforced.
+** An attempt to set a limit smaller than -1 is a no-op.
*/
SQLITE_PRIVATE i64 sqlite3PagerJournalSizeLimit(Pager *pPager, i64 iLimit){
if( iLimit>=-1 ){
/************** End of btreeInt.h ********************************************/
/************** Continuing where we left off in btmutex.c ********************/
-#if SQLITE_THREADSAFE && !defined(SQLITE_OMIT_SHARED_CACHE)
+#ifndef SQLITE_OMIT_SHARED_CACHE
+#if SQLITE_THREADSAFE
+
+/*
+** Obtain the BtShared mutex associated with B-Tree handle p. Also,
+** set BtShared.db to the database handle associated with p and the
+** p->locked boolean to true.
+*/
+static void lockBtreeMutex(Btree *p){
+ assert( p->locked==0 );
+ assert( sqlite3_mutex_notheld(p->pBt->mutex) );
+ assert( sqlite3_mutex_held(p->db->mutex) );
+
+ sqlite3_mutex_enter(p->pBt->mutex);
+ p->pBt->db = p->db;
+ p->locked = 1;
+}
+
+/*
+** Release the BtShared mutex associated with B-Tree handle p and
+** clear the p->locked boolean.
+*/
+static void unlockBtreeMutex(Btree *p){
+ assert( p->locked==1 );
+ assert( sqlite3_mutex_held(p->pBt->mutex) );
+ assert( sqlite3_mutex_held(p->db->mutex) );
+ assert( p->db==p->pBt->db );
+ sqlite3_mutex_leave(p->pBt->mutex);
+ p->locked = 0;
+}
/*
** Enter a mutex on the given BTree object.
/* We should already hold a lock on the database connection */
assert( sqlite3_mutex_held(p->db->mutex) );
+ /* Unless the database is sharable and unlocked, then BtShared.db
+ ** should already be set correctly. */
+ assert( (p->locked==0 && p->sharable) || p->pBt->db==p->db );
+
if( !p->sharable ) return;
p->wantToLock++;
if( p->locked ) return;
** procedure that follows. Just be sure not to block.
*/
if( sqlite3_mutex_try(p->pBt->mutex)==SQLITE_OK ){
+ p->pBt->db = p->db;
p->locked = 1;
return;
}
assert( pLater->pNext==0 || pLater->pNext->pBt>pLater->pBt );
assert( !pLater->locked || pLater->wantToLock>0 );
if( pLater->locked ){
- sqlite3_mutex_leave(pLater->pBt->mutex);
- pLater->locked = 0;
+ unlockBtreeMutex(pLater);
}
}
- sqlite3_mutex_enter(p->pBt->mutex);
- p->locked = 1;
+ lockBtreeMutex(p);
for(pLater=p->pNext; pLater; pLater=pLater->pNext){
if( pLater->wantToLock ){
- sqlite3_mutex_enter(pLater->pBt->mutex);
- pLater->locked = 1;
+ lockBtreeMutex(pLater);
}
}
}
assert( p->wantToLock>0 );
p->wantToLock--;
if( p->wantToLock==0 ){
- assert( p->locked );
- sqlite3_mutex_leave(p->pBt->mutex);
- p->locked = 0;
+ unlockBtreeMutex(p);
}
}
}
#ifndef NDEBUG
/*
-** Return true if the BtShared mutex is held on the btree.
-**
-** This routine makes no determination one way or another if the
-** database connection mutex is held.
+** Return true if the BtShared mutex is held on the btree, or if the
+** B-Tree is not marked as sharable.
**
** This routine is used only from within assert() statements.
*/
SQLITE_PRIVATE int sqlite3BtreeHoldsMutex(Btree *p){
- return (p->sharable==0 ||
- (p->locked && p->wantToLock && sqlite3_mutex_held(p->pBt->mutex)));
+ assert( p->sharable==0 || p->locked==0 || p->wantToLock>0 );
+ assert( p->sharable==0 || p->locked==0 || p->db==p->pBt->db );
+ assert( p->sharable==0 || p->locked==0 || sqlite3_mutex_held(p->pBt->mutex) );
+ assert( p->sharable==0 || p->locked==0 || sqlite3_mutex_held(p->db->mutex) );
+
+ return (p->sharable==0 || p->locked);
}
#endif
assert( sqlite3_mutex_held(db->mutex) );
for(i=0; i<db->nDb; i++){
p = db->aDb[i].pBt;
+ assert( !p || (p->locked==0 && p->sharable) || p->pBt->db==p->db );
if( p && p->sharable ){
p->wantToLock++;
if( !p->locked ){
while( p->locked && p->pNext ) p = p->pNext;
for(pLater = p->pNext; pLater; pLater=pLater->pNext){
if( pLater->locked ){
- sqlite3_mutex_leave(pLater->pBt->mutex);
- pLater->locked = 0;
+ unlockBtreeMutex(pLater);
}
}
while( p ){
- sqlite3_mutex_enter(p->pBt->mutex);
- p->locked++;
+ lockBtreeMutex(p);
p = p->pNext;
}
}
assert( p->wantToLock>0 );
p->wantToLock--;
if( p->wantToLock==0 ){
- assert( p->locked );
- sqlite3_mutex_leave(p->pBt->mutex);
- p->locked = 0;
+ unlockBtreeMutex(p);
}
}
}
p->wantToLock++;
if( !p->locked && p->sharable ){
- sqlite3_mutex_enter(p->pBt->mutex);
- p->locked = 1;
+ lockBtreeMutex(p);
}
}
}
p->wantToLock--;
if( p->wantToLock==0 && p->locked ){
- sqlite3_mutex_leave(p->pBt->mutex);
- p->locked = 0;
+ unlockBtreeMutex(p);
}
}
}
-
-#endif /* SQLITE_THREADSAFE && !SQLITE_OMIT_SHARED_CACHE */
+#else
+SQLITE_PRIVATE void sqlite3BtreeEnter(Btree *p){
+ p->pBt->db = p->db;
+}
+SQLITE_PRIVATE void sqlite3BtreeEnterAll(sqlite3 *db){
+ int i;
+ for(i=0; i<db->nDb; i++){
+ Btree *p = db->aDb[i].pBt;
+ if( p ){
+ p->pBt->db = p->db;
+ }
+ }
+}
+#endif /* if SQLITE_THREADSAFE */
+#endif /* ifndef SQLITE_OMIT_SHARED_CACHE */
/************** End of btmutex.c *********************************************/
/************** Begin file btree.c *******************************************/
assert( eLock==READ_LOCK || eLock==WRITE_LOCK );
assert( p->db!=0 );
+ /* If requesting a write-lock, then the Btree must have an open write
+ ** transaction on this file. And, obviously, for this to be so there
+ ** must be an open write transaction on the file itself.
+ */
+ assert( eLock==READ_LOCK || (p==pBt->pWriter && p->inTrans==TRANS_WRITE) );
+ assert( eLock==READ_LOCK || pBt->inTransaction==TRANS_WRITE );
+
/* This is a no-op if the shared-cache is not enabled */
if( !p->sharable ){
return SQLITE_OK;
iTab==MASTER_ROOT
){
for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
- if( pIter->pBtree!=p && pIter->iTable==iTab &&
- (pIter->eLock!=eLock || eLock!=READ_LOCK) ){
+ /* The condition (pIter->eLock!=eLock) in the following if(...)
+ ** statement is a simplification of:
+ **
+ ** (eLock==WRITE_LOCK || pIter->eLock==WRITE_LOCK)
+ **
+ ** since we know that if eLock==WRITE_LOCK, then no other connection
+ ** may hold a WRITE_LOCK on any table in this file (since there can
+ ** only be a single writer).
+ */
+ assert( pIter->eLock==READ_LOCK || pIter->eLock==WRITE_LOCK );
+ assert( eLock==READ_LOCK || pIter->pBtree==p || pIter->eLock==READ_LOCK);
+ if( pIter->pBtree!=p && pIter->iTable==iTab && pIter->eLock!=eLock ){
sqlite3ConnectionBlocked(p->db, pIter->pBtree->db);
if( eLock==WRITE_LOCK ){
assert( p==pBt->pWriter );
/*
** Release all the table locks (locks obtained via calls to
** the setSharedCacheTableLock() procedure) held by Btree handle p.
+**
+** This function assumes that handle p has an open read or write
+** transaction. If it does not, then the BtShared.isPending variable
+** may be incorrectly cleared.
*/
static void clearAllSharedCacheTableLocks(Btree *p){
BtShared *pBt = p->pBt;
assert( sqlite3BtreeHoldsMutex(p) );
assert( p->sharable || 0==*ppIter );
+ assert( p->inTrans>0 );
while( *ppIter ){
BtLock *pLock = *ppIter;
assert( pBt->isExclusive==0 || pBt->pWriter==pLock->pBtree );
+ assert( pLock->pBtree->inTrans>=pLock->eLock );
if( pLock->pBtree==p ){
*ppIter = pLock->pNext;
sqlite3_free(pLock);
}
/*
-** Allocate nByte bytes of space on a page.
+** Allocate nByte bytes of space from within the B-Tree page passed
+** as the first argument. Return the index into pPage->aData[] of the
+** first byte of allocated space.
**
-** Return the index into pPage->aData[] of the first byte of
-** the new allocation. The caller guarantees that there is enough
-** space. This routine will never fail.
+** The caller guarantees that the space between the end of the cell-offset
+** array and the start of the cell-content area is at least nByte bytes
+** in size. So this routine can never fail.
**
-** If the page contains nBytes of free space but does not contain
-** nBytes of contiguous free space, then this routine automatically
-** calls defragmentPage() to consolidate all free space before
-** allocating the new chunk.
+** If there are already 60 or more bytes of fragments within the page,
+** the page is defragmented before returning. If this were not done there
+** is a chance that the number of fragmented bytes could eventually
+** overflow the single-byte field of the page-header in which this value
+** is stored.
*/
static int allocateSpace(MemPage *pPage, int nByte){
- int addr, pc, hdr;
- int size;
- int nFrag;
+ const int hdr = pPage->hdrOffset; /* Local cache of pPage->hdrOffset */
+ u8 * const data = pPage->aData; /* Local cache of pPage->aData */
+ int nFrag; /* Number of fragmented bytes on pPage */
int top;
- int nCell;
- int cellOffset;
- unsigned char *data;
- data = pPage->aData;
assert( sqlite3PagerIswriteable(pPage->pDbPage) );
assert( pPage->pBt );
assert( sqlite3_mutex_held(pPage->pBt->mutex) );
assert( nByte>=0 ); /* Minimum cell size is 4 */
assert( pPage->nFree>=nByte );
assert( pPage->nOverflow==0 );
- pPage->nFree -= (u16)nByte;
- hdr = pPage->hdrOffset;
+ /* Assert that the space between the cell-offset array and the
+ ** cell-content area is greater than nByte bytes.
+ */
+ assert( nByte <= (
+ get2byte(&data[hdr+5])-(hdr+8+(pPage->leaf?0:4)+2*get2byte(&data[hdr+3]))
+ ));
+
+ pPage->nFree -= (u16)nByte;
nFrag = data[hdr+7];
- if( nFrag<60 ){
- /* Search the freelist looking for a slot big enough to satisfy the
- ** space request. */
- addr = hdr+1;
- while( (pc = get2byte(&data[addr]))>0 ){
- size = get2byte(&data[pc+2]);
+ if( nFrag>=60 ){
+ defragmentPage(pPage);
+ }else{
+ /* Search the freelist looking for a free slot big enough to satisfy
+ ** the request. The allocation is made from the first free slot in
+ ** the list that is large enough to accomadate it.
+ */
+ int pc, addr;
+ for(addr=hdr+1; (pc = get2byte(&data[addr]))>0; addr=pc){
+ int size = get2byte(&data[pc+2]); /* Size of free slot */
if( size>=nByte ){
int x = size - nByte;
- if( size<nByte+4 ){
+ if( x<4 ){
+ /* Remove the slot from the free-list. Update the number of
+ ** fragmented bytes within the page. */
memcpy(&data[addr], &data[pc], 2);
data[hdr+7] = (u8)(nFrag + x);
- return pc;
}else{
+ /* The slot remains on the free-list. Reduce its size to account
+ ** for the portion used by the new allocation. */
put2byte(&data[pc+2], x);
- return pc + x;
}
+ return pc + x;
}
- addr = pc;
}
}
/* Allocate memory from the gap in between the cell pointer array
** and the cell content area.
*/
- top = get2byte(&data[hdr+5]);
- nCell = get2byte(&data[hdr+3]);
- cellOffset = pPage->cellOffset;
- if( nFrag>=60 || cellOffset + 2*nCell > top - nByte ){
- defragmentPage(pPage);
- top = get2byte(&data[hdr+5]);
- }
- top -= nByte;
- assert( cellOffset + 2*nCell <= top );
+ top = get2byte(&data[hdr+5]) - nByte;
put2byte(&data[hdr+5], top);
- assert( sqlite3PagerIswriteable(pPage->pDbPage) );
return top;
}
static void pageReinit(DbPage *pData){
MemPage *pPage;
pPage = (MemPage *)sqlite3PagerGetExtra(pData);
+ assert( sqlite3PagerPageRefcount(pData)>0 );
if( pPage->isInit ){
assert( sqlite3_mutex_held(pPage->pBt->mutex) );
pPage->isInit = 0;
- if( sqlite3PagerPageRefcount(pData)>0 ){
+ if( sqlite3PagerPageRefcount(pData)>1 ){
/* pPage might not be a btree page; it might be an overflow page
** or ptrmap page or a free page. In those cases, the following
** call to sqlite3BtreeInitPage() will likely return SQLITE_CORRUPT.
** If this Btree is a candidate for shared cache, try to find an
** existing BtShared object that we can share with
*/
- if( isMemdb==0
- && (db->flags & SQLITE_Vtab)==0
- && zFilename && zFilename[0]
- ){
+ if( isMemdb==0 && zFilename && zFilename[0] ){
if( sqlite3GlobalConfig.sharedCacheEnabled ){
int nFullPathname = pVfs->mxPathname+1;
char *zFullPathname = sqlite3Malloc(nFullPathname);
if( rc!=SQLITE_OK ){
goto btree_open_out;
}
+ pBt->db = db;
sqlite3PagerSetBusyhandler(pBt->pPager, btreeInvokeBusyHandler, pBt);
p->pBt = pBt;
/* Close all cursors opened via this handle. */
assert( sqlite3_mutex_held(p->db->mutex) );
sqlite3BtreeEnter(p);
- pBt->db = p->db;
pCur = pBt->pCursor;
while( pCur ){
BtCursor *pTmp = pCur;
#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) || !defined(SQLITE_OMIT_VACUUM)
/*
** Change the default pages size and the number of reserved bytes per page.
+** Or, if the page size has already been fixed, return SQLITE_READONLY
+** without changing anything.
**
** The page size must be a power of 2 between 512 and 65536. If the page
** size supplied does not meet this constraint then the page size is not
**
** If parameter nReserve is less than zero, then the number of reserved
** bytes per page is left unchanged.
+**
+** If the iFix!=0 then the pageSizeFixed flag is set so that the page size
+** and autovacuum mode can no longer be changed.
*/
-SQLITE_PRIVATE int sqlite3BtreeSetPageSize(Btree *p, int pageSize, int nReserve){
+SQLITE_PRIVATE int sqlite3BtreeSetPageSize(Btree *p, int pageSize, int nReserve, int iFix){
int rc = SQLITE_OK;
BtShared *pBt = p->pBt;
assert( nReserve>=-1 && nReserve<=255 );
rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize);
}
pBt->usableSize = pBt->pageSize - (u16)nReserve;
+ if( iFix ) pBt->pageSizeFixed = 1;
sqlite3BtreeLeave(p);
return rc;
}
int nPage;
assert( sqlite3_mutex_held(pBt->mutex) );
- if( pBt->pPage1 ) return SQLITE_OK;
+ assert( pBt->pPage1==0 );
rc = sqlite3BtreeGetPage(pBt, 1, &pPage1, 0);
if( rc!=SQLITE_OK ) return rc;
int rc = SQLITE_OK;
sqlite3BtreeEnter(p);
- pBt->db = p->db;
btreeIntegrity(p);
/* If the btree is already in a write-transaction, or it
#endif
do {
- if( pBt->pPage1==0 ){
- do{
- rc = lockBtree(pBt);
- }while( pBt->pPage1==0 && rc==SQLITE_OK );
- }
+ /* Call lockBtree() until either pBt->pPage1 is populated or
+ ** lockBtree() returns something other than SQLITE_OK. lockBtree()
+ ** may return SQLITE_OK but leave pBt->pPage1 set to 0 if after
+ ** reading page 1 it discovers that the page-size of the database
+ ** file is not pBt->pageSize. In this case lockBtree() will update
+ ** pBt->pageSize to the page-size of the file on disk.
+ */
+ while( pBt->pPage1==0 && SQLITE_OK==(rc = lockBtree(pBt)) );
if( rc==SQLITE_OK && wrflag ){
if( pBt->readOnly ){
}
/*
-** Somewhere on pPage, which is guarenteed to be a btree page, not an overflow
+** Somewhere on pPage, which is guaranteed to be a btree page, not an overflow
** page, is a pointer to page iFrom. Modify this pointer so that it points to
** iTo. Parameter eType describes the type of pointer to be modified, as
** follows:
Pgno nFreeList; /* Number of pages still on the free-list */
assert( sqlite3_mutex_held(pBt->mutex) );
+ assert( iLastPg>nFin );
if( !PTRMAP_ISPAGE(pBt, iLastPg) && iLastPg!=PENDING_BYTE_PAGE(pBt) ){
int rc;
Pgno iPtrPage;
nFreeList = get4byte(&pBt->pPage1->aData[36]);
- if( nFreeList==0 || nFin==iLastPg ){
+ if( nFreeList==0 ){
return SQLITE_DONE;
}
BtShared *pBt = p->pBt;
sqlite3BtreeEnter(p);
- pBt->db = p->db;
assert( pBt->inTransaction==TRANS_WRITE && p->inTrans==TRANS_WRITE );
if( !pBt->autoVacuum ){
rc = SQLITE_DONE;
const int pgsz = pBt->pageSize;
Pgno nOrig = pagerPagecount(pBt);
- if( PTRMAP_ISPAGE(pBt, nOrig) ){
+ if( PTRMAP_ISPAGE(pBt, nOrig) || nOrig==PENDING_BYTE_PAGE(pBt) ){
+ /* It is not possible to create a database for which the final page
+ ** is either a pointer-map page or the pending-byte page. If one
+ ** is encountered, this indicates corruption.
+ */
return SQLITE_CORRUPT_BKPT;
}
- if( nOrig==PENDING_BYTE_PAGE(pBt) ){
- nOrig--;
- }
+
nFree = get4byte(&pBt->pPage1->aData[36]);
nPtrmap = (nFree-nOrig+PTRMAP_PAGENO(pBt, nOrig)+pgsz/5)/(pgsz/5);
nFin = nOrig - nFree - nPtrmap;
- if( nOrig>PENDING_BYTE_PAGE(pBt) && nFin<=PENDING_BYTE_PAGE(pBt) ){
+ if( nOrig>PENDING_BYTE_PAGE(pBt) && nFin<PENDING_BYTE_PAGE(pBt) ){
nFin--;
}
while( PTRMAP_ISPAGE(pBt, nFin) || nFin==PENDING_BYTE_PAGE(pBt) ){
if( p->inTrans==TRANS_WRITE ){
BtShared *pBt = p->pBt;
sqlite3BtreeEnter(p);
- pBt->db = p->db;
#ifndef SQLITE_OMIT_AUTOVACUUM
if( pBt->autoVacuum ){
rc = autoVacuumCommit(pBt);
BtShared *pBt = p->pBt;
sqlite3BtreeEnter(p);
- pBt->db = p->db;
btreeIntegrity(p);
/* If the handle has a write-transaction open, commit the shared-btrees
}
pBt->inTransaction = TRANS_READ;
}
- clearAllSharedCacheTableLocks(p);
/* If the handle has any kind of transaction open, decrement the transaction
** count of the shared btree. If the transaction count reaches 0, set
** will unlock the pager.
*/
if( p->inTrans!=TRANS_NONE ){
+ clearAllSharedCacheTableLocks(p);
pBt->nTransaction--;
if( 0==pBt->nTransaction ){
pBt->inTransaction = TRANS_NONE;
MemPage *pPage1;
sqlite3BtreeEnter(p);
- pBt->db = p->db;
rc = saveAllCursors(pBt, 0, 0);
#ifndef SQLITE_OMIT_SHARED_CACHE
if( rc!=SQLITE_OK ){
}
#endif
btreeIntegrity(p);
- clearAllSharedCacheTableLocks(p);
if( p->inTrans==TRANS_WRITE ){
int rc2;
}
if( p->inTrans!=TRANS_NONE ){
+ clearAllSharedCacheTableLocks(p);
assert( pBt->nTransaction>0 );
pBt->nTransaction--;
if( 0==pBt->nTransaction ){
int rc;
BtShared *pBt = p->pBt;
sqlite3BtreeEnter(p);
- pBt->db = p->db;
assert( p->inTrans==TRANS_WRITE );
assert( pBt->readOnly==0 );
assert( iStatement>0 );
assert( op==SAVEPOINT_RELEASE || op==SAVEPOINT_ROLLBACK );
assert( iSavepoint>=0 || (iSavepoint==-1 && op==SAVEPOINT_ROLLBACK) );
sqlite3BtreeEnter(p);
- pBt->db = p->db;
rc = sqlite3PagerSavepoint(pBt->pPager, op, iSavepoint);
if( rc==SQLITE_OK ){
rc = newDatabase(pBt);
){
int rc;
sqlite3BtreeEnter(p);
- p->pBt->db = p->db;
rc = btreeCursor(p, iTable, wrFlag, pKeyInfo, pCur);
sqlite3BtreeLeave(p);
return rc;
int i;
BtShared *pBt = pCur->pBt;
sqlite3BtreeEnter(pBtree);
- pBt->db = pBtree->db;
sqlite3BtreeClearCursor(pCur);
if( pCur->pPrev ){
pCur->pPrev->pNext = pCur->pNext;
){
int rc; /* Status code */
UnpackedRecord *pIdxKey; /* Unpacked index key */
- UnpackedRecord aSpace[16]; /* Temp space for pIdxKey - to avoid a malloc */
+ char aSpace[150]; /* Temp space for pIdxKey - to avoid a malloc */
+
if( pKey ){
assert( nKey==(i64)(int)nKey );
while( nOvfl-- ){
Pgno iNext = 0;
MemPage *pOvfl = 0;
- if( ovflPgno==0 || ovflPgno>pagerPagecount(pBt) ){
+ if( ovflPgno<2 || ovflPgno>pagerPagecount(pBt) ){
+ /* 0 is not a legal page number and page 1 cannot be an
+ ** overflow page. Therefore if ovflPgno<2 or past the end of the
+ ** file the database must be corrupt. */
return SQLITE_CORRUPT_BKPT;
}
if( nOvfl ){
}
szCell = (u16*)&apCell[nMaxCells];
aCopy[0] = (u8*)&szCell[nMaxCells];
- assert( ((aCopy[0] - (u8*)0) & 7)==0 ); /* 8-byte alignment required */
+ assert( EIGHT_BYTE_ALIGNMENT(aCopy[0]) );
for(i=1; i<NB; i++){
aCopy[i] = &aCopy[i-1][pBt->pageSize+ROUND8(sizeof(MemPage))];
assert( ((aCopy[i] - (u8*)0) & 7)==0 ); /* 8-byte alignment required */
}
aSpace1 = &aCopy[NB-1][pBt->pageSize+ROUND8(sizeof(MemPage))];
- assert( ((aSpace1 - (u8*)0) & 7)==0 ); /* 8-byte alignment required */
+ assert( EIGHT_BYTE_ALIGNMENT(aSpace1) );
if( ISAUTOVACUUM ){
aFrom = &aSpace1[pBt->pageSize];
}
rc = sqlite3BtreeNext(&leafCur, ¬Used);
}
pLeafPage = leafCur.apPage[leafCur.iPage];
- assert( pLeafPage->pgno==leafPgno );
- assert( leafCur.aiIdx[leafCur.iPage]==0 );
+ assert( rc!=SQLITE_OK || pLeafPage->pgno==leafPgno );
+ assert( rc!=SQLITE_OK || leafCur.aiIdx[leafCur.iPage]==0 );
}
if( SQLITE_OK==rc
SQLITE_PRIVATE int sqlite3BtreeCreateTable(Btree *p, int *piTable, int flags){
int rc;
sqlite3BtreeEnter(p);
- p->pBt->db = p->db;
rc = btreeCreateTable(p, piTable, flags);
sqlite3BtreeLeave(p);
return rc;
int rc;
BtShared *pBt = p->pBt;
sqlite3BtreeEnter(p);
- pBt->db = p->db;
assert( p->inTrans==TRANS_WRITE );
if( (rc = checkForReadConflicts(p, iTable, 0, 1))!=SQLITE_OK ){
/* nothing to do */
SQLITE_PRIVATE int sqlite3BtreeDropTable(Btree *p, int iTable, int *piMoved){
int rc;
sqlite3BtreeEnter(p);
- p->pBt->db = p->db;
rc = btreeDropTable(p, iTable, piMoved);
sqlite3BtreeLeave(p);
return rc;
BtShared *pBt = p->pBt;
sqlite3BtreeEnter(p);
- pBt->db = p->db;
/* Reading a meta-data value requires a read-lock on page 1 (and hence
** the sqlite_master table. We grab this lock regardless of whether or
if( idx==4 && *pMeta>0 ) pBt->readOnly = 1;
#endif
- /* Grab the read-lock on page 1. */
- rc = setSharedCacheTableLock(p, 1, READ_LOCK);
+ /* If there is currently an open transaction, grab a read-lock
+ ** on page 1 of the database file. This is done to make sure that
+ ** no other connection can modify the meta value just read from
+ ** the database until the transaction is concluded.
+ */
+ if( p->inTrans>0 ){
+ rc = setSharedCacheTableLock(p, 1, READ_LOCK);
+ }
sqlite3BtreeLeave(p);
return rc;
}
int rc;
assert( idx>=1 && idx<=15 );
sqlite3BtreeEnter(p);
- pBt->db = p->db;
assert( p->inTrans==TRANS_WRITE );
assert( pBt->pPage1!=0 );
pP1 = pBt->pPage1->aData;
char zErr[100];
sqlite3BtreeEnter(p);
- pBt->db = p->db;
nRef = sqlite3PagerRefcount(pBt->pPager);
if( lockBtreeWithRetry(p)!=SQLITE_OK ){
*pnErr = 1;
assert( !(fg&(MEM_Str|MEM_Blob)) );
assert( fg&(MEM_Int|MEM_Real) );
assert( (pMem->flags&MEM_RowSet)==0 );
+ assert( EIGHT_BYTE_ALIGNMENT(pMem) );
if( sqlite3VdbeMemGrow(pMem, nByte, 0) ){
SQLITE_PRIVATE i64 sqlite3VdbeIntValue(Mem *pMem){
int flags;
assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
+ assert( EIGHT_BYTE_ALIGNMENT(pMem) );
flags = pMem->flags;
if( flags & MEM_Int ){
return pMem->u.i;
*/
SQLITE_PRIVATE double sqlite3VdbeRealValue(Mem *pMem){
assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
+ assert( EIGHT_BYTE_ALIGNMENT(pMem) );
if( pMem->flags & MEM_Real ){
return pMem->r;
}else if( pMem->flags & MEM_Int ){
assert( pMem->flags & MEM_Real );
assert( (pMem->flags & MEM_RowSet)==0 );
assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
+ assert( EIGHT_BYTE_ALIGNMENT(pMem) );
pMem->u.i = doubleToInt64(pMem->r);
if( pMem->r==(double)pMem->u.i ){
SQLITE_PRIVATE int sqlite3VdbeMemIntegerify(Mem *pMem){
assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
assert( (pMem->flags & MEM_RowSet)==0 );
+ assert( EIGHT_BYTE_ALIGNMENT(pMem) );
+
pMem->u.i = sqlite3VdbeIntValue(pMem);
MemSetTypeFlag(pMem, MEM_Int);
return SQLITE_OK;
*/
SQLITE_PRIVATE int sqlite3VdbeMemRealify(Mem *pMem){
assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
+ assert( EIGHT_BYTE_ALIGNMENT(pMem) );
+
pMem->r = sqlite3VdbeRealValue(pMem);
MemSetTypeFlag(pMem, MEM_Real);
return SQLITE_OK;
u8 *pEnd, /* Pointer to 1 byte past the end of *ppFrom buffer */
int *pnByte /* If allocation cannot be made, increment *pnByte */
){
+ assert( EIGHT_BYTE_ALIGNMENT(*ppFrom) );
if( (*(void**)pp)==0 ){
nByte = ROUND8(nByte);
if( (pEnd - *ppFrom)>=nByte ){
if( isExplain && nMem<10 ){
nMem = 10;
}
+ zCsr += (zCsr - (u8*)0)&7;
+ assert( EIGHT_BYTE_ALIGNMENT(zCsr) );
+ if( zEnd<zCsr ) zEnd = zCsr;
do {
memset(zCsr, 0, zEnd-zCsr);
return rc;
}
+/*
+** If SQLite is compiled to support shared-cache mode and to be threadsafe,
+** this routine obtains the mutex associated with each BtShared structure
+** that may be accessed by the VM passed as an argument. In doing so it
+** sets the BtShared.db member of each of the BtShared structures, ensuring
+** that the correct busy-handler callback is invoked if required.
+**
+** If SQLite is not threadsafe but does support shared-cache mode, then
+** sqlite3BtreeEnterAll() is invoked to set the BtShared.db variables
+** of all of BtShared structures accessible via the database handle
+** associated with the VM. Of course only a subset of these structures
+** will be accessed by the VM, and we could use Vdbe.btreeMask to figure
+** that subset out, but there is no advantage to doing so.
+**
+** If SQLite is not threadsafe and does not support shared-cache mode, this
+** function is a no-op.
+*/
+#ifndef SQLITE_OMIT_SHARED_CACHE
+SQLITE_PRIVATE void sqlite3VdbeMutexArrayEnter(Vdbe *p){
+#if SQLITE_THREADSAFE
+ sqlite3BtreeMutexArrayEnter(&p->aMutex);
+#else
+ sqlite3BtreeEnterAll(p->db);
+#endif
+}
+#endif
+
/*
** This routine is called the when a VDBE tries to halt. If the VDBE
** has made changes and is in autocommit mode, then commit those
int isSpecialError; /* Set to true if a 'special' error */
/* Lock all btrees used by the statement */
- sqlite3BtreeMutexArrayEnter(&p->aMutex);
+ sqlite3VdbeMutexArrayEnter(p);
/* Check for one of the special errors */
mrc = p->rc & 0xff;
KeyInfo *pKeyInfo, /* Information about the record format */
int nKey, /* Size of the binary record */
const void *pKey, /* The binary record */
- UnpackedRecord *pSpace,/* Space available to hold resulting object */
+ char *pSpace, /* Unaligned space available to hold the object */
int szSpace /* Size of pSpace[] in bytes */
){
const unsigned char *aKey = (const unsigned char *)pKey;
- UnpackedRecord *p;
- int nByte, d;
+ UnpackedRecord *p; /* The unpacked record that we will return */
+ int nByte; /* Memory space needed to hold p, in bytes */
+ int d;
u32 idx;
- u16 u; /* Unsigned loop counter */
+ u16 u; /* Unsigned loop counter */
u32 szHdr;
Mem *pMem;
+ int nOff; /* Increase pSpace by this much to 8-byte align it */
- assert( sizeof(Mem)>sizeof(*p) );
- nByte = sizeof(Mem)*(pKeyInfo->nField+2);
+ /*
+ ** We want to shift the pointer pSpace up such that it is 8-byte aligned.
+ ** Thus, we need to calculate a value, nOff, between 0 and 7, to shift
+ ** it by. If pSpace is already 8-byte aligned, nOff should be zero.
+ */
+ nOff = (8 - (SQLITE_PTR_TO_INT(pSpace) & 7)) & 7;
+ pSpace += nOff;
+ szSpace -= nOff;
+ nByte = ROUND8(sizeof(UnpackedRecord)) + sizeof(Mem)*(pKeyInfo->nField+1);
if( nByte>szSpace ){
p = sqlite3DbMallocRaw(pKeyInfo->db, nByte);
if( p==0 ) return 0;
p->flags = UNPACKED_NEED_FREE | UNPACKED_NEED_DESTROY;
}else{
- p = pSpace;
+ p = (UnpackedRecord*)pSpace;
p->flags = UNPACKED_NEED_DESTROY;
}
p->pKeyInfo = pKeyInfo;
p->nField = pKeyInfo->nField + 1;
- p->aMem = pMem = &((Mem*)p)[1];
+ p->aMem = pMem = (Mem*)&((char*)p)[ROUND8(sizeof(UnpackedRecord))];
+ assert( EIGHT_BYTE_ALIGNMENT(pMem) );
idx = getVarint32(aKey, szHdr);
d = szHdr;
u = 0;
}
if( p->pc<=0 && p->expired ){
- if( p->rc==SQLITE_OK ){
+ if( ALWAYS(p->rc==SQLITE_OK) ){
p->rc = SQLITE_SCHEMA;
}
rc = SQLITE_ERROR;
sqlite3_reset(pStmt);
v->expired = 0;
}
- if( rc==SQLITE_SCHEMA && v->isPrepareV2 && db->pErr ){
+ if( rc==SQLITE_SCHEMA && ALWAYS(v->isPrepareV2) && ALWAYS(db->pErr) ){
/* This case occurs after failing to recompile an sql statement.
** The error message from the SQL compiler has already been loaded
** into the database handle. This block copies the error message
const char *zName = context->pFunc->zName;
char *zErr;
UNUSED_PARAMETER2(NotUsed, NotUsed2);
- zErr = sqlite3MPrintf(0,
+ zErr = sqlite3_mprintf(
"unable to use function %s in the requested context", zName);
sqlite3_result_error(context, zErr, -1);
sqlite3_free(zErr);
}else{
/* ((double)0) In case of SQLITE_OMIT_FLOATING_POINT... */
static const Mem nullMem = {{0}, (double)0, 0, "", 0, MEM_Null, SQLITE_NULL, 0, 0, 0 };
- if( pVm && pVm->db ){
+ if( pVm && ALWAYS(pVm->db) ){
sqlite3_mutex_enter(pVm->db->mutex);
sqlite3Error(pVm->db, SQLITE_RANGE, 0);
}
const void *ret = 0;
Vdbe *p = (Vdbe *)pStmt;
int n;
+ sqlite3 *db = p->db;
-
- if( p!=0 ){
- n = sqlite3_column_count(pStmt);
- if( N<n && N>=0 ){
- N += useType*n;
- sqlite3_mutex_enter(p->db->mutex);
- ret = xFunc(&p->aColName[N]);
-
- /* A malloc may have failed inside of the xFunc() call. If this
- ** is the case, clear the mallocFailed flag and return NULL.
- */
- if( p->db && p->db->mallocFailed ){
- p->db->mallocFailed = 0;
- ret = 0;
- }
- sqlite3_mutex_leave(p->db->mutex);
+ assert( db!=0 );
+ n = sqlite3_column_count(pStmt);
+ if( N<n && N>=0 ){
+ N += useType*n;
+ sqlite3_mutex_enter(db->mutex);
+ assert( db->mallocFailed==0 );
+ ret = xFunc(&p->aColName[N]);
+ /* A malloc may have failed inside of the xFunc() call. If this
+ ** is the case, clear the mallocFailed flag and return NULL.
+ */
+ if( db->mallocFailed ){
+ db->mallocFailed = 0;
+ ret = 0;
}
+ sqlite3_mutex_leave(db->mutex);
}
return ret;
}
rc = sqlite3VdbeChangeEncoding(&p->aVar[i-1], ENC(p->db));
}
sqlite3_mutex_leave(p->db->mutex);
+ rc = sqlite3ApiExit(p->db, rc);
}
- rc = sqlite3ApiExit(p->db, rc);
return rc;
}
SQLITE_API int sqlite3_bind_zeroblob(sqlite3_stmt *pStmt, int i, int n){
*/
static void createVarMap(Vdbe *p){
if( !p->okVar ){
+ int j;
+ Op *pOp;
sqlite3_mutex_enter(p->db->mutex);
- if( !p->okVar ){
- int j;
- Op *pOp;
- for(j=0, pOp=p->aOp; j<p->nOp; j++, pOp++){
- if( pOp->opcode==OP_Variable ){
- assert( pOp->p1>0 && pOp->p1<=p->nVar );
- p->azVar[pOp->p1-1] = pOp->p4.z;
- }
+ /* The race condition here is harmless. If two threads call this
+ ** routine on the same Vdbe at the same time, they both might end
+ ** up initializing the Vdbe.azVar[] array. That is a little extra
+ ** work but it results in the same answer.
+ */
+ for(j=0, pOp=p->aOp; j<p->nOp; j++, pOp++){
+ if( pOp->opcode==OP_Variable ){
+ assert( pOp->p1>0 && pOp->p1<=p->nVar );
+ p->azVar[pOp->p1-1] = pOp->p4.z;
}
- p->okVar = 1;
}
+ p->okVar = 1;
sqlite3_mutex_leave(p->db->mutex);
}
}
/*
** Transfer all bindings from the first statement over to the second.
-** If the two statements contain a different number of bindings, then
-** an SQLITE_ERROR is returned.
*/
SQLITE_PRIVATE int sqlite3TransferBindings(sqlite3_stmt *pFromStmt, sqlite3_stmt *pToStmt){
Vdbe *pFrom = (Vdbe*)pFromStmt;
Vdbe *pTo = (Vdbe*)pToStmt;
- int i, rc = SQLITE_OK;
- if( (pFrom->magic!=VDBE_MAGIC_RUN && pFrom->magic!=VDBE_MAGIC_HALT)
- || (pTo->magic!=VDBE_MAGIC_RUN && pTo->magic!=VDBE_MAGIC_HALT)
- || pTo->db!=pFrom->db ){
- return SQLITE_MISUSE;
- }
- if( pFrom->nVar!=pTo->nVar ){
- return SQLITE_ERROR;
- }
+ int i;
+ assert( pTo->db==pFrom->db );
+ assert( pTo->nVar==pFrom->nVar );
sqlite3_mutex_enter(pTo->db->mutex);
- for(i=0;
rc==SQLITE_OK && i<pFrom->nVar; i++){
+ for(i=0; i<pFrom->nVar; i++){
sqlite3VdbeMemMove(&pTo->aVar[i], &pFrom->aVar[i]);
}
sqlite3_mutex_leave(pTo->db->mutex);
- assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
- return rc;
+ return SQLITE_OK;
}
#ifndef SQLITE_OMIT_DEPRECATED
/*
** Deprecated external interface. Internal/core SQLite code
** should call sqlite3TransferBindings.
+**
+** Is is misuse to call this routine with statements from different
+** database connections. But as this is a deprecated interface, we
+** will not bother to check for that condition.
+**
+** If the two statements contain a different number of bindings, then
+** an SQLITE_ERROR is returned. Nothing else can go wrong, so otherwise
+** SQLITE_OK is returned.
*/
SQLITE_API int sqlite3_transfer_bindings(sqlite3_stmt *pFromStmt, sqlite3_stmt *pToStmt){
+ Vdbe *pFrom = (Vdbe*)pFromStmt;
+ Vdbe *pTo = (Vdbe*)pToStmt;
+ if( pFrom->nVar!=pTo->nVar ){
+ return SQLITE_ERROR;
+ }
return sqlite3TransferBindings(pFromStmt, pToStmt);
}
#endif
#ifndef SQLITE_OMIT_PROGRESS_CALLBACK
int nProgressOps = 0; /* Opcodes executed since progress callback. */
#endif
- UnpackedRecord aTempRec[16]; /* Space to hold a transient UnpackedRecord */
+
+ /* Temporary space into which to unpack a record. */
+ char aTempRec[ROUND8(sizeof(UnpackedRecord)) + sizeof(Mem)*3 + 7];
assert( p->magic==VDBE_MAGIC_RUN ); /* sqlite3_step() verifies this */
assert( db->magic==SQLITE_MAGIC_BUSY );
- sqlite3BtreeMutexArrayEnter(&p->aMutex);
+ sqlite3VdbeMutexArrayEnter(p);
if( p->rc==SQLITE_NOMEM ){
/* This happens if a malloc() inside a call to sqlite3_column_text() or
** sqlite3_column_text16() failed. */
case OP_Count: { /* out2-prerelease */
i64 nEntry;
BtCursor *pCrsr = p->apCsr[pOp->p1]->pCursor;
- rc = sqlite3BtreeCount(pCrsr, &nEntry);
+ if( pCrsr ){
+ rc = sqlite3BtreeCount(pCrsr, &nEntry);
+ }else{
+ nEntry = 0;
+ }
pOut->flags = MEM_Int;
pOut->u.i = nEntry;
break;
BtCursor *pCrsr;
VdbeCursor *pC;
+
assert( i>=0 && i<p->nCursor );
assert( p->apCsr[i]!=0 );
if( (pCrsr = (pC = p->apCsr[i])->pCursor)!=0 ){
i64 rowid;
-
+ rc = sqlite3VdbeCursorMoveto(pC);
+ if( rc ) goto abort_due_to_error;
assert( pC->deferredMoveto==0 );
assert( pC->isTable==0 );
if( !pC->nullRow ){
/* Space to hold the rollback journal is allocated in increments of
** this many bytes.
+**
+** The size chosen is a little less than a power of two. That way,
+** the FileChunk object will have a size that almost exactly fills
+** a power-of-two allocation. This mimimizes wasted space in power-of-two
+** memory allocators.
*/
-#define JOURNAL_CHUNKSIZE 1024
+#define JOURNAL_CHUNKSIZE ((int)(1024-sizeof(FileChunk*)))
/* Macro to find the minimum of two numeric values.
*/
};
/*
-** Read data from the file.
+** Read data from the in-memory journal file. This is the implementation
+** of the sqlite3_vfs.xRead method.
*/
static int memjrnlRead(
sqlite3_file *pJfd, /* The journal file from which to read */
int iChunkOffset;
FileChunk *pChunk;
+ /* SQLite never tries to read past the end of a rollback journal file */
assert( iOfst+iAmt<=p->endpoint.iOffset );
if( p->readpoint.iOffset!=iOfst || iOfst==0 ){
sqlite3_int64 iOff = 0;
for(pChunk=p->pFirst;
- pChunk && (iOff+JOURNAL_CHUNKSIZE)<=iOfst;
+ ALWAYS(pChunk) && (iOff+JOURNAL_CHUNKSIZE)<=iOfst;
pChunk=pChunk->pNext
){
iOff += JOURNAL_CHUNKSIZE;
/*
** Sync the file.
+**
+** Syncing an in-memory journal is a no-op. And, in fact, this routine
+** is never called in a working implementation. This implementation
+** exists purely as a contingency, in case some malfunction in some other
+** part of SQLite causes Sync to be called by mistake.
*/
-static int memjrnlSync(sqlite3_file *NotUsed, int NotUsed2){
- UNUSED_PARAMETER2(NotUsed, NotUsed2);
- return SQLITE_OK;
-}
+static int memjrnlSync(sqlite3_file *NotUsed, int NotUsed2){ /*NO_TEST*/
+ UNUSED_PARAMETER2(NotUsed, NotUsed2); /*NO_TEST*/
+ assert( 0 ); /*NO_TEST*/
+ return SQLITE_OK; /*NO_TEST*/
+} /*NO_TEST*/
/*
** Query the size of the file in bytes.
*/
SQLITE_PRIVATE void sqlite3MemJournalOpen(sqlite3_file *pJfd){
MemJournal *p = (MemJournal *)pJfd;
+ assert( EIGHT_BYTE_ALIGNMENT(p) );
memset(p, 0, sqlite3MemJournalSize());
p->pMethod = &MemJournalMethods;
}
SQLITE_PRIVATE int sqlite3WalkExpr(Walker *pWalker, Expr *pExpr){
int rc;
if( pExpr==0 ) return WRC_Continue;
+ testcase( ExprHasProperty(pExpr, EP_TokenOnly) );
+ testcase( ExprHasProperty(pExpr, EP_SpanToken) );
+ testcase( ExprHasProperty(pExpr, EP_Reduced) );
rc = pWalker->xExprCallback(pWalker, pExpr);
- if( rc==WRC_Continue ){
+ if( rc==WRC_Continue
+ && !ExprHasAnyProperty(pExpr,EP_TokenOnly|EP_SpanToken) ){
if( sqlite3WalkExpr(pWalker, pExpr->pLeft) ) return WRC_Abort;
if( sqlite3WalkExpr(pWalker, pExpr->pRight) ) return WRC_Abort;
if( ExprHasProperty(pExpr, EP_xIsSelect) ){
*/
SQLITE_PRIVATE void sqlite3ExprClear(sqlite3 *db, Expr *p){
if( p->token.dyn ) sqlite3DbFree(db, (char*)p->token.z);
- if( !ExprHasAnyProperty(p, EP_TokenOnly|EP_SpanOnly) ){
+ if( !ExprHasAnyProperty(p, EP_TokenOnly|EP_SpanToken) ){
if( p->span.dyn ) sqlite3DbFree(db, (char*)p->span.z);
if( ExprHasProperty(p, EP_Reduced) ){
+ /* Subtrees are part of the same memory allocation when EP_Reduced set */
if( p->pLeft ) sqlite3ExprClear(db, p->pLeft);
if( p->pRight ) sqlite3ExprClear(db, p->pRight);
}else{
+ /* Subtrees are separate allocations when EP_Reduced is clear */
sqlite3ExprDelete(db, p->pLeft);
sqlite3ExprDelete(db, p->pRight);
}
+ /* x.pSelect and x.pList are always separately allocated */
if( ExprHasProperty(p, EP_xIsSelect) ){
sqlite3SelectDelete(db, p->x.pSelect);
}else{
*/
static int exprStructSize(Expr *p){
if( ExprHasProperty(p, EP_TokenOnly) ) return EXPR_TOKENONLYSIZE;
- if( ExprHasProperty(p, EP_SpanOnly) ) return EXPR_SPANONLYSIZE;
+ if( ExprHasProperty(p, EP_SpanToken) ) return EXPR_SPANTOKENSIZE;
if( ExprHasProperty(p, EP_Reduced) ) return EXPR_REDUCEDSIZE;
return EXPR_FULLSIZE;
}
nSize = EXPR_FULLSIZE;
}else if( p->pLeft || p->pRight || p->pColl || p->x.pList ){
nSize = EXPR_REDUCEDSIZE;
- }else if( flags&(EXPRDUP_SPAN|EXPRDUP_DISTINCTSPAN) ){
- nSize = EXPR_SPANONLYSIZE;
+ }else if( flags&EXPRDUP_SPAN ){
+ nSize = EXPR_SPANTOKENSIZE;
}else{
nSize = EXPR_TOKENONLYSIZE;
}
*/
static int dupedExprNodeSize(Expr *p, int flags){
int nByte = dupedExprStructSize(p, flags) + (p->token.z ? p->token.n + 1 : 0);
- if( (flags&EXPRDUP_DISTINCTSPAN)
- || (flags&EXPRDUP_SPAN && (p->token.z!=p->span.z || p->token.n!=p->span.n))
+ if( (flags&EXPRDUP_SPAN)!=0
+ && (p->token.z!=p->span.z || p->token.n!=p->span.n)
){
nByte += p->span.n;
}
if( p ){
nByte = dupedExprNodeSize(p, flags);
if( flags&EXPRDUP_REDUCE ){
- int f = flags&(~(EXPRDUP_SPAN|EXPRDUP_DISTINCTSPAN));
+ int f = flags&(~EXPRDUP_SPAN);
nByte += dupedExprSize(p->pLeft, f) + dupedExprSize(p->pRight, f);
}
}
static Expr *exprDup(sqlite3 *db, Expr *p, int flags, u8 **pzBuffer){
Expr *pNew = 0; /* Value to return */
if( p ){
- const int isRequireDistinctSpan = (flags&EXPRDUP_DISTINCTSPAN);
- const int isRequireSpan = (flags&(EXPRDUP_SPAN|EXPRDUP_DISTINCTSPAN));
+ const int isRequireSpan = (flags&EXPRDUP_SPAN);
const int isReduced = (flags&EXPRDUP_REDUCE);
u8 *zAlloc;
}
/* Set the EP_Reduced and EP_TokenOnly flags appropriately. */
- pNew->flags &= ~(EP_Reduced|EP_TokenOnly|EP_SpanOnly);
+ pNew->flags &= ~(EP_Reduced|EP_TokenOnly|EP_SpanToken);
switch( nNewSize ){
case EXPR_REDUCEDSIZE: pNew->flags |= EP_Reduced; break;
case EXPR_TOKENONLYSIZE: pNew->flags |= EP_TokenOnly; break;
- case EXPR_SPANONLYSIZE: pNew->flags |= EP_SpanOnly; break;
+ case EXPR_SPANTOKENSIZE: pNew->flags |= EP_SpanToken; break;
}
/* Copy the p->token string, if any. */
if( 0==((p->flags|pNew->flags) & EP_TokenOnly) ){
/* Fill in the pNew->span token, if required. */
if( isRequireSpan ){
- if( isRequireDistinctSpan
- || p->token.z!=p->span.z || p->token.n!=p->span.n
- ){
+ if( p->token.z!=p->span.z || p->token.n!=p->span.n ){
pNew->span.z = &zAlloc[nNewSize+nToken];
memcpy((char *)pNew->span.z, p->span.z, p->span.n);
pNew->span.dyn = 0;
}
}
- if( 0==((p->flags|pNew->flags) & (EP_TokenOnly|EP_SpanOnly)) ){
+ if( 0==((p->flags|pNew->flags) & (EP_TokenOnly|EP_SpanToken)) ){
/* Fill in the pNew->x.pSelect or pNew->x.pList member. */
if( ExprHasProperty(p, EP_xIsSelect) ){
pNew->x.pSelect = sqlite3SelectDup(db, p->x.pSelect, isReduced);
}
/* Fill in pNew->pLeft and pNew->pRight. */
- if( ExprHasAnyProperty(pNew, EP_Reduced|EP_TokenOnly|EP_SpanOnly) ){
+ if( ExprHasAnyProperty(pNew, EP_Reduced|EP_TokenOnly|EP_SpanToken) ){
zAlloc += dupedExprNodeSize(p, flags);
if( ExprHasProperty(pNew, EP_Reduced) ){
pNew->pLeft = exprDup(db, p->pLeft, EXPRDUP_REDUCE, &zAlloc);
if( pzBuffer ){
*pzBuffer = zAlloc;
}
- }else if( !ExprHasAnyProperty(p, EP_TokenOnly|EP_SpanOnly) ){
+ }else if( !ExprHasAnyProperty(p, EP_TokenOnly|EP_SpanToken) ){
pNew->pLeft = sqlite3ExprDup(db, p->pLeft, 0);
pNew->pRight = sqlite3ExprDup(db, p->pRight, 0);
}
*/
p = (ExprHasProperty(pX, EP_xIsSelect) ? pX->x.pSelect : 0);
if( isCandidateForInOpt(p) ){
- sqlite3 *db = pParse->db;
- Index *pIdx;
- Expr *pExpr = p->pEList->a[0].pExpr;
- int iCol = pExpr->iColumn;
- Vdbe *v = sqlite3GetVdbe(pParse);
+ sqlite3 *db = pParse->db; /* Database connection */
+ Expr *pExpr = p->pEList->a[0].pExpr; /* Expression <column> */
+ int iCol = pExpr->iColumn; /* Index of column <column> */
+ Vdbe *v = sqlite3GetVdbe(pParse); /* Virtual machine being coded */
+ Table *pTab = p->pSrc->a[0].pTab; /* Table <table>. */
+ int iDb; /* Database idx for pTab */
+
+ /* Code an OP_VerifyCookie and OP_TableLock for <table>. */
+ iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
+ sqlite3CodeVerifySchema(pParse, iDb);
+ sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
/* This function is only called from two places. In both cases the vdbe
** has already been allocated. So assume sqlite3GetVdbe() is always
if( iCol<0 ){
int iMem = ++pParse->nMem;
int iAddr;
- Table *pTab = p->pSrc->a[0].pTab;
- int iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
sqlite3VdbeUsesBtree(v, iDb);
iAddr = sqlite3VdbeAddOp1(v, OP_If, iMem);
sqlite3VdbeJumpHere(v, iAddr);
}else{
+ Index *pIdx; /* Iterator variable */
+
/* The collation sequence used by the comparison. If an index is to
** be used in place of a temp-table, it must be ordered according
- ** to this collation sequence.
- */
+ ** to this collation sequence. */
CollSeq *pReq = sqlite3BinaryCompareCollSeq(pParse, pX->pLeft, pExpr);
/* Check that the affinity that will be used to perform the
** comparison is the same as the affinity of the column. If
** it is not, it is not possible to use any index.
*/
- Table *pTab = p->pSrc->a[0].pTab;
char aff = comparisonAffinity(pX);
int affinity_ok = (pTab->aCol[iCol].affinity==aff||aff==SQLITE_AFF_NONE);
&& (pReq==sqlite3FindCollSeq(db, ENC(db), pIdx->azColl[0], -1, 0))
&& (!mustBeUnique || (pIdx->nColumn==1 && pIdx->onError!=OE_None))
){
- int iDb;
int iMem = ++pParse->nMem;
int iAddr;
char *pKey;
}
case TK_CONST_FUNC:
case TK_FUNCTION: {
- ExprList *pList = (
- ExprHasAnyProperty(pExpr, EP_TokenOnly|EP_SpanOnly) ? 0 : pExpr->x.pList
- );
- int nExpr = pList ? pList->nExpr : 0;
- FuncDef *pDef;
- int nId;
- const char *zId;
- int constMask = 0;
- int i;
- u8 enc = ENC(db);
- CollSeq *pColl = 0;
+ ExprList *pFarg; /* List of function arguments */
+ int nFarg; /* Number of function arguments */
+ FuncDef *pDef; /* The function definition object */
+ int nId; /* Length of the function name in bytes */
+ const char *zId; /* The function name */
+ int constMask = 0; /* Mask of function arguments that are constant */
+ int i; /* Loop counter */
+ u8 enc = ENC(db); /* The text encoding used by this database */
+ CollSeq *pColl = 0; /* A collating sequence */
assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
testcase( op==TK_CONST_FUNC );
testcase( op==TK_FUNCTION );
+ if( ExprHasAnyProperty(pExpr, EP_TokenOnly|EP_SpanToken) ){
+ pFarg = 0;
+ }else{
+ pFarg = pExpr->x.pList;
+ }
+ nFarg = pFarg ? pFarg->nExpr : 0;
zId = (char*)pExpr->token.z;
nId = pExpr->token.n;
- pDef = sqlite3FindFunction(db, zId, nId, nExpr, enc, 0);
+ pDef = sqlite3FindFunction(db, zId, nId, nFarg, enc, 0);
assert( pDef!=0 );
- if( pList ){
- nExpr = pList->nExpr;
- r1 = sqlite3GetTempRange(pParse, nExpr);
- sqlite3ExprCodeExprList(pParse, pList, r1, 1);
+ if( pFarg ){
+ r1 = sqlite3GetTempRange(pParse, nFarg);
+ sqlite3ExprCodeExprList(pParse, pFarg, r1, 1);
}else{
- nExpr = r1 = 0;
+ r1 = 0;
}
#ifndef SQLITE_OMIT_VIRTUALTABLE
/* Possibly overload the function if the first argument is
** "glob(B,A). We want to use the A in "A glob B" to test
** for function overloading. But we use the B term in "glob(B,A)".
*/
- if( nExpr>=2 && (pExpr->flags & EP_InfixFunc) ){
- pDef = sqlite3VtabOverloadFunction(db, pDef, nExpr, pList->a[1].pExpr);
- }else if( nExpr>0 ){
- pDef = sqlite3VtabOverloadFunction(db, pDef, nExpr, pList->a[0].pExpr);
+ if( nFarg>=2 && (pExpr->flags & EP_InfixFunc) ){
+ pDef = sqlite3VtabOverloadFunction(db, pDef, nFarg, pFarg->a[1].pExpr);
+ }else if( nFarg>0 ){
+ pDef = sqlite3VtabOverloadFunction(db, pDef, nFarg, pFarg->a[0].pExpr);
}
#endif
- for(i=0; i<nExpr && i<32; i++){
- if( sqlite3ExprIsConstant(pList->a[i].pExpr) ){
+ for(i=0; i<nFarg && i<32; i++){
+ if( sqlite3ExprIsConstant(pFarg->a[i].pExpr) ){
constMask |= (1<<i);
}
if( (pDef->flags & SQLITE_FUNC_NEEDCOLL)!=0 && !pColl ){
- pColl = sqlite3ExprCollSeq(pParse, pList->a[i].pExpr);
+ pColl = sqlite3ExprCollSeq(pParse, pFarg->a[i].pExpr);
}
}
if( pDef->flags & SQLITE_FUNC_NEEDCOLL ){
}
sqlite3VdbeAddOp4(v, OP_Function, constMask, r1, target,
(char*)pDef, P4_FUNCDEF);
- sqlite3VdbeChangeP5(v, (u8)nExpr);
- if( nExpr ){
- sqlite3ReleaseTempRange(pParse, r1, nExpr);
+ sqlite3VdbeChangeP5(v, (u8)nFarg);
+ if( nFarg ){
+ sqlite3ReleaseTempRange(pParse, r1, nFarg);
}
- sqlite3ExprCacheAffinityChange(pParse, r1, nExpr);
+ sqlite3ExprCacheAffinityChange(pParse, r1, nFarg);
break;
}
#ifndef SQLITE_OMIT_SUBQUERY
Expr *pExpr /* The expression to be fixed to one database */
){
while( pExpr ){
- if( ExprHasAnyProperty(pExpr, EP_TokenOnly|EP_SpanOnly) ) break;
+ if( ExprHasAnyProperty(pExpr, EP_TokenOnly|EP_SpanToken) ) break;
if( ExprHasProperty(pExpr, EP_xIsSelect) ){
if( sqlite3FixSelect(pFix, pExpr->x.pSelect) ) return 1;
}else{
** is required by pragma table_info.
*/
sqlite3ExprDelete(db, pCol->pDflt);
- pCol->pDflt = sqlite3ExprDup(
- db, pExpr, EXPRDUP_REDUCE|EXPRDUP_DISTINCTSPAN
- );
+ pCol->pDflt = sqlite3ExprDup(db, pExpr, EXPRDUP_REDUCE|EXPRDUP_SPAN);
}
}
sqlite3ExprDelete(db, pExpr);
/*
** Allocate nByte bytes of space using sqlite3_malloc(). If the
** allocation fails, call sqlite3_result_error_nomem() to notify
-** the database handle that malloc() has failed.
+** the database handle that malloc() has failed and return NULL.
+** If nByte is larger than the maximum string or blob length, then
+** raise an SQLITE_TOOBIG exception and return NULL.
*/
static void *contextMalloc(sqlite3_context *context, i64 nByte){
char *z;
- if( nByte>sqlite3_context_db_handle(context)->aLimit[SQLITE_LIMIT_LENGTH] ){
+ sqlite3 *db = sqlite3_context_db_handle(context);
+ assert( nByte>0 );
+ testcase( nByte==db->aLimit[SQLITE_LIMIT_LENGTH] );
+ testcase( nByte==db->aLimit[SQLITE_LIMIT_LENGTH]+1 );
+ if( nByte>db->aLimit[SQLITE_LIMIT_LENGTH] ){
sqlite3_result_error_toobig(context);
z = 0;
}else{
z = sqlite3Malloc((int)nByte);
- if( !z && nByte>0 ){
+ if( !z ){
sqlite3_result_error_nomem(context);
}
}
sqlite_int64 r;
UNUSED_PARAMETER2(NotUsed, NotUsed2);
sqlite3_randomness(sizeof(r), &r);
- if( (r<<1)==0 ) r = 0; /* Prevent 0x8000.... as the result so that we */
- /* can always do abs() of the result */
+ if( r<0 ){
+ /* We need to prevent a random number of 0x8000000000000000
+ ** (or -9223372036854775808) since when you do abs() of that
+ ** number of you get the same value back again. To do this
+ ** in a way that is testable, mask the sign bit off of negative
+ ** values, resulting in a positive value. Then take the
+ ** 2s complement of that positive value. The end result can
+ ** therefore be no less than -9223372036854775807.
+ */
+ r = -(r ^ (((sqlite3_int64)1)<<63));
+ }
sqlite3_result_int64(context, r);
}
** whereas only characters less than 0x80 do in ASCII.
*/
#if defined(SQLITE_EBCDIC)
-# define sqlite3Utf8Read(A,B,C) (*(A++))
+# define sqlite3Utf8Read(A,C) (*(A++))
# define GlogUpperToLower(A) A = sqlite3UpperToLower[A]
#else
# define GlogUpperToLower(A) if( A<0x80 ){ A = sqlite3UpperToLower[A]; }
u8 noCase = pInfo->noCase;
int prevEscape = 0; /* True if the previous character was 'escape' */
- while( (c = sqlite3Utf8Read(zPattern,0,&zPattern))!=0 ){
+ while( (c = sqlite3Utf8Read(zPattern,&zPattern))!=0 ){
if( !prevEscape && c==matchAll ){
- while( (c=sqlite3Utf8Read(zPattern,0,&zPattern)) == matchAll
+ while( (c=sqlite3Utf8Read(zPattern,&zPattern)) == matchAll
|| c == matchOne ){
- if( c==matchOne && sqlite3Utf8Read(zString, 0, &zString)==0 ){
+ if( c==matchOne && sqlite3Utf8Read(zString, &zString)==0 ){
return 0;
}
}
if( c==0 ){
return 1;
}else if( c==esc ){
- c = sqlite3Utf8Read(zPattern, 0, &zPattern);
+ c = sqlite3Utf8Read(zPattern, &zPattern);
if( c==0 ){
return 0;
}
}
return *zString!=0;
}
- while( (c2 = sqlite3Utf8Read(zString,0,&zString))!=0 ){
+ while( (c2 = sqlite3Utf8Read(zString,&zString))!=0 ){
if( noCase ){
GlogUpperToLower(c2);
GlogUpperToLower(c);
while( c2 != 0 && c2 != c ){
- c2 = sqlite3Utf8Read(zString, 0, &zString);
+ c2 = sqlite3Utf8Read(zString, &zString);
GlogUpperToLower(c2);
}
}else{
while( c2 != 0 && c2 != c ){
- c2 = sqlite3Utf8Read(zString, 0, &zString);
+ c2 = sqlite3Utf8Read(zString, &zString);
}
}
if( c2==0 ) return 0;
}
return 0;
}else if( !prevEscape && c==matchOne ){
- if( sqlite3Utf8Read(zString, 0, &zString)==0 ){
+ if( sqlite3Utf8Read(zString, &zString)==0 ){
return 0;
}
}else if( c==matchSet ){
assert( esc==0 ); /* This only occurs for GLOB, not LIKE */
seen = 0;
invert = 0;
- c = sqlite3Utf8Read(zString, 0, &zString);
+ c = sqlite3Utf8Read(zString, &zString);
if( c==0 ) return 0;
- c2 = sqlite3Utf8Read(zPattern, 0, &zPattern);
+ c2 = sqlite3Utf8Read(zPattern, &zPattern);
if( c2=='^' ){
invert = 1;
- c2 = sqlite3Utf8Read(zPattern, 0, &zPattern);
+ c2 = sqlite3Utf8Read(zPattern, &zPattern);
}
if( c2==']' ){
if( c==']' ) seen = 1;
- c2 = sqlite3Utf8Read(zPattern, 0, &zPattern);
+ c2 = sqlite3Utf8Read(zPattern, &zPattern);
}
while( c2 && c2!=']' ){
if( c2=='-' && zPattern[0]!=']' && zPattern[0]!=0 && prior_c>0 ){
- c2 = sqlite3Utf8Read(zPattern, 0, &zPattern);
+ c2 = sqlite3Utf8Read(zPattern, &zPattern);
if( c>=prior_c && c<=c2 ) seen = 1;
prior_c = 0;
}else{
}
prior_c = c2;
}
- c2 = sqlite3Utf8Read(zPattern, 0, &zPattern);
+ c2 = sqlite3Utf8Read(zPattern, &zPattern);
}
if( c2==0 || (seen ^ invert)==0 ){
return 0;
}else if( esc==c && !prevEscape ){
prevEscape = 1;
}else{
- c2 = sqlite3Utf8Read(zString, 0, &zString);
+ c2 = sqlite3Utf8Read(zString, &zString);
if( noCase ){
GlogUpperToLower(c);
GlogUpperToLower(c2);
){
const unsigned char *zA, *zB;
int escape = 0;
+ int nPat;
sqlite3 *db = sqlite3_context_db_handle(context);
zB = sqlite3_value_text(argv[0]);
/* Limit the length of the LIKE or GLOB pattern to avoid problems
** of deep recursion and N*N behavior in patternCompare().
*/
- if( sqlite3_value_bytes(argv[0]) >
- db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH] ){
+ nPat = sqlite3_value_bytes(argv[0]);
+ testcase( nPat==db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH] );
+ testcase( nPat==db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH]+1 );
+ if( nPat > db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH] ){
sqlite3_result_error(context, "LIKE or GLOB pattern too complex", -1);
return;
}
"ESCAPE expression must be a single character", -1);
return;
}
- escape = sqlite3Utf8Read(zEsc, 0, &zEsc);
+ escape = sqlite3Utf8Read(zEsc, &zEsc);
}
if( zA && zB ){
struct compareInfo *pInfo = sqlite3_user_data(context);
sqlite3_value **argv
){
i64 n;
+ sqlite3 *db = sqlite3_context_db_handle(context);
assert( argc==1 );
UNUSED_PARAMETER(argc);
n = sqlite3_value_int64(argv[0]);
- if( n>SQLITE_MAX_LENGTH ){
+ testcase( n==db->aLimit[SQLITE_LIMIT_LENGTH] );
+ testcase( n==db->aLimit[SQLITE_LIMIT_LENGTH]+1 );
+ if( n>db->aLimit[SQLITE_LIMIT_LENGTH] ){
sqlite3_result_error_toobig(context);
}else{
sqlite3_result_zeroblob(context, (int)n);
u8 *zOld;
sqlite3 *db = sqlite3_context_db_handle(context);
nOut += nRep - nPattern;
- if( nOut>=db->aLimit[SQLITE_LIMIT_LENGTH] ){
+ testcase( nOut-1==db->aLimit[SQLITE_LIMIT_LENGTH] );
+ testcase( nOut-2==db->aLimit[SQLITE_LIMIT_LENGTH] );
+ if( nOut-1>db->aLimit[SQLITE_LIMIT_LENGTH] ){
sqlite3_result_error_toobig(context);
sqlite3DbFree(db, zOut);
return;
int len = 0;
for(i=0; i<nChar; i++){
len = aLen[i];
- if( memcmp(zIn, azChar[i], len)==0 ) break;
+ if( len<=nIn && memcmp(zIn, azChar[i], len)==0 ) break;
}
if( i>=nChar ) break;
zIn += len;
if( (argc==0 || SQLITE_NULL!=sqlite3_value_type(argv[0])) && p ){
p->n++;
}
+
+ /* The sqlite3_aggregate_count() function is deprecated. But just to make
+ ** sure it still operates correctly, verify that its count agrees with our
+ ** internal count when using count(*) and when the total count can be
+ ** expressed as a 32-bit integer. */
+ assert( argc==1 || p==0 || p->n>0x7fffffff
+ || p->n==sqlite3_aggregate_count(context) );
}
static void countFinalize(sqlite3_context *context){
CountCtx *p;
sqlite3_value *pRes;
pRes = (sqlite3_value *)sqlite3_aggregate_context(context, 0);
if( pRes ){
- if( pRes->flags ){
+ if( ALWAYS(pRes->flags) ){
sqlite3_result_value(context, pRes);
}
sqlite3VdbeMemRelease(pRes);
FuncDef *pDef;
pDef = sqlite3FindFunction(db, zName, sqlite3Strlen30(zName),
2, SQLITE_UTF8, 0);
- if( pDef ){
+ if( ALWAYS(pDef) ){
pDef->flags = flagVal;
}
}
assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
pDef = sqlite3FindFunction(db, (char*)pExpr->token.z, pExpr->token.n, 2,
SQLITE_UTF8, 0);
- if( pDef==0 || (pDef->flags & SQLITE_FUNC_LIKE)==0 ){
+ if( NEVER(pDef==0) || (pDef->flags & SQLITE_FUNC_LIKE)==0 ){
return 0;
}
/*
** Generate code to return a single integer value.
*/
-static void returnSingleInt(Parse *pParse, const char *zLabel, int value){
+static void returnSingleInt(Parse *pParse, const char *zLabel, i64 value){
Vdbe *v = sqlite3GetVdbe(pParse);
int mem = ++pParse->nMem;
- sqlite3VdbeAddOp2(v, OP_Integer, value, mem);
- if( pParse->explain==0 ){
- sqlite3VdbeSetNumCols(v, 1);
- sqlite3VdbeSetColName(v, 0, COLNAME_NAME, zLabel, SQLITE_STATIC);
+ i64 *pI64 = sqlite3DbMallocRaw(pParse->db, sizeof(value));
+ if( pI64 ){
+ memcpy(pI64, &value, sizeof(value));
}
+ sqlite3VdbeAddOp4(v, OP_Int64, 0, mem, 0, (char*)pI64, P4_INT64);
+ sqlite3VdbeSetNumCols(v, 1);
+ sqlite3VdbeSetColName(v, 0, COLNAME_NAME, zLabel, SQLITE_STATIC);
sqlite3VdbeAddOp2(v, OP_ResultRow, mem, 1);
}
** buffer that the pager module resizes using sqlite3_realloc().
*/
db->nextPagesize = atoi(zRight);
- if( SQLITE_NOMEM==sqlite3BtreeSetPageSize(pBt, db->nextPagesize, -1) ){
+ if( SQLITE_NOMEM==sqlite3BtreeSetPageSize(pBt, db->nextPagesize, -1, 0) ){
db->mallocFailed = 1;
}
}
Pager *pPager = sqlite3BtreePager(pDb->pBt);
i64 iLimit = -2;
if( zRight ){
- int iLimit32 = atoi(zRight);
- if( iLimit32<-1 ){
- iLimit32 = -1;
- }
- iLimit = iLimit32;
+ sqlite3Atoi64(zRight, &iLimit);
+ if( iLimit<-1 ) iLimit = -1;
}
iLimit = sqlite3PagerJournalSizeLimit(pPager, iLimit);
- returnSingleInt(pParse, "journal_size_limit", (int)iLimit);
+ returnSingleInt(pParse, "journal_size_limit", iLimit);
}else
#endif /* SQLITE_OMIT_PAGER_PRAGMAS */
cnt++;
}
}
- if( cnt==0 ) continue;
/* Make sure sufficient number of registers have been allocated */
if( pParse->nMem < cnt+4 ){
{ OP_Concat, 3, 2, 2},
{ OP_ResultRow, 2, 1, 0},
};
- if( pIdx->tnum==0 ) continue;
addr = sqlite3VdbeAddOp1(v, OP_IfPos, 1);
sqlite3VdbeAddOp2(v, OP_Halt, 0, 0);
sqlite3VdbeJumpHere(v, addr);
int rc = SQLITE_OK;
int i;
- assert( ppStmt );
- *ppStmt = 0;
- if( sqlite3SafetyOn(db) ){
- return SQLITE_MISUSE;
- }
+ if( sqlite3SafetyOn(db) ) return SQLITE_MISUSE;
+ assert( ppStmt && *ppStmt==0 );
assert( !db->mallocFailed );
assert( sqlite3_mutex_held(db->mutex) );
const char **pzTail /* OUT: End of parsed string */
){
int rc;
+ assert( ppStmt!=0 );
+ *ppStmt = 0;
if( !sqlite3SafetyCheckOk(db) ){
return SQLITE_MISUSE;
}
const char *zTail8 = 0;
int rc = SQLITE_OK;
+ assert( ppStmt );
+ *ppStmt = 0;
if( !sqlite3SafetyCheckOk(db) ){
return SQLITE_MISUSE;
}
** (19) The subquery does not use LIMIT or the outer query does not
** have a WHERE clause.
**
+** (20) If the sub-query is a compound select, then it must not use
+** an ORDER BY clause. Ticket #3773. We could relax this constraint
+** somewhat by saying that the terms of the ORDER BY clause must
+** appear as unmodified result columns in the outer query. But
+** have other optimizations in mind to deal with that case.
+**
** In this routine, the "p" parameter is a pointer to the outer query.
** The subquery is p->pSrc->a[iFrom]. isAgg is true if the outer query
** uses aggregates and subqueryIsAgg is true if the subquery uses aggregates.
** queries.
*/
if( pSub->pPrior ){
+ if( pSub->pOrderBy ){
+ return 0; /* Restriction 20 */
+ }
if( isAgg || (p->selFlags & SF_Distinct)!=0 || pSrc->nSrc!=1 ){
return 0;
}
** to the callback function is uses to build the result.
*/
typedef struct TabResult {
- char **azResult;
- char *zErrMsg;
- int nResult;
- int nAlloc;
- int nRow;
- int nColumn;
- int nData;
- int rc;
+ char **azResult; /* Accumulated output */
+ char *zErrMsg; /* Error message text, if an error occurs */
+ int nAlloc; /* Slots allocated for azResult[] */
+ int nRow; /* Number of rows in the result */
+ int nColumn; /* Number of columns in the result */
+ int nData; /* Slots used in azResult[]. (nRow+1)*nColumn */
+ int rc; /* Return code from sqlite3_exec() */
} TabResult;
/*
** memory as necessary.
*/
static int sqlite3_get_table_cb(void *pArg, int nCol, char **argv, char **colv){
- TabResult *p = (TabResult*)pArg;
- int need;
- int i;
- char *z;
+ TabResult *p = (TabResult*)pArg; /* Result accumulator */
+ int need; /* Slots needed in p->azResult[] */
+ int i; /* Loop counter */
+ char *z; /* A single column of result */
/* Make sure there is enough space in p->azResult to hold everything
** we need to remember from this invocation of the callback.
}else{
need = nCol;
}
- if( p->nData + need >= p->nAlloc ){
+ if( p->nData + need > p->nAlloc ){
char **azNew;
- p->nAlloc = p->nAlloc*2 + need + 1;
+ p->nAlloc = p->nAlloc*2 + need;
azNew = sqlite3_realloc( p->azResult, sizeof(char*)*p->nAlloc );
if( azNew==0 ) goto malloc_failed;
p->azResult = azNew;
if( pnRow ) *pnRow = 0;
if( pzErrMsg ) *pzErrMsg = 0;
res.zErrMsg = 0;
- res.nResult = 0;
res.nRow = 0;
res.nColumn = 0;
res.nData = 1;
}
if( res.nAlloc>res.nData ){
char **azNew;
- azNew = sqlite3_realloc( res.azResult, sizeof(char*)*(res.nData+1) );
+ azNew = sqlite3_realloc( res.azResult, sizeof(char*)*res.nData );
if( azNew==0 ){
sqlite3_free_table(&res.azResult[1]);
db->errCode = SQLITE_NOMEM;
return SQLITE_NOMEM;
}
- res.nAlloc = res.nData+1;
res.azResult = azNew;
}
*pazResult = &res.azResult[1];
}
#endif
- if( sqlite3BtreeSetPageSize(pTemp, sqlite3BtreeGetPageSize(pMain), nRes)
- || (!isMemDb && sqlite3BtreeSetPageSize(pTemp, db->nextPagesize, nRes))
+ if( sqlite3BtreeSetPageSize(pTemp, sqlite3BtreeGetPageSize(pMain), nRes, 0)
+ || (!isMemDb && sqlite3BtreeSetPageSize(pTemp, db->nextPagesize, nRes, 0))
|| db->mallocFailed
){
rc = SQLITE_NOMEM;
}
if( rc==SQLITE_OK ){
- rc = sqlite3BtreeSetPageSize(pMain, sqlite3BtreeGetPageSize(pTemp), nRes);
+ rc = sqlite3BtreeSetPageSize(pMain, sqlite3BtreeGetPageSize(pTemp), nRes,1);
}
end_of_vacuum:
*/
#ifndef SQLITE_OMIT_VIRTUALTABLE
+/*
+** The actual function that does the work of creating a new module.
+** This function implements the sqlite3_create_module() and
+** sqlite3_create_module_v2() interfaces.
+*/
static int createModule(
sqlite3 *db, /* Database in which module is registered */
const char *zName, /* Name assigned to this module */
** disconnect the virtual table.
*/
SQLITE_PRIVATE void sqlite3VtabUnlock(sqlite3 *db, sqlite3_vtab *pVtab){
+ assert( pVtab->nRef>0 );
pVtab->nRef--;
assert(db);
assert( sqlite3SafetyCheckOk(db) );
#if defined(SQLITE_TEST) || defined(SQLITE_DEBUG)
SQLITE_PRIVATE int sqlite3WhereTrace = 0;
#endif
-#if 0
+#if defined(SQLITE_TEST) && defined(SQLITE_DEBUG)
# define WHERETRACE(X) if(sqlite3WhereTrace) sqlite3DebugPrintf X
#else
# define WHERETRACE(X)
if( pProbe==0 &&
findTerm(pWC, iCur, -1, 0, WO_EQ|WO_IN|WO_LT|WO_LE|WO_GT|WO_GE,0)==0 &&
(pOrderBy==0 || !sortableByRowid(iCur, pOrderBy, pWC->pMaskSet, &rev)) ){
+ if( pParse->db->flags & SQLITE_ReverseOrder ){
+ /* For application testing, randomly reverse the output order for
+ ** SELECT statements that omit the ORDER BY clause. This will help
+ ** to find cases where
+ */
+ pCost->plan.wsFlags |= WHERE_REVERSE;
+ }
return;
}
pCost->rCost = SQLITE_BIG_DBL;
#define sqlite3ParserARG_PDECL ,Parse *pParse
#define sqlite3ParserARG_FETCH Parse *pParse = yypParser->pParse
#define sqlite3ParserARG_STORE yypParser->pParse = pParse
-#define YYNSTATE 613
-#define YYNRULE 321
+#define YYNSTATE 616
+#define YYNRULE 323
#define YYFALLBACK 1
#define YY_NO_ACTION (YYNSTATE+YYNRULE+2)
#define YY_ACCEPT_ACTION (YYNSTATE+YYNRULE+1)
** yy_default[] Default action for each state.
*/
static const YYACTIONTYPE yy_action[] = {
- /* 0 */ 304, 935, 176, 612, 2, 150, 214, 438, 24, 24,
- /* 10 */ 24, 24, 487, 26, 26, 26, 26, 27, 27, 28,
- /* 20 */ 28, 28, 29, 216, 412, 413, 212, 412, 413, 445,
- /* 30 */ 451, 31, 26, 26, 26, 26, 27, 27, 28, 28,
- /* 40 */ 28, 29, 216, 30, 482, 32, 134, 23, 22, 308,
- /* 50 */ 455, 456, 452, 452, 25, 25, 24, 24, 24, 24,
- /* 60 */ 435, 26, 26, 26, 26, 27, 27, 28, 28, 28,
- /* 70 */ 29, 216, 304, 216, 311, 438, 511, 489, 45, 26,
+ /* 0 */ 304, 940, 176, 615, 2, 150, 214, 439, 24, 24,
+ /* 10 */ 24, 24, 488, 26, 26, 26, 26, 27, 27, 28,
+ /* 20 */ 28, 28, 29, 216, 413, 414, 212, 413, 414, 446,
+ /* 30 */ 452, 31, 26, 26, 26, 26, 27, 27, 28, 28,
+ /* 40 */ 28, 29, 216, 30, 483, 32, 134, 23, 22, 308,
+ /* 50 */ 456, 457, 453, 453, 25, 25, 24, 24, 24, 24,
+ /* 60 */ 436, 26, 26, 26, 26, 27, 27, 28, 28, 28,
+ /* 70 */ 29, 216, 304, 216, 311, 439, 512, 490, 45, 26,
/* 80 */ 26, 26, 26, 27, 27, 28, 28, 28, 29, 216,
- /* 90 */ 412, 413, 415, 416, 156, 415, 416, 360, 363, 364,
- /* 100 */ 311, 445, 451, 385, 513, 21, 186, 494, 365, 27,
- /* 110 */ 27, 28, 28, 28, 29, 216, 412, 413, 414, 23,
- /* 120 */ 22, 308, 455, 456, 452, 452, 25, 25, 24, 24,
- /* 130 */ 24, 24, 554, 26, 26, 26, 26, 27, 27, 28,
- /* 140 */ 28, 28, 29, 216, 304, 228, 503, 135, 467, 218,
- /* 150 */ 438, 145, 132, 256, 358, 261, 359, 153, 415, 416,
- /* 160 */ 553, 528, 331, 30, 265, 32, 134, 552, 592, 593,
- /* 170 */ 230, 228, 489, 445, 451, 57, 505, 328, 132, 256,
- /* 180 */ 358, 261, 359, 153, 415, 416, 434, 78, 407, 404,
- /* 190 */ 265, 23, 22, 308, 455, 456, 452, 452, 25, 25,
- /* 200 */ 24, 24, 24, 24, 476, 26, 26, 26, 26, 27,
- /* 210 */ 27, 28, 28, 28, 29, 216, 304, 572, 438, 546,
- /* 220 */ 477, 127, 547, 596, 30, 331, 32, 134, 345, 214,
- /* 230 */ 428, 63, 331, 355, 414, 478, 241, 341, 414, 342,
- /* 240 */ 328, 387, 193, 595, 594, 445, 451, 328, 299, 434,
- /* 250 */ 85, 469, 545, 200, 190, 555, 434, 78, 309, 462,
- /* 260 */ 463, 571, 471, 23, 22, 308, 455, 456, 452, 452,
- /* 270 */ 25, 25, 24, 24, 24, 24, 435, 26, 26, 26,
+ /* 90 */ 413, 414, 416, 417, 156, 416, 417, 360, 363, 364,
+ /* 100 */ 311, 446, 452, 385, 514, 21, 186, 495, 365, 27,
+ /* 110 */ 27, 28, 28, 28, 29, 216, 413, 414, 415, 23,
+ /* 120 */ 22, 308, 456, 457, 453, 453, 25, 25, 24, 24,
+ /* 130 */ 24, 24, 555, 26, 26, 26, 26, 27, 27, 28,
+ /* 140 */ 28, 28, 29, 216, 304, 228, 504, 135, 468, 218,
+ /* 150 */ 548, 145, 132, 256, 358, 261, 359, 153, 416, 417,
+ /* 160 */ 241, 598, 331, 30, 265, 32, 134, 439, 596, 597,
+ /* 170 */ 230, 228, 490, 446, 452, 57, 506, 328, 132, 256,
+ /* 180 */ 358, 261, 359, 153, 416, 417, 435, 78, 408, 405,
+ /* 190 */ 265, 23, 22, 308, 456, 457, 453, 453, 25, 25,
+ /* 200 */ 24, 24, 24, 24, 342, 26, 26, 26, 26, 27,
+ /* 210 */ 27, 28, 28, 28, 29, 216, 304, 214, 534, 547,
+ /* 220 */ 307, 127, 489, 595, 30, 331, 32, 134, 345, 387,
+ /* 230 */ 429, 63, 331, 355, 415, 439, 507, 331, 415, 535,
+ /* 240 */ 328, 215, 193, 594, 593, 446, 452, 328, 18, 435,
+ /* 250 */ 85, 16, 328, 183, 190, 556, 435, 78, 309, 463,
+ /* 260 */ 464, 435, 85, 23, 22, 308, 456, 457, 453, 453,
+ /* 270 */ 25, 25, 24, 24, 24, 24, 436, 26, 26, 26,
/* 280 */ 26, 27, 27, 28, 28, 28, 29, 216, 304, 347,
- /* 290 */ 221, 191, 512, 429, 544, 331, 440, 234, 345, 430,
- /* 300 */ 324, 409, 541, 344, 591, 217, 213, 541, 112, 331,
- /* 310 */ 328, 388, 282, 281, 211, 29, 216, 445, 451, 434,
- /* 320 */ 79, 217, 214, 334, 328, 458, 458, 442, 442, 442,
- /* 330 */ 571, 270, 4, 434, 85, 23, 22, 308, 455, 456,
- /* 340 */ 452, 452, 25, 25, 24, 24, 24, 24, 435, 26,
+ /* 290 */ 221, 313, 595, 191, 378, 331, 472, 234, 345, 381,
+ /* 300 */ 324, 410, 220, 344, 592, 217, 213, 415, 112, 331,
+ /* 310 */ 328, 4, 594, 399, 211, 554, 529, 446, 452, 435,
+ /* 320 */ 79, 217, 553, 515, 328, 334, 513, 459, 459, 469,
+ /* 330 */ 441, 572, 432, 435, 78, 23, 22, 308, 456, 457,
+ /* 340 */ 453, 453, 25, 25, 24, 24, 24, 24, 436, 26,
/* 350 */ 26, 26, 26, 27, 27, 28, 28, 28, 29, 216,
- /* 360 */ 304, 514, 156, 331, 488, 360, 363, 364, 331, 353,
- /* 370 */ 431, 247, 395, 274, 220, 272, 365, 352, 328, 331,
- /* 380 */ 388, 282, 281, 328, 412, 413, 307, 434, 93, 445,
- /* 390 */ 451, 214, 434, 93, 328, 530, 150, 1, 438, 403,
- /* 400 */ 468, 412, 413, 434, 78, 40, 210, 23, 22, 308,
- /* 410 */ 455, 456, 452, 452, 25, 25, 24, 24, 24, 24,
- /* 420 */ 194, 26, 26, 26, 26, 27, 27, 28, 28, 28,
- /* 430 */ 29, 216, 304, 319, 331, 596, 507, 535, 320, 179,
- /* 440 */ 435, 489, 467, 156, 192, 349, 360, 363, 364, 328,
- /* 450 */ 414, 536, 415, 416, 435, 595, 546, 365, 434, 71,
- /* 460 */ 378, 445, 451, 208, 240, 381, 438, 556, 63, 415,
- /* 470 */ 416, 414, 28, 28, 28, 29, 216, 43, 435, 23,
- /* 480 */ 22, 308, 455, 456, 452, 452, 25, 25, 24, 24,
- /* 490 */ 24, 24, 276, 26, 26, 26, 26, 27, 27, 28,
- /* 500 */ 28, 28, 29, 216, 304, 354, 209, 414, 510, 412,
- /* 510 */ 413, 135, 426, 331, 412, 413, 398, 217, 66, 333,
- /* 520 */ 328, 564, 412, 413, 30, 563, 32, 134, 328, 434,
- /* 530 */ 8, 546, 484, 445, 451, 400, 489, 434, 72, 377,
- /* 540 */ 435, 485, 603, 63, 598, 494, 414, 372, 469, 337,
- /* 550 */ 200, 23, 22, 308, 455, 456, 452, 452, 25, 25,
+ /* 360 */ 304, 443, 443, 443, 156, 468, 218, 360, 363, 364,
+ /* 370 */ 331, 247, 395, 398, 217, 349, 331, 30, 365, 32,
+ /* 380 */ 134, 388, 282, 281, 39, 328, 41, 430, 545, 446,
+ /* 390 */ 452, 328, 214, 531, 435, 93, 542, 601, 1, 404,
+ /* 400 */ 435, 93, 413, 414, 495, 40, 536, 23, 22, 308,
+ /* 410 */ 456, 457, 453, 453, 25, 25, 24, 24, 24, 24,
+ /* 420 */ 573, 26, 26, 26, 26, 27, 27, 28, 28, 28,
+ /* 430 */ 29, 216, 304, 276, 331, 179, 508, 490, 210, 547,
+ /* 440 */ 319, 413, 414, 222, 192, 385, 320, 240, 415, 328,
+ /* 450 */ 557, 63, 413, 414, 415, 616, 408, 405, 435, 71,
+ /* 460 */ 415, 446, 452, 611, 572, 28, 28, 28, 29, 216,
+ /* 470 */ 416, 417, 436, 336, 463, 464, 401, 43, 436, 23,
+ /* 480 */ 22, 308, 456, 457, 453, 453, 25, 25, 24, 24,
+ /* 490 */ 24, 24, 495, 26, 26, 26, 26, 27, 27, 28,
+ /* 500 */ 28, 28, 29, 216, 304, 612, 209, 135, 511, 416,
+ /* 510 */ 417, 431, 233, 64, 388, 282, 281, 439, 66, 542,
+ /* 520 */ 416, 417, 413, 414, 156, 214, 403, 360, 363, 364,
+ /* 530 */ 547, 252, 490, 446, 452, 491, 217, 8, 365, 495,
+ /* 540 */ 436, 606, 63, 537, 299, 415, 492, 470, 546, 200,
+ /* 550 */ 196, 23, 22, 308, 456, 457, 453, 453, 25, 25,
/* 560 */ 24, 24, 24, 24, 386, 26, 26, 26, 26, 27,
- /* 570 */ 27, 28, 28, 28, 29, 216, 304, 415, 416, 476,
- /* 580 */ 527, 60, 415, 416, 222, 402, 389, 498, 185, 331,
- /* 590 */ 415, 416, 385, 242, 331, 477, 331, 506, 453, 336,
- /* 600 */ 462, 463, 414, 490, 328, 445, 451, 414, 491, 328,
- /* 610 */ 478, 328, 518, 434, 67, 613, 407, 404, 434, 76,
- /* 620 */ 434, 97, 519, 23, 22, 308, 455, 456, 452, 452,
+ /* 570 */ 27, 28, 28, 28, 29, 216, 304, 477, 254, 354,
+ /* 580 */ 528, 60, 517, 518, 436, 439, 389, 331, 356, 7,
+ /* 590 */ 416, 417, 331, 478, 328, 208, 197, 137, 460, 499,
+ /* 600 */ 447, 448, 328, 435, 9, 446, 452, 328, 479, 485,
+ /* 610 */ 519, 435, 72, 567, 415, 434, 435, 67, 486, 433,
+ /* 620 */ 520, 450, 451, 23, 22, 308, 456, 457, 453, 453,
/* 630 */ 25, 25, 24, 24, 24, 24, 331, 26, 26, 26,
/* 640 */ 26, 27, 27, 28, 28, 28, 29, 216, 304, 331,
- /* 650 */ 310, 328, 268, 368, 64, 331, 397, 439, 438, 233,
- /* 660 */ 434, 96, 217, 16, 328, 183, 331, 459, 467, 218,
- /* 670 */ 328, 446, 447, 434, 101, 214, 154, 445, 451, 434,
- /* 680 */ 99, 328, 464, 154, 566, 466, 334, 396, 458, 458,
- /* 690 */ 434, 104, 449, 450, 205, 23, 22, 308, 455, 456,
- /* 700 */ 452, 452, 25, 25, 24, 24, 24, 24, 331, 26,
+ /* 650 */ 449, 328, 268, 390, 461, 331, 65, 331, 368, 434,
+ /* 660 */ 435, 76, 310, 433, 328, 150, 427, 439, 473, 331,
+ /* 670 */ 328, 499, 328, 435, 97, 29, 216, 446, 452, 435,
+ /* 680 */ 96, 435, 101, 353, 328, 372, 415, 334, 154, 459,
+ /* 690 */ 459, 352, 569, 435, 99, 23, 22, 308, 456, 457,
+ /* 700 */ 453, 453, 25, 25, 24, 24, 24, 24, 331, 26,
/* 710 */ 26, 26, 26, 27, 27, 28, 28, 28, 29, 216,
- /* 720 */ 304, 448, 331, 328, 390, 56, 438, 331, 435, 331,
- /* 730 */ 248, 306, 434, 105, 516, 517, 472, 328, 306, 39,
- /* 740 */ 331, 41, 328, 265, 328, 414, 434, 126, 339, 445,
- /* 750 */ 451, 434, 128, 434, 59, 328, 334, 250, 458, 458,
- /* 760 */ 196, 569, 517, 568, 434, 102, 483, 23, 22, 308,
- /* 770 */ 455, 456, 452, 452, 25, 25, 24, 24, 24, 24,
+ /* 720 */ 304, 331, 248, 328, 264, 56, 334, 331, 459, 459,
+ /* 730 */ 861, 333, 435, 104, 376, 439, 328, 415, 331, 415,
+ /* 740 */ 565, 331, 328, 306, 564, 435, 105, 185, 265, 446,
+ /* 750 */ 452, 435, 126, 328, 570, 518, 328, 334, 377, 459,
+ /* 760 */ 459, 314, 435, 128, 194, 435, 59, 23, 22, 308,
+ /* 770 */ 456, 457, 453, 453, 25, 25, 24, 24, 24, 24,
/* 780 */ 331, 26, 26, 26, 26, 27, 27, 28, 28, 28,
- /* 790 */ 29, 216, 304, 331, 435, 328, 562, 375, 562, 331,
- /* 800 */ 264, 858, 606, 303, 434, 77, 197, 137, 328, 406,
- /* 810 */ 2, 331, 178, 215, 328, 414, 486, 434, 100, 136,
- /* 820 */ 18, 445, 451, 434, 68, 334, 328, 458, 458, 610,
- /* 830 */ 926, 460, 926, 65, 414, 434, 98, 314, 528, 23,
- /* 840 */ 22, 308, 455, 456, 452, 452, 25, 25, 24, 24,
+ /* 790 */ 29, 216, 304, 331, 136, 328, 242, 477, 436, 331,
+ /* 800 */ 350, 331, 609, 303, 435, 102, 201, 137, 328, 415,
+ /* 810 */ 454, 178, 331, 478, 328, 415, 328, 435, 77, 440,
+ /* 820 */ 249, 446, 452, 435, 100, 435, 68, 328, 479, 465,
+ /* 830 */ 341, 613, 931, 484, 931, 415, 435, 98, 467, 23,
+ /* 840 */ 22, 308, 456, 457, 453, 453, 25, 25, 24, 24,
/* 850 */ 24, 24, 331, 26, 26, 26, 26, 27, 27, 28,
- /* 860 */ 28, 28, 29, 216, 304, 331, 350, 328, 264, 155,
- /* 870 */ 264, 331, 607, 331, 201, 137, 434, 129, 433, 574,
- /* 880 */ 328, 414, 432, 414, 331, 414, 328, 498, 328, 434,
- /* 890 */ 130, 498, 539, 445, 451, 434, 131, 434, 69, 328,
- /* 900 */ 362, 334, 414, 458, 458, 229, 414, 315, 434, 80,
- /* 910 */ 259, 23, 33, 308, 455, 456, 452, 452, 25, 25,
+ /* 860 */ 28, 28, 29, 216, 304, 331, 397, 328, 164, 264,
+ /* 870 */ 205, 331, 264, 332, 610, 339, 435, 129, 407, 2,
+ /* 880 */ 328, 322, 175, 331, 415, 214, 328, 415, 415, 435,
+ /* 890 */ 130, 466, 466, 446, 452, 435, 131, 396, 328, 257,
+ /* 900 */ 334, 487, 459, 459, 436, 154, 229, 435, 69, 315,
+ /* 910 */ 258, 23, 33, 308, 456, 457, 453, 453, 25, 25,
/* 920 */ 24, 24, 24, 24, 331, 26, 26, 26, 26, 27,
- /* 930 */ 27, 28, 28, 28, 29, 216, 304, 331, 264, 328,
- /* 940 */ 164, 264, 356, 331, 417, 418, 419, 525, 434, 81,
- /* 950 */ 376, 542, 328, 414, 318, 331, 414, 538, 328, 465,
- /* 960 */ 465, 434, 70, 322, 175, 445, 451, 434, 82, 433,
- /* 970 */ 328, 610, 925, 432, 925, 316, 540, 494, 317, 434,
- /* 980 */ 83, 522, 523, 587, 22, 308, 455, 456, 452, 452,
+ /* 930 */ 27, 28, 28, 28, 29, 216, 304, 331, 497, 328,
+ /* 940 */ 151, 264, 412, 331, 264, 470, 337, 200, 435, 80,
+ /* 950 */ 250, 155, 328, 523, 524, 331, 415, 415, 328, 415,
+ /* 960 */ 306, 435, 81, 533, 532, 446, 452, 435, 70, 47,
+ /* 970 */ 328, 613, 930, 259, 930, 418, 419, 420, 316, 435,
+ /* 980 */ 82, 317, 206, 539, 22, 308, 456, 457, 453, 453,
/* 990 */ 25, 25, 24, 24, 24, 24, 331, 26, 26, 26,
/* 1000 */ 26, 27, 27, 28, 28, 28, 29, 216, 304, 331,
- /* 1010 */ 209, 328, 257, 249, 607, 331, 252, 202, 203, 204,
- /* 1020 */ 434, 84, 290, 258, 328, 532, 531, 331, 414, 394,
- /* 1030 */ 328, 331, 533, 434, 86, 332, 141, 445, 451, 434,
- /* 1040 */ 87, 47, 328, 496, 435, 151, 328, 537, 410, 155,
- /* 1050 */ 414, 434, 88, 534, 494, 434, 73, 308, 455, 456,
- /* 1060 */ 452, 452, 25, 25, 24, 24, 24, 24, 386, 26,
+ /* 1010 */ 209, 328, 529, 540, 610, 331, 436, 563, 375, 563,
+ /* 1020 */ 435, 83, 362, 538, 328, 155, 541, 331, 499, 526,
+ /* 1030 */ 328, 331, 575, 435, 84, 424, 543, 446, 452, 435,
+ /* 1040 */ 86, 290, 328, 415, 436, 267, 328, 155, 394, 141,
+ /* 1050 */ 415, 435, 87, 588, 411, 435, 88, 308, 456, 457,
+ /* 1060 */ 453, 453, 25, 25, 24, 24, 24, 24, 386, 26,
/* 1070 */ 26, 26, 26, 27, 27, 28, 28, 28, 29, 216,
- /* 1080 */ 35, 338, 286, 3, 331, 411, 331, 327, 413, 423,
- /* 1090 */ 382, 422, 276, 254, 420, 35, 338, 335, 3, 328,
- /* 1100 */ 414, 328, 327, 413, 414, 313, 276, 414, 434, 74,
- /* 1110 */ 434, 89, 335, 331, 421, 340, 424, 331, 425, 331,
- /* 1120 */ 267, 414, 155, 142, 289, 471, 287, 325, 328, 326,
- /* 1130 */ 340, 414, 328, 414, 328, 581, 276, 434, 90, 144,
- /* 1140 */ 471, 434, 91, 434, 92, 38, 37, 15, 331, 277,
- /* 1150 */ 133, 414, 441, 276, 36, 329, 330, 6, 436, 440,
- /* 1160 */ 38, 37, 504, 328, 206, 414, 47, 414, 414, 36,
- /* 1170 */ 329, 330, 434, 75, 440, 198, 367, 214, 155, 583,
- /* 1180 */ 235, 236, 237, 143, 239, 348, 343, 580, 46, 243,
- /* 1190 */ 442, 442, 442, 443, 444, 9, 584, 276, 435, 7,
- /* 1200 */ 172, 414, 294, 331, 288, 442, 442, 442, 443, 444,
- /* 1210 */ 9, 295, 414, 35, 338, 567, 3, 155, 328, 480,
- /* 1220 */ 327, 413, 331, 170, 276, 571, 244, 434, 17, 169,
- /* 1230 */ 335, 19, 171, 245, 414, 412, 413, 328, 331, 414,
- /* 1240 */ 585, 276, 575, 576, 151, 54, 434, 94, 340, 493,
- /* 1250 */ 497, 499, 346, 328, 276, 262, 414, 529, 471, 263,
- /* 1260 */ 246, 20, 434, 95, 414, 414, 414, 231, 548, 414,
- /* 1270 */ 414, 437, 414, 471, 414, 393, 291, 281, 38, 37,
- /* 1280 */ 588, 305, 54, 414, 232, 269, 214, 36, 329, 330,
- /* 1290 */ 219, 271, 440, 188, 189, 273, 275, 292, 42, 280,
- /* 1300 */ 414, 380, 383, 512, 384, 283, 414, 440, 149, 399,
- /* 1310 */ 414, 414, 608, 605, 414, 302, 414, 414, 284, 414,
- /* 1320 */ 414, 285, 579, 442, 442, 442, 443, 444, 9, 48,
- /* 1330 */ 590, 293, 296, 414, 297, 602, 414, 414, 442, 442,
- /* 1340 */ 442, 251, 351, 481, 177, 414, 414, 414, 495, 414,
- /* 1350 */ 414, 501, 253, 255, 609, 502, 357, 312, 521, 515,
- /* 1360 */ 107, 525, 226, 225, 520, 260, 369, 158, 227, 524,
- /* 1370 */ 557, 526, 300, 549, 550, 551, 373, 278, 159, 301,
- /* 1380 */ 543, 371, 160, 51, 207, 559, 560, 161, 140, 379,
- /* 1390 */ 570, 163, 117, 391, 181, 392, 118, 119, 120, 121,
- /* 1400 */ 321, 123, 577, 599, 600, 55, 58, 586, 601, 604,
- /* 1410 */ 62, 323, 408, 103, 224, 111, 174, 238, 427, 199,
- /* 1420 */ 654, 655, 656, 146, 147, 454, 457, 34, 182, 180,
- /* 1430 */ 461, 470, 473, 474, 195, 5, 492, 475, 148, 479,
- /* 1440 */ 44, 106, 10, 11, 138, 508, 509, 500, 223, 49,
- /* 1450 */ 361, 108, 152, 266, 109, 50, 110, 157, 258, 370,
- /* 1460 */ 184, 558, 139, 113, 151, 162, 279, 115, 374, 14,
- /* 1470 */ 573, 116, 165, 52, 12, 366, 166, 53, 578, 167,
- /* 1480 */ 582, 168, 114, 124, 122, 561, 565, 13, 61, 125,
- /* 1490 */ 597, 173, 298, 187, 589, 405, 936, 611, 936, 936,
- /* 1500 */ 401,
+ /* 1080 */ 35, 338, 286, 3, 331, 270, 331, 327, 414, 421,
+ /* 1090 */ 382, 318, 276, 422, 325, 35, 338, 335, 3, 328,
+ /* 1100 */ 423, 328, 327, 414, 142, 144, 276, 415, 435, 73,
+ /* 1110 */ 435, 74, 335, 331, 6, 340, 425, 331, 326, 331,
+ /* 1120 */ 367, 415, 155, 437, 289, 472, 287, 274, 328, 272,
+ /* 1130 */ 340, 415, 328, 47, 328, 277, 276, 435, 89, 348,
+ /* 1140 */ 472, 435, 90, 435, 91, 38, 37, 243, 331, 582,
+ /* 1150 */ 244, 415, 426, 276, 36, 329, 330, 46, 245, 441,
+ /* 1160 */ 38, 37, 505, 328, 202, 203, 204, 415, 415, 36,
+ /* 1170 */ 329, 330, 435, 92, 441, 198, 568, 214, 155, 584,
+ /* 1180 */ 235, 236, 237, 143, 239, 346, 133, 581, 438, 246,
+ /* 1190 */ 443, 443, 443, 444, 445, 10, 585, 276, 20, 42,
+ /* 1200 */ 172, 415, 294, 331, 288, 443, 443, 443, 444, 445,
+ /* 1210 */ 10, 295, 415, 35, 338, 219, 3, 149, 328, 482,
+ /* 1220 */ 327, 414, 331, 170, 276, 572, 48, 435, 75, 169,
+ /* 1230 */ 335, 19, 171, 251, 442, 413, 414, 328, 331, 415,
+ /* 1240 */ 586, 343, 276, 177, 351, 496, 435, 17, 340, 415,
+ /* 1250 */ 481, 253, 255, 328, 276, 502, 415, 415, 472, 331,
+ /* 1260 */ 503, 357, 435, 94, 576, 415, 151, 231, 312, 415,
+ /* 1270 */ 577, 516, 54, 472, 328, 393, 291, 281, 38, 37,
+ /* 1280 */ 494, 305, 521, 435, 95, 232, 214, 36, 329, 330,
+ /* 1290 */ 526, 498, 441, 188, 189, 415, 500, 292, 522, 262,
+ /* 1300 */ 530, 260, 263, 513, 549, 269, 415, 441, 589, 400,
+ /* 1310 */ 54, 415, 525, 527, 415, 415, 271, 415, 273, 415,
+ /* 1320 */ 415, 275, 280, 443, 443, 443, 444, 445, 10, 107,
+ /* 1330 */ 380, 415, 383, 415, 384, 283, 415, 415, 443, 443,
+ /* 1340 */ 443, 284, 285, 580, 300, 415, 591, 415, 293, 415,
+ /* 1350 */ 415, 296, 297, 605, 226, 550, 415, 415, 415, 225,
+ /* 1360 */ 608, 415, 302, 415, 551, 227, 415, 415, 415, 301,
+ /* 1370 */ 544, 552, 369, 158, 373, 558, 159, 278, 371, 160,
+ /* 1380 */ 51, 207, 560, 561, 161, 140, 379, 117, 571, 163,
+ /* 1390 */ 391, 392, 181, 180, 321, 602, 578, 118, 119, 120,
+ /* 1400 */ 121, 123, 55, 587, 58, 603, 604, 607, 62, 174,
+ /* 1410 */ 103, 224, 111, 409, 238, 428, 199, 323, 657, 658,
+ /* 1420 */ 659, 146, 147, 455, 458, 34, 474, 462, 471, 182,
+ /* 1430 */ 195, 148, 475, 476, 480, 5, 12, 493, 44, 11,
+ /* 1440 */ 106, 138, 509, 510, 501, 223, 49, 361, 108, 109,
+ /* 1450 */ 152, 266, 50, 110, 157, 258, 370, 184, 559, 139,
+ /* 1460 */ 151, 113, 279, 162, 115, 374, 15, 574, 116, 165,
+ /* 1470 */ 52, 13, 366, 579, 53, 167, 168, 166, 583, 124,
+ /* 1480 */ 114, 122, 562, 566, 14, 61, 599, 600, 125, 173,
+ /* 1490 */ 298, 590, 187, 406, 941, 614, 941, 402,
};
static const YYCODETYPE yy_lookahead[] = {
/* 0 */ 19, 142, 143, 144, 145, 24, 116, 26, 75, 76,
/* 120 */ 67, 68, 69, 70, 71, 72, 73, 74, 75, 76,
/* 130 */ 77, 78, 186, 80, 81, 82, 83, 84, 85, 86,
/* 140 */ 87, 88, 89, 90, 19, 90, 205, 95, 84, 85,
- /* 150 */ 26, 96, 97, 98, 99, 100, 101, 102, 94, 95,
- /* 160 */ 181, 182, 150, 222, 109, 224, 225, 188, 104, 105,
+ /* 150 */ 186, 96, 97, 98, 99, 100, 101, 102, 94, 95,
+ /* 160 */ 195, 97, 150, 222, 109, 224, 225, 26, 104, 105,
/* 170 */ 217, 90, 120, 48, 49, 50, 86, 165, 97, 98,
/* 180 */ 99, 100, 101, 102, 94, 95, 174, 175, 1, 2,
/* 190 */ 109, 66, 67, 68, 69, 70, 71, 72, 73, 74,
- /* 200 */ 75, 76, 77, 78, 12, 80, 81, 82, 83, 84,
- /* 210 */ 85, 86, 87, 88, 89, 90, 19, 11, 94, 150,
- /* 220 */ 28, 24, 186, 150, 222, 150, 224, 225, 216, 116,
- /* 230 */ 161, 162, 150, 221, 165, 43, 195, 45, 165, 191,
- /* 240 */ 165, 128, 160, 170, 171, 48, 49, 165, 163, 174,
- /* 250 */ 175, 166, 167, 168, 185, 186, 174, 175, 169, 170,
- /* 260 */ 171, 55, 64, 66, 67, 68, 69, 70, 71, 72,
+ /* 200 */ 75, 76, 77, 78, 191, 80, 81, 82, 83, 84,
+ /* 210 */ 85, 86, 87, 88, 89, 90, 19, 116, 35, 150,
+ /* 220 */ 155, 24, 208, 150, 222, 150, 224, 225, 216, 128,
+ /* 230 */ 161, 162, 150, 221, 165, 94, 23, 150, 165, 56,
+ /* 240 */ 165, 197, 160, 170, 171, 48, 49, 165, 204, 174,
+ /* 250 */ 175, 22, 165, 24, 185, 186, 174, 175, 169, 170,
+ /* 260 */ 171, 174, 175, 66, 67, 68, 69, 70, 71, 72,
/* 270 */ 73, 74, 75, 76, 77, 78, 194, 80, 81, 82,
/* 280 */ 83, 84, 85, 86, 87, 88, 89, 90, 19, 214,
- /* 290 */ 215, 25, 94, 172, 173, 150, 98, 148, 216, 173,
- /* 300 */ 146, 147, 181, 221, 231, 232, 152, 181, 154, 150,
- /* 310 */ 165, 105, 106, 107, 160, 89, 90, 48, 49, 174,
- /* 320 */ 175, 232, 116, 112, 165, 114, 115, 129, 130, 131,
- /* 330 */ 55, 16, 196, 174, 175, 66, 67, 68, 69, 70,
+ /* 290 */ 215, 108, 150, 25, 229, 150, 64, 148, 216, 234,
+ /* 300 */ 146, 147, 215, 221, 231, 232, 152, 165, 154, 150,
+ /* 310 */ 165, 196, 170, 171, 160, 181, 182, 48, 49, 174,
+ /* 320 */ 175, 232, 188, 165, 165, 112, 94, 114, 115, 166,
+ /* 330 */ 98, 55, 174, 174, 175, 66, 67, 68, 69, 70,
/* 340 */ 71, 72, 73, 74, 75, 76, 77, 78, 194, 80,
/* 350 */ 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
- /* 360 */ 19, 165, 96, 150, 208, 99, 100, 101, 150, 19,
- /* 370 */ 174, 226, 218, 58, 215, 60, 110, 27, 165, 150,
- /* 380 */ 105, 106, 107, 165, 26, 27, 155, 174, 175, 48,
- /* 390 */ 49, 116, 174, 175, 165, 183, 24, 22, 26, 245,
- /* 400 */ 166, 26, 27, 174, 175, 136, 160, 66, 67, 68,
+ /* 360 */ 19, 129, 130, 131, 96, 84, 85, 99, 100, 101,
+ /* 370 */ 150, 226, 218, 231, 232, 216, 150, 222, 110, 224,
+ /* 380 */ 225, 105, 106, 107, 135, 165, 137, 172, 173, 48,
+ /* 390 */ 49, 165, 116, 183, 174, 175, 181, 242, 22, 245,
+ /* 400 */ 174, 175, 26, 27, 166, 136, 183, 66, 67, 68,
/* 410 */ 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
- /* 420 */ 160, 80, 81, 82, 83, 84, 85, 86, 87, 88,
- /* 430 */ 89, 90, 19, 220, 150, 150, 23, 183, 220, 23,
- /* 440 */ 194, 25, 84, 96, 160, 216, 99, 100, 101, 165,
- /* 450 */ 165, 183, 94, 95, 194, 170, 150, 110, 174, 175,
- /* 460 */ 229, 48, 49, 236, 158, 234, 94, 161, 162, 94,
- /* 470 */ 95, 165, 86, 87, 88, 89, 90, 136, 194, 66,
+ /* 420 */ 11, 80, 81, 82, 83, 84, 85, 86, 87, 88,
+ /* 430 */ 89, 90, 19, 150, 150, 23, 23, 25, 160, 150,
+ /* 440 */ 220, 26, 27, 205, 160, 150, 220, 158, 165, 165,
+ /* 450 */ 161, 162, 26, 27, 165, 0, 1, 2, 174, 175,
+ /* 460 */ 165, 48, 49, 23, 55, 86, 87, 88, 89, 90,
+ /* 470 */ 94, 95, 194, 169, 170, 171, 193, 136, 194, 66,
/* 480 */ 67, 68, 69, 70, 71, 72, 73, 74, 75, 76,
- /* 490 */ 77, 78, 150, 80, 81, 82, 83, 84, 85, 86,
- /* 500 */ 87, 88, 89, 90, 19, 150, 160, 165, 23, 26,
- /* 510 */ 27, 95, 153, 150, 26, 27, 231, 232, 22, 19,
- /* 520 */ 165, 29, 26, 27, 222, 33, 224, 225, 165, 174,
- /* 530 */ 175, 150, 31, 48, 49, 193, 120, 174, 175, 47,
- /* 540 */ 194, 40, 161, 162, 242, 166, 165, 237, 166, 167,
- /* 550 */ 168, 66, 67, 68, 69, 70, 71, 72, 73, 74,
+ /* 490 */ 77, 78, 166, 80, 81, 82, 83, 84, 85, 86,
+ /* 500 */ 87, 88, 89, 90, 19, 65, 160, 95, 23, 94,
+ /* 510 */ 95, 173, 217, 22, 105, 106, 107, 26, 22, 181,
+ /* 520 */ 94, 95, 26, 27, 96, 116, 243, 99, 100, 101,
+ /* 530 */ 150, 205, 120, 48, 49, 120, 232, 22, 110, 166,
+ /* 540 */ 194, 161, 162, 183, 163, 165, 120, 166, 167, 168,
+ /* 550 */ 160, 66, 67, 68, 69, 70, 71, 72, 73, 74,
/* 560 */ 75, 76, 77, 78, 218, 80, 81, 82, 83, 84,
- /* 570 */ 85, 86, 87, 88, 89, 90, 19, 94, 95, 12,
- /* 580 */ 23, 235, 94, 95, 205, 243, 240, 150, 196, 150,
- /* 590 */ 94, 95, 150, 198, 150, 28, 150, 23, 98, 169,
- /* 600 */ 170, 171, 165, 120, 165, 48, 49, 165, 120, 165,
- /* 610 */ 43, 165, 45, 174, 175, 0, 1, 2, 174, 175,
- /* 620 */ 174, 175, 55, 66, 67, 68, 69, 70, 71, 72,
+ /* 570 */ 85, 86, 87, 88, 89, 90, 19, 12, 205, 150,
+ /* 580 */ 23, 235, 190, 191, 194, 94, 240, 150, 86, 74,
+ /* 590 */ 94, 95, 150, 28, 165, 236, 206, 207, 23, 150,
+ /* 600 */ 48, 49, 165, 174, 175, 48, 49, 165, 43, 31,
+ /* 610 */ 45, 174, 175, 21, 165, 113, 174, 175, 40, 117,
+ /* 620 */ 55, 69, 70, 66, 67, 68, 69, 70, 71, 72,
/* 630 */ 73, 74, 75, 76, 77, 78, 150, 80, 81, 82,
/* 640 */ 83, 84, 85, 86, 87, 88, 89, 90, 19, 150,
- /* 650 */ 213, 165, 23, 19, 22, 150, 97, 166, 26, 217,
- /* 660 */ 174, 175, 232, 22, 165, 24, 150, 23, 84, 85,
- /* 670 */ 165, 48, 49, 174, 175, 116, 49, 48, 49, 174,
- /* 680 */ 175, 165, 233, 49, 21, 233, 112, 128, 114, 115,
- /* 690 */ 174, 175, 69, 70, 160, 66, 67, 68, 69, 70,
+ /* 650 */ 98, 165, 23, 61, 23, 150, 25, 150, 19, 113,
+ /* 660 */ 174, 175, 213, 117, 165, 24, 153, 26, 23, 150,
+ /* 670 */ 165, 150, 165, 174, 175, 89, 90, 48, 49, 174,
+ /* 680 */ 175, 174, 175, 19, 165, 237, 165, 112, 49, 114,
+ /* 690 */ 115, 27, 100, 174, 175, 66, 67, 68, 69, 70,
/* 700 */ 71, 72, 73, 74, 75, 76, 77, 78, 150, 80,
/* 710 */ 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
- /* 720 */ 19, 98, 150, 165, 61, 24, 94, 150, 194, 150,
- /* 730 */ 150, 104, 174, 175, 190, 191, 23, 165, 104, 135,
- /* 740 */ 150, 137, 165, 109, 165, 165, 174, 175, 228, 48,
- /* 750 */ 49, 174, 175, 174, 175, 165, 112, 209, 114, 115,
- /* 760 */ 160, 190, 191, 100, 174, 175, 177, 66, 67, 68,
+ /* 720 */ 19, 150, 150, 165, 150, 24, 112, 150, 114, 115,
+ /* 730 */ 138, 19, 174, 175, 213, 94, 165, 165, 150, 165,
+ /* 740 */ 29, 150, 165, 104, 33, 174, 175, 196, 109, 48,
+ /* 750 */ 49, 174, 175, 165, 190, 191, 165, 112, 47, 114,
+ /* 760 */ 115, 187, 174, 175, 160, 174, 175, 66, 67, 68,
/* 770 */ 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
/* 780 */ 150, 80, 81, 82, 83, 84, 85, 86, 87, 88,
- /* 790 */ 89, 90, 19, 150, 194, 165, 105, 106, 107, 150,
- /* 800 */ 150, 138, 248, 249, 174, 175, 206, 207, 165, 144,
- /* 810 */ 145, 150, 23, 197, 165, 165, 177, 174, 175, 150,
- /* 820 */ 204, 48, 49, 174, 175, 112, 165, 114, 115, 22,
- /* 830 */ 23, 23, 25, 25, 165, 174, 175, 187, 182, 66,
+ /* 790 */ 89, 90, 19, 150, 150, 165, 198, 12, 194, 150,
+ /* 800 */ 150, 150, 248, 249, 174, 175, 206, 207, 165, 165,
+ /* 810 */ 98, 23, 150, 28, 165, 165, 165, 174, 175, 166,
+ /* 820 */ 150, 48, 49, 174, 175, 174, 175, 165, 43, 233,
+ /* 830 */ 45, 22, 23, 177, 25, 165, 174, 175, 233, 66,
/* 840 */ 67, 68, 69, 70, 71, 72, 73, 74, 75, 76,
/* 850 */ 77, 78, 150, 80, 81, 82, 83, 84, 85, 86,
- /* 860 */ 87, 88, 89, 90, 19, 150, 150, 165, 150, 25,
- /* 870 */ 150, 150, 65, 150, 206, 207, 174, 175, 113, 199,
- /* 880 */ 165, 165, 117, 165, 150, 165, 165, 150, 165, 174,
- /* 890 */ 175, 150, 166, 48, 49, 174, 175, 174, 175, 165,
- /* 900 */ 178, 112, 165, 114, 115, 187, 165, 187, 174, 175,
- /* 910 */ 177, 66, 67, 68, 69, 70, 71, 72, 73, 74,
+ /* 860 */ 87, 88, 89, 90, 19, 150, 97, 165, 25, 150,
+ /* 870 */ 160, 150, 150, 150, 65, 228, 174, 175, 144, 145,
+ /* 880 */ 165, 246, 247, 150, 165, 116, 165, 165, 165, 174,
+ /* 890 */ 175, 129, 130, 48, 49, 174, 175, 128, 165, 98,
+ /* 900 */ 112, 177, 114, 115, 194, 49, 187, 174, 175, 187,
+ /* 910 */ 109, 66, 67, 68, 69, 70, 71, 72, 73, 74,
/* 920 */ 75, 76, 77, 78, 150, 80, 81, 82, 83, 84,
- /* 930 */ 85, 86, 87, 88, 89, 90, 19, 150, 150, 165,
- /* 940 */ 25, 150, 86, 150, 7, 8, 9, 103, 174, 175,
- /* 950 */ 213, 166, 165, 165, 213, 150, 165, 177, 165, 129,
- /* 960 */ 130, 174, 175, 246, 247, 48, 49, 174, 175, 113,
- /* 970 */ 165, 22, 23, 117, 25, 187, 177, 166, 187, 174,
- /* 980 */ 175, 7, 8, 199, 67, 68, 69, 70, 71, 72,
+ /* 930 */ 85, 86, 87, 88, 89, 90, 19, 150, 23, 165,
+ /* 940 */ 25, 150, 150, 150, 150, 166, 167, 168, 174, 175,
+ /* 950 */ 209, 25, 165, 7, 8, 150, 165, 165, 165, 165,
+ /* 960 */ 104, 174, 175, 97, 98, 48, 49, 174, 175, 126,
+ /* 970 */ 165, 22, 23, 177, 25, 7, 8, 9, 187, 174,
+ /* 980 */ 175, 187, 160, 177, 67, 68, 69, 70, 71, 72,
/* 990 */ 73, 74, 75, 76, 77, 78, 150, 80, 81, 82,
/* 1000 */ 83, 84, 85, 86, 87, 88, 89, 90, 19, 150,
- /* 1010 */ 160, 165, 98, 150, 65, 150, 205, 105, 106, 107,
- /* 1020 */ 174, 175, 209, 109, 165, 97, 98, 150, 165, 209,
- /* 1030 */ 165, 150, 35, 174, 175, 150, 6, 48, 49, 174,
- /* 1040 */ 175, 126, 165, 23, 194, 25, 165, 23, 149, 25,
- /* 1050 */ 165, 174, 175, 56, 166, 174, 175, 68, 69, 70,
+ /* 1010 */ 160, 165, 182, 166, 65, 150, 194, 105, 106, 107,
+ /* 1020 */ 174, 175, 178, 23, 165, 25, 177, 150, 150, 103,
+ /* 1030 */ 165, 150, 199, 174, 175, 150, 166, 48, 49, 174,
+ /* 1040 */ 175, 209, 165, 165, 194, 23, 165, 25, 209, 6,
+ /* 1050 */ 165, 174, 175, 199, 149, 174, 175, 68, 69, 70,
/* 1060 */ 71, 72, 73, 74, 75, 76, 77, 78, 218, 80,
/* 1070 */ 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
- /* 1080 */ 19, 20, 16, 22, 150, 150, 150, 26, 27, 150,
- /* 1090 */ 240, 13, 150, 205, 149, 19, 20, 36, 22, 165,
- /* 1100 */ 165, 165, 26, 27, 165, 108, 150, 165, 174, 175,
- /* 1110 */ 174, 175, 36, 150, 149, 54, 150, 150, 150, 150,
- /* 1120 */ 23, 165, 25, 151, 58, 64, 60, 149, 165, 159,
- /* 1130 */ 54, 165, 165, 165, 165, 193, 150, 174, 175, 151,
- /* 1140 */ 64, 174, 175, 174, 175, 84, 85, 22, 150, 193,
- /* 1150 */ 150, 165, 150, 150, 93, 94, 95, 25, 194, 98,
- /* 1160 */ 84, 85, 86, 165, 160, 165, 126, 165, 165, 93,
+ /* 1080 */ 19, 20, 16, 22, 150, 16, 150, 26, 27, 149,
+ /* 1090 */ 240, 213, 150, 149, 149, 19, 20, 36, 22, 165,
+ /* 1100 */ 13, 165, 26, 27, 151, 151, 150, 165, 174, 175,
+ /* 1110 */ 174, 175, 36, 150, 25, 54, 150, 150, 159, 150,
+ /* 1120 */ 23, 165, 25, 194, 58, 64, 60, 58, 165, 60,
+ /* 1130 */ 54, 165, 165, 126, 165, 193, 150, 174, 175, 123,
+ /* 1140 */ 64, 174, 175, 174, 175, 84, 85, 199, 150, 193,
+ /* 1150 */ 200, 165, 150, 150, 93, 94, 95, 124, 201, 98,
+ /* 1160 */ 84, 85, 86, 165, 105, 106, 107, 165, 165, 93,
/* 1170 */ 94, 95, 174, 175, 98, 5, 23, 116, 25, 193,
- /* 1180 */ 10, 11, 12, 13, 14, 123, 150, 17, 124, 199,
- /* 1190 */ 129, 130, 131, 132, 133, 134, 193, 150, 194, 74,
+ /* 1180 */ 10, 11, 12, 13, 14, 122, 150, 17, 203, 202,
+ /* 1190 */ 129, 130, 131, 132, 133, 134, 193, 150, 125, 135,
/* 1200 */ 30, 165, 32, 150, 138, 129, 130, 131, 132, 133,
- /* 1210 */ 134, 41, 165, 19, 20, 23, 22, 25, 165, 150,
- /* 1220 */ 26, 27, 150, 53, 150, 55, 200, 174, 175, 59,
- /* 1230 */ 36, 22, 62, 201, 165, 26, 27, 165, 150, 165,
- /* 1240 */ 193, 150, 23, 23, 25, 25, 174, 175, 54, 150,
- /* 1250 */ 150, 150, 122, 165, 150, 150, 165, 150, 64, 150,
- /* 1260 */ 202, 125, 174, 175, 165, 165, 165, 193, 150, 165,
- /* 1270 */ 165, 203, 165, 64, 165, 105, 106, 107, 84, 85,
- /* 1280 */ 23, 111, 25, 165, 193, 150, 116, 93, 94, 95,
- /* 1290 */ 227, 150, 98, 84, 85, 150, 150, 193, 135, 150,
- /* 1300 */ 165, 150, 150, 94, 150, 150, 165, 98, 118, 139,
- /* 1310 */ 165, 165, 23, 23, 165, 25, 165, 165, 150, 165,
- /* 1320 */ 165, 150, 150, 129, 130, 131, 132, 133, 134, 104,
- /* 1330 */ 150, 150, 150, 165, 150, 150, 165, 165, 129, 130,
- /* 1340 */ 131, 210, 121, 157, 157, 165, 165, 165, 211, 165,
- /* 1350 */ 165, 211, 210, 210, 65, 211, 104, 46, 184, 176,
- /* 1360 */ 22, 103, 90, 230, 176, 176, 18, 156, 230, 178,
- /* 1370 */ 157, 176, 179, 176, 176, 176, 44, 238, 156, 179,
- /* 1380 */ 184, 157, 156, 135, 157, 157, 239, 156, 66, 157,
- /* 1390 */ 189, 189, 22, 157, 219, 18, 192, 192, 192, 192,
- /* 1400 */ 157, 189, 199, 39, 157, 241, 241, 199, 157, 37,
- /* 1410 */ 244, 250, 1, 164, 180, 180, 247, 15, 23, 22,
- /* 1420 */ 118, 118, 118, 118, 118, 98, 113, 22, 22, 219,
- /* 1430 */ 23, 23, 11, 23, 22, 34, 120, 23, 25, 23,
- /* 1440 */ 25, 22, 25, 34, 118, 23, 23, 27, 50, 22,
- /* 1450 */ 50, 22, 34, 23, 22, 22, 22, 102, 109, 19,
- /* 1460 */ 24, 20, 38, 104, 25, 104, 138, 22, 42, 5,
- /* 1470 */ 1, 108, 127, 74, 22, 50, 119, 74, 1, 16,
- /* 1480 */ 20, 121, 51, 108, 119, 57, 51, 22, 16, 127,
- /* 1490 */ 23, 15, 140, 22, 128, 3, 251, 4, 251, 251,
- /* 1500 */ 63,
+ /* 1210 */ 134, 41, 165, 19, 20, 227, 22, 118, 165, 157,
+ /* 1220 */ 26, 27, 150, 53, 150, 55, 104, 174, 175, 59,
+ /* 1230 */ 36, 22, 62, 210, 150, 26, 27, 165, 150, 165,
+ /* 1240 */ 193, 150, 150, 157, 121, 211, 174, 175, 54, 165,
+ /* 1250 */ 150, 210, 210, 165, 150, 211, 165, 165, 64, 150,
+ /* 1260 */ 211, 104, 174, 175, 23, 165, 25, 193, 46, 165,
+ /* 1270 */ 23, 176, 25, 64, 165, 105, 106, 107, 84, 85,
+ /* 1280 */ 150, 111, 176, 174, 175, 193, 116, 93, 94, 95,
+ /* 1290 */ 103, 150, 98, 84, 85, 165, 150, 193, 184, 150,
+ /* 1300 */ 150, 176, 150, 94, 150, 150, 165, 98, 23, 139,
+ /* 1310 */ 25, 165, 178, 176, 165, 165, 150, 165, 150, 165,
+ /* 1320 */ 165, 150, 150, 129, 130, 131, 132, 133, 134, 22,
+ /* 1330 */ 150, 165, 150, 165, 150, 150, 165, 165, 129, 130,
+ /* 1340 */ 131, 150, 150, 150, 179, 165, 150, 165, 150, 165,
+ /* 1350 */ 165, 150, 150, 150, 90, 176, 165, 165, 165, 230,
+ /* 1360 */ 23, 165, 25, 165, 176, 230, 165, 165, 165, 179,
+ /* 1370 */ 184, 176, 18, 156, 44, 157, 156, 238, 157, 156,
+ /* 1380 */ 135, 157, 157, 239, 156, 66, 157, 22, 189, 189,
+ /* 1390 */ 157, 18, 219, 219, 157, 39, 199, 192, 192, 192,
+ /* 1400 */ 192, 189, 241, 199, 241, 157, 157, 37, 244, 247,
+ /* 1410 */ 164, 180, 180, 1, 15, 23, 22, 250, 118, 118,
+ /* 1420 */ 118, 118, 118, 98, 113, 22, 11, 23, 23, 22,
+ /* 1430 */ 22, 25, 23, 23, 23, 34, 34, 120, 25, 25,
+ /* 1440 */ 22, 118, 23, 23, 27, 50, 22, 50, 22, 22,
+ /* 1450 */ 34, 23, 22, 22, 102, 109, 19, 24, 20, 38,
+ /* 1460 */ 25, 104, 138, 104, 22, 42, 5, 1, 108, 127,
+ /* 1470 */ 74, 22, 50, 1, 74, 16, 121, 119, 20, 108,
+ /* 1480 */ 51, 119, 57, 51, 22, 16, 23, 23, 127, 15,
+ /* 1490 */ 140, 128, 22, 3, 251, 4, 251, 63,
};
#define YY_SHIFT_USE_DFLT (-111)
-#define YY_SHIFT_MAX 405
+#define YY_SHIFT_MAX 406
static const short yy_shift_ofst[] = {
- /* 0 */ 187, 1061, 1170, 1061, 1194, 1194, -2, 64, -19, 1194,
- /* 10 */ 1194, 1194, 1194, 1194, 275, 358, 1, 125, 1076, 1194,
+ /* 0 */ 187, 1061, 1170, 1061, 1194, 1194, -2, 64, 64, -19,
+ /* 10 */ 1194, 1194, 1194, 1194, 1194, 276, 1, 125, 1076, 1194,
/* 20 */ 1194, 1194, 1194, 1194, 1194, 1194, 1194, 1194, 1194, 1194,
/* 30 */ 1194, 1194, 1194, 1194, 1194, 1194, 1194, 1194, 1194, 1194,
/* 40 */ 1194, 1194, 1194, 1194, 1194, 1194, 1194, 1194, 1194, 1194,
/* 50 */ 1194, 1194, 1194, 1194, 1194, 1194, 1194, 1194, 1194, -48,
- /* 60 */ 206, 1, 1, 124, 584, 584, -110, 53, 197, 269,
+ /* 60 */ 409, 1, 1, 141, 281, 281, -110, 53, 197, 269,
/* 70 */ 341, 413, 485, 557, 629, 701, 773, 845, 773, 773,
/* 80 */ 773, 773, 773, 773, 773, 773, 773, 773, 773, 773,
/* 90 */ 773, 773, 773, 773, 773, 773, 917, 989, 989, -67,
- /* 100 */ -67, -1, -1, 55, 25, 386, 1, 1, 1, 1,
- /* 110 */ 1, 634, 663, 1, 1, 1, 1, 1, 1, 1,
- /* 120 */ 1, 1, 1, 1, 1, 1, 226, 124, -17, -111,
- /* 130 */ -111, -111, 1209, 81, 375, 483, 488, 496, 90, 567,
- /* 140 */ 567, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ /* 100 */ -67, -1, -1, 55, 25, 379, 1, 1, 1, 1,
+ /* 110 */ 1, 639, 592, 1, 1, 1, 1, 1, 1, 1,
+ /* 120 */ 1, 1, 1, 1, 1, 1, 586, 141, -17, -111,
+ /* 130 */ -111, -111, 1209, 81, 376, 415, 426, 496, 90, 565,
+ /* 140 */ 565, 1, 1, 1, 1, 1, 1, 1, 1, 1,
/* 150 */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
/* 160 */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- /* 170 */ 1, 1, 1, 1, 807, 949, 615, 372, 372, 372,
- /* 180 */ 559, 113, -110, -110, -110, -111, -111, -111, 198, 198,
- /* 190 */ 266, 347, 574, 644, 713, 192, 789, 416, 937, 856,
- /* 200 */ 632, 52, 997, 997, 997, 211, 211, 492, 691, 211,
- /* 210 */ 211, 211, 211, 641, 765, -13, 124, 830, 830, 604,
- /* 220 */ 501, 501, 350, 501, 627, 501, 124, 501, 124, 844,
- /* 230 */ 915, 350, 350, 915, 1030, 1030, 1030, 1030, 1078, 1078,
- /* 240 */ 1132, -110, 1040, 1062, 1064, 1130, 1136, 1163, 1190, 1190,
- /* 250 */ 1225, 1221, 1225, 1221, 1225, 1221, 1252, 1252, 1311, 1252,
- /* 260 */ 1258, 1252, 1338, 1272, 1272, 1311, 1252, 1252, 1252, 1338,
- /* 270 */ 1348, 1190, 1348, 1190, 1348, 1190, 1190, 1332, 1248, 1348,
- /* 280 */ 1190, 1322, 1322, 1370, 1040, 1190, 1377, 1377, 1377, 1377,
- /* 290 */ 1040, 1322, 1370, 1190, 1364, 1364, 1190, 1190, 1372, -111,
- /* 300 */ -111, -111, -111, -111, 623, 1066, 912, 315, 500, 808,
- /* 310 */ 1020, 914, 974, 928, 1024, 1097, 1153, 1192, 1219, 1220,
- /* 320 */ 1257, 1125, 1290, 1289, 1411, 1402, 1395, 1397, 1302, 1303,
- /* 330 */ 1304, 1305, 1306, 1327, 1313, 1405, 1407, 1408, 1406, 1421,
- /* 340 */ 1412, 1410, 1413, 1414, 1416, 1415, 1401, 1417, 1409, 1415,
- /* 350 */ 1316, 1419, 1418, 1420, 1326, 1422, 1423, 1424, 1398, 1427,
- /* 360 */ 1400, 1429, 1430, 1432, 1433, 1425, 1434, 1355, 1349, 1440,
- /* 370 */ 1441, 1436, 1359, 1426, 1428, 1431, 1439, 1435, 1328, 1361,
- /* 380 */ 1445, 1464, 1469, 1363, 1399, 1403, 1345, 1452, 1357, 1477,
- /* 390 */ 1463, 1360, 1460, 1365, 1375, 1362, 1465, 1366, 1467, 1472,
- /* 400 */ 1437, 1476, 1352, 1471, 1492, 1493,
+ /* 170 */ 1, 1, 1, 1, 809, 949, 455, 641, 641, 641,
+ /* 180 */ 769, 101, -110, -110, -110, -111, -111, -111, 232, 232,
+ /* 190 */ 268, 428, 213, 575, 645, 785, 788, 412, 968, 502,
+ /* 200 */ 491, 52, 183, 183, 183, 614, 614, 711, 912, 614,
+ /* 210 */ 614, 614, 614, 229, 546, -13, 141, 762, 762, 249,
+ /* 220 */ 578, 578, 664, 578, 856, 578, 141, 578, 141, 926,
+ /* 230 */ 843, 664, 664, 843, 1043, 1043, 1043, 1043, 1087, 1087,
+ /* 240 */ 1089, -110, 1007, 1016, 1033, 1063, 1073, 1064, 1099, 1099,
+ /* 250 */ 1122, 1123, 1122, 1123, 1122, 1123, 1157, 1157, 1222, 1157,
+ /* 260 */ 1187, 1157, 1307, 1264, 1264, 1222, 1157, 1157, 1157, 1307,
+ /* 270 */ 1354, 1099, 1354, 1099, 1354, 1099, 1099, 1330, 1245, 1354,
+ /* 280 */ 1099, 1319, 1319, 1365, 1007, 1099, 1373, 1373, 1373, 1373,
+ /* 290 */ 1007, 1319, 1365, 1099, 1356, 1356, 1099, 1099, 1370, -111,
+ /* 300 */ -111, -111, -111, -111, 552, 1066, 1059, 1069, 712, 631,
+ /* 310 */ 915, 801, 946, 866, 1000, 1022, 1097, 1153, 1241, 1247,
+ /* 320 */ 1285, 515, 1337, 440, 1412, 1399, 1392, 1394, 1300, 1301,
+ /* 330 */ 1302, 1303, 1304, 1325, 1311, 1403, 1404, 1405, 1407, 1415,
+ /* 340 */ 1408, 1409, 1406, 1410, 1411, 1413, 1401, 1414, 1402, 1413,
+ /* 350 */ 1317, 1418, 1416, 1417, 1323, 1419, 1420, 1421, 1395, 1424,
+ /* 360 */ 1397, 1426, 1428, 1427, 1430, 1422, 1431, 1352, 1346, 1437,
+ /* 370 */ 1438, 1433, 1357, 1423, 1425, 1429, 1435, 1432, 1324, 1359,
+ /* 380 */ 1442, 1461, 1466, 1360, 1396, 1400, 1342, 1449, 1358, 1472,
+ /* 390 */ 1459, 1355, 1458, 1362, 1371, 1361, 1462, 1363, 1463, 1464,
+ /* 400 */ 1469, 1434, 1474, 1350, 1470, 1490, 1491,
};
#define YY_REDUCE_USE_DFLT (-180)
#define YY_REDUCE_MAX 303
static const short yy_reduce_ofst[] = {
- /* 0 */ -141, 82, 154, 284, 12, 75, 69, 73, -59, 145,
- /* 10 */ 159, 229, 213, 218, 346, 285, 306, 302, 355, 363,
- /* 20 */ 439, 444, 446, 486, 499, 505, 516, 558, 572, 577,
- /* 30 */ 579, 590, 630, 643, 649, 661, 702, 715, 721, 723,
- /* 40 */ 734, 774, 787, 793, 805, 846, 859, 865, 877, 881,
- /* 50 */ 934, 936, 963, 967, 969, 998, 1053, 1072, 1088, -179,
- /* 60 */ 850, 342, 381, 85, 89, 430, 600, 2, 2, 2,
+ /* 0 */ -141, 82, 154, 284, 12, 75, 69, 73, 142, -59,
+ /* 10 */ 145, 87, 159, 220, 226, 346, 289, 155, 429, 437,
+ /* 20 */ 442, 486, 499, 505, 507, 519, 558, 571, 577, 588,
+ /* 30 */ 591, 630, 643, 649, 651, 662, 702, 715, 721, 733,
+ /* 40 */ 774, 787, 793, 805, 846, 859, 865, 877, 881, 934,
+ /* 50 */ 936, 963, 967, 969, 998, 1053, 1072, 1088, 1109, -179,
+ /* 60 */ 850, 283, 380, 381, 89, 304, 390, 2, 2, 2,
/* 70 */ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
/* 80 */ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
/* 90 */ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- /* 100 */ 2, 2, 2, 121, 2, 2, 437, 650, 718, 720,
- /* 110 */ 788, -21, 231, 956, 737, 791, -47, 741, 942, 986,
- /* 120 */ 1003, 1047, 1074, 1091, 442, 1104, 2, 382, 2, 2,
- /* 130 */ 2, 2, 196, 126, 580, 669, 716, 863, 885, 544,
- /* 140 */ 571, 935, 939, 966, 968, 1000, 885, 1002, 1036, 1069,
- /* 150 */ 1099, 1100, 1101, 1105, 1107, 1109, 1118, 1135, 1141, 1145,
- /* 160 */ 1146, 1149, 1151, 1152, 1154, 1155, 1168, 1171, 1172, 1180,
- /* 170 */ 1181, 1182, 1184, 1185, 554, 554, 665, 379, 811, 888,
- /* 180 */ -134, 246, 260, 534, 1004, 616, 668, 717, -98, -70,
- /* 190 */ -54, 36, 41, 41, 41, 48, 41, 156, 149, 136,
- /* 200 */ 234, 156, 212, 254, 268, 41, 41, 227, 310, 41,
- /* 210 */ 41, 41, 41, 359, 392, 395, 491, 449, 452, 520,
- /* 220 */ 589, 639, 548, 733, 656, 780, 726, 799, 785, 722,
- /* 230 */ 680, 813, 820, 784, 899, 945, 965, 978, 972, 988,
- /* 240 */ 970, 964, 990, 1026, 1032, 1058, 1068, 1063, 1186, 1187,
- /* 250 */ 1131, 1137, 1142, 1140, 1143, 1144, 1183, 1188, 1174, 1189,
- /* 260 */ 1191, 1195, 1193, 1133, 1138, 1196, 1197, 1198, 1199, 1200,
- /* 270 */ 1211, 1213, 1222, 1224, 1226, 1227, 1228, 1139, 1147, 1231,
- /* 280 */ 1232, 1201, 1202, 1175, 1203, 1236, 1204, 1205, 1206, 1207,
- /* 290 */ 1208, 1212, 1210, 1243, 1164, 1165, 1247, 1251, 1166, 1249,
- /* 300 */ 1234, 1235, 1169, 1161,
+ /* 100 */ 2, 2, 2, 215, 2, 2, 449, 574, 719, 722,
+ /* 110 */ 791, 134, 65, 942, 521, 794, -47, 878, 956, 986,
+ /* 120 */ 1003, 1047, 1074, 1092, 295, 1104, 2, 779, 2, 2,
+ /* 130 */ 2, 2, 158, 338, 572, 644, 650, 670, 723, 392,
+ /* 140 */ 564, 792, 885, 966, 1002, 1036, 723, 1084, 1091, 1100,
+ /* 150 */ 1130, 1141, 1146, 1149, 1150, 1152, 1154, 1155, 1166, 1168,
+ /* 160 */ 1171, 1172, 1180, 1182, 1184, 1185, 1191, 1192, 1193, 1196,
+ /* 170 */ 1198, 1201, 1202, 1203, 554, 554, 734, 238, 326, 373,
+ /* 180 */ -134, 278, 604, 710, 822, 44, 600, 635, -98, -70,
+ /* 190 */ -54, -36, -35, -35, -35, 13, -35, 14, 149, 115,
+ /* 200 */ 163, 14, 210, 223, 360, -35, -35, 359, 448, -35,
+ /* 210 */ -35, -35, -35, 513, 551, 598, 653, 596, 605, 647,
+ /* 220 */ 656, 724, 741, 796, 830, 806, 847, 849, 870, 844,
+ /* 230 */ 833, 832, 839, 854, 905, 940, 944, 945, 953, 954,
+ /* 240 */ 959, 929, 948, 950, 957, 987, 985, 988, 1062, 1086,
+ /* 250 */ 1023, 1034, 1041, 1044, 1042, 1049, 1095, 1106, 1114, 1125,
+ /* 260 */ 1134, 1137, 1165, 1129, 1135, 1186, 1179, 1188, 1195, 1190,
+ /* 270 */ 1217, 1218, 1220, 1221, 1223, 1224, 1225, 1139, 1144, 1228,
+ /* 280 */ 1229, 1199, 1200, 1173, 1197, 1233, 1205, 1206, 1207, 1208,
+ /* 290 */ 1204, 1212, 1174, 1237, 1161, 1163, 1248, 1249, 1164, 1246,
+ /* 300 */ 1231, 1232, 1162, 1167,
};
static const YYACTIONTYPE yy_default[] = {
- /* 0 */ 618, 853, 934, 934, 853, 934, 934, 880, 741, 851,
- /* 10 */ 934, 934, 934, 934, 934, 880, 934, 909, 934, 934,
- /* 20 */ 934, 934, 934, 934, 934, 934, 934, 934, 934, 934,
- /* 30 */ 934, 934, 934, 934, 934, 934, 934, 934, 934, 934,
- /* 40 */ 934, 934, 934, 934, 934, 934, 934, 934, 934, 934,
- /* 50 */ 934, 934, 934, 934, 934, 934, 934, 934, 934, 825,
- /* 60 */ 934, 934, 934, 657, 880, 880, 745, 776, 934, 934,
- /* 70 */ 934, 934, 934, 934, 934, 934, 777, 934, 855, 850,
- /* 80 */ 846, 848, 847, 854, 778, 767, 774, 781, 756, 893,
- /* 90 */ 783, 784, 790, 791, 910, 908, 813, 812, 831, 815,
- /* 100 */ 837, 814, 824, 649, 816, 817, 934, 934, 934, 934,
- /* 110 */ 934, 710, 644, 934, 934, 934, 934, 934, 934, 934,
- /* 120 */ 934, 934, 934, 934, 934, 934, 818, 934, 819, 832,
- /* 130 */ 833, 834, 934, 934, 934, 934, 934, 934, 934, 934,
- /* 140 */ 934, 624, 934, 934, 934, 934, 934, 934, 934, 934,
- /* 150 */ 934, 934, 934, 934, 934, 934, 934, 934, 934, 934,
- /* 160 */ 934, 934, 934, 934, 934, 934, 934, 934, 934, 866,
- /* 170 */ 934, 913, 915, 934, 934, 934, 618, 741, 741, 741,
- /* 180 */ 934, 934, 934, 934, 934, 735, 745, 927, 934, 934,
- /* 190 */ 701, 934, 934, 934, 934, 934, 934, 934, 626, 733,
- /* 200 */ 659, 743, 934, 934, 934, 646, 722, 886, 934, 900,
- /* 210 */ 898, 724, 786, 934, 733, 742, 934, 934, 934, 849,
- /* 220 */ 770, 770, 758, 770, 680, 770, 934, 770, 934, 683,
- /* 230 */ 780, 758, 758, 780, 623, 623, 623, 623, 634, 634,
- /* 240 */ 700, 934, 780, 771, 773, 763, 775, 934, 749, 749,
- /* 250 */ 757, 762, 757, 762, 757, 762, 712, 712, 697, 712,
- /* 260 */ 683, 712, 859, 863, 863, 697, 712, 712, 712, 859,
- /* 270 */ 641, 749, 641, 749, 641, 749, 749, 890, 892, 641,
- /* 280 */ 749, 714, 714, 792, 780, 749, 721, 721, 721, 721,
- /* 290 */ 780, 714, 792, 749, 912, 912, 749, 749, 920, 667,
- /* 300 */ 685, 685, 927, 932, 934, 934, 934, 934, 934, 934,
- /* 310 */ 934, 934, 934, 934, 934, 934, 934, 934, 934, 934,
- /* 320 */ 934, 873, 934, 934, 934, 632, 934, 651, 799, 804,
- /* 330 */ 800, 934, 801, 934, 727, 934, 934, 934, 934, 934,
- /* 340 */ 934, 934, 934, 934, 934, 852, 934, 764, 934, 772,
- /* 350 */ 934, 934, 934, 934, 934, 934, 934, 934, 934, 934,
- /* 360 */ 934, 934, 934, 934, 934, 934, 934, 934, 934, 934,
- /* 370 */ 934, 934, 934, 934, 934, 888, 889, 934, 934, 934,
- /* 380 */ 934, 934, 934, 934, 934, 934, 934, 934, 934, 934,
- /* 390 */ 934, 934, 934, 934, 934, 934, 934, 934, 934, 934,
- /* 400 */ 919, 934, 934, 922, 619, 934, 614, 616, 617, 621,
- /* 410 */ 622, 625, 651, 652, 654, 655, 656, 627, 628, 629,
- /* 420 */ 630, 631, 633, 637, 635, 636, 638, 645, 647, 666,
- /* 430 */ 668, 670, 731, 732, 796, 725, 726, 730, 653, 807,
- /* 440 */ 798, 802, 803, 805, 806, 820, 821, 823, 829, 836,
- /* 450 */ 839, 822, 827, 828, 830, 835, 838, 728, 729, 842,
- /* 460 */ 660, 661, 664, 665, 876, 878, 877, 879, 663, 662,
- /* 470 */ 808, 811, 844, 845, 901, 902, 903, 904, 905, 840,
- /* 480 */ 750, 843, 826, 765, 768, 769, 766, 734, 744, 752,
- /* 490 */ 753, 754, 755, 739, 740, 746, 761, 794, 795, 759,
- /* 500 */ 760, 747, 748, 736, 737, 738, 841, 797, 809, 810,
- /* 510 */ 671, 672, 804, 673, 674, 675, 713, 716, 717, 718,
- /* 520 */ 676, 695, 698, 699, 677, 684, 678, 679, 686, 687,
- /* 530 */ 688, 691, 692, 693, 694, 689, 690, 860, 861, 864,
- /* 540 */ 862, 681, 682, 696, 669, 658, 650, 702, 705, 706,
- /* 550 */ 707, 708, 709, 711, 703, 704, 648, 639, 642, 751,
- /* 560 */ 882, 891, 887, 883, 884, 885, 643, 856, 857, 715,
- /* 570 */ 788, 789, 881, 894, 896, 793, 897, 899, 895, 924,
- /* 580 */ 640, 719, 720, 723, 865, 906, 779, 782, 785, 787,
- /* 590 */ 867, 868, 869, 870, 871, 874, 875, 872, 907, 911,
- /* 600 */ 914, 916, 917, 918, 921, 923, 928, 929, 930, 933,
- /* 610 */ 931, 620, 615,
+ /* 0 */ 621, 856, 939, 939, 856, 939, 939, 885, 885, 744,
+ /* 10 */ 854, 939, 939, 939, 939, 939, 939, 914, 939, 939,
+ /* 20 */ 939, 939, 939, 939, 939, 939, 939, 939, 939, 939,
+ /* 30 */ 939, 939, 939, 939, 939, 939, 939, 939, 939, 939,
+ /* 40 */ 939, 939, 939, 939, 939, 939, 939, 939, 939, 939,
+ /* 50 */ 939, 939, 939, 939, 939, 939, 939, 939, 939, 828,
+ /* 60 */ 939, 939, 939, 660, 885, 885, 748, 779, 939, 939,
+ /* 70 */ 939, 939, 939, 939, 939, 939, 780, 939, 858, 853,
+ /* 80 */ 849, 851, 850, 857, 781, 770, 777, 784, 759, 898,
+ /* 90 */ 786, 787, 793, 794, 915, 913, 816, 815, 834, 818,
+ /* 100 */ 840, 817, 827, 652, 819, 820, 939, 939, 939, 939,
+ /* 110 */ 939, 713, 647, 939, 939, 939, 939, 939, 939, 939,
+ /* 120 */ 939, 939, 939, 939, 939, 939, 821, 939, 822, 835,
+ /* 130 */ 836, 837, 939, 939, 939, 939, 939, 939, 939, 939,
+ /* 140 */ 939, 627, 939, 939, 939, 939, 939, 939, 939, 939,
+ /* 150 */ 939, 939, 939, 939, 939, 939, 939, 939, 939, 939,
+ /* 160 */ 939, 939, 939, 939, 939, 939, 939, 939, 939, 869,
+ /* 170 */ 939, 918, 920, 939, 939, 939, 621, 744, 744, 744,
+ /* 180 */ 939, 939, 939, 939, 939, 738, 748, 932, 939, 939,
+ /* 190 */ 704, 939, 939, 939, 939, 939, 939, 939, 629, 736,
+ /* 200 */ 662, 746, 939, 939, 939, 649, 725, 891, 939, 905,
+ /* 210 */ 903, 727, 789, 939, 736, 745, 939, 939, 939, 852,
+ /* 220 */ 773, 773, 761, 773, 683, 773, 939, 773, 939, 686,
+ /* 230 */ 783, 761, 761, 783, 626, 626, 626, 626, 637, 637,
+ /* 240 */ 703, 939, 783, 774, 776, 766, 778, 939, 752, 752,
+ /* 250 */ 760, 765, 760, 765, 760, 765, 715, 715, 700, 715,
+ /* 260 */ 686, 715, 862, 866, 866, 700, 715, 715, 715, 862,
+ /* 270 */ 644, 752, 644, 752, 644, 752, 752, 895, 897, 644,
+ /* 280 */ 752, 717, 717, 795, 783, 752, 724, 724, 724, 724,
+ /* 290 */ 783, 717, 795, 752, 917, 917, 752, 752, 925, 670,
+ /* 300 */ 688, 688, 932, 937, 939, 939, 939, 939, 939, 939,
+ /* 310 */ 939, 939, 939, 939, 939, 939, 939, 939, 939, 939,
+ /* 320 */ 939, 871, 939, 939, 939, 635, 939, 654, 802, 807,
+ /* 330 */ 803, 939, 804, 939, 730, 939, 939, 939, 939, 939,
+ /* 340 */ 939, 939, 939, 939, 939, 855, 939, 767, 939, 775,
+ /* 350 */ 939, 939, 939, 939, 939, 939, 939, 939, 939, 939,
+ /* 360 */ 939, 939, 939, 939, 939, 939, 939, 939, 939, 939,
+ /* 370 */ 939, 939, 939, 939, 939, 893, 894, 939, 939, 939,
+ /* 380 */ 939, 939, 939, 939, 939, 939, 939, 939, 939, 939,
+ /* 390 */ 939, 939, 939, 939, 939, 939, 939, 939, 939, 939,
+ /* 400 */ 939, 924, 939, 939, 927, 622, 939, 617, 619, 620,
+ /* 410 */ 624, 625, 628, 654, 655, 657, 658, 659, 630, 631,
+ /* 420 */ 632, 633, 634, 636, 640, 638, 639, 641, 648, 650,
+ /* 430 */ 669, 671, 673, 734, 735, 799, 728, 729, 733, 656,
+ /* 440 */ 810, 801, 805, 806, 808, 809, 823, 824, 826, 832,
+ /* 450 */ 839, 842, 825, 830, 831, 833, 838, 841, 731, 732,
+ /* 460 */ 845, 663, 664, 667, 668, 881, 883, 882, 884, 666,
+ /* 470 */ 665, 811, 814, 847, 848, 906, 907, 908, 909, 910,
+ /* 480 */ 843, 753, 846, 829, 768, 771, 772, 769, 737, 747,
+ /* 490 */ 755, 756, 757, 758, 742, 743, 749, 764, 797, 798,
+ /* 500 */ 762, 763, 750, 751, 739, 740, 741, 844, 800, 812,
+ /* 510 */ 813, 674, 675, 807, 676, 677, 678, 716, 719, 720,
+ /* 520 */ 721, 679, 698, 701, 702, 680, 687, 681, 682, 689,
+ /* 530 */ 690, 691, 694, 695, 696, 697, 692, 693, 863, 864,
+ /* 540 */ 867, 865, 684, 685, 699, 672, 661, 653, 705, 708,
+ /* 550 */ 709, 710, 711, 712, 714, 706, 707, 651, 642, 645,
+ /* 560 */ 754, 887, 896, 892, 888, 889, 890, 646, 859, 860,
+ /* 570 */ 718, 791, 792, 886, 899, 901, 796, 902, 904, 900,
+ /* 580 */ 929, 643, 722, 723, 726, 868, 911, 782, 785, 788,
+ /* 590 */ 790, 870, 872, 874, 876, 877, 878, 879, 880, 873,
+ /* 600 */ 875, 912, 916, 919, 921, 922, 923, 926, 928, 933,
+ /* 610 */ 934, 935, 938, 936, 623, 618,
};
#define YY_SZ_ACTTAB (int)(sizeof(yy_action)/sizeof(yy_action[0]))
/* 252 */ "cmd ::= DROP INDEX ifexists fullname",
/* 253 */ "cmd ::= VACUUM",
/* 254 */ "cmd ::= VACUUM nm",
- /* 255 */ "cmd ::= PRAGMA nm dbnm EQ nmnum",
- /* 256 */ "cmd ::= PRAGMA nm dbnm EQ ON",
- /* 257 */ "cmd ::= PRAGMA nm dbnm EQ DELETE",
+ /* 255 */ "cmd ::= PRAGMA nm dbnm",
+ /* 256 */ "cmd ::= PRAGMA nm dbnm EQ nmnum",
+ /* 257 */ "cmd ::= PRAGMA nm dbnm LP nmnum RP",
/* 258 */ "cmd ::= PRAGMA nm dbnm EQ minus_num",
- /* 259 */ "cmd ::= PRAGMA nm dbnm LP nmnum RP",
- /* 260 */ "cmd ::= PRAGMA nm dbnm",
- /* 261 */ "nmnum ::= plus_num",
- /* 262 */ "nmnum ::= nm",
- /* 263 */ "plus_num ::= plus_opt number",
- /* 264 */ "minus_num ::= MINUS number",
- /* 265 */ "number ::= INTEGER|FLOAT",
- /* 266 */ "plus_opt ::= PLUS",
- /* 267 */ "plus_opt ::=",
- /* 268 */ "cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END",
- /* 269 */ "trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause",
- /* 270 */ "trigger_time ::= BEFORE",
- /* 271 */ "trigger_time ::= AFTER",
- /* 272 */ "trigger_time ::= INSTEAD OF",
- /* 273 */ "trigger_time ::=",
- /* 274 */ "trigger_event ::= DELETE|INSERT",
- /* 275 */ "trigger_event ::= UPDATE",
- /* 276 */ "trigger_event ::= UPDATE OF inscollist",
- /* 277 */ "foreach_clause ::=",
- /* 278 */ "foreach_clause ::= FOR EACH ROW",
- /* 279 */ "when_clause ::=",
- /* 280 */ "when_clause ::= WHEN expr",
- /* 281 */ "trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI",
- /* 282 */ "trigger_cmd_list ::= trigger_cmd SEMI",
- /* 283 */ "trigger_cmd ::= UPDATE orconf nm SET setlist where_opt",
- /* 284 */ "trigger_cmd ::= insert_cmd INTO nm inscollist_opt VALUES LP itemlist RP",
- /* 285 */ "trigger_cmd ::= insert_cmd INTO nm inscollist_opt select",
- /* 286 */ "trigger_cmd ::= DELETE FROM nm where_opt",
- /* 287 */ "trigger_cmd ::= select",
- /* 288 */ "expr ::= RAISE LP IGNORE RP",
- /* 289 */ "expr ::= RAISE LP raisetype COMMA nm RP",
- /* 290 */ "raisetype ::= ROLLBACK",
- /* 291 */ "raisetype ::= ABORT",
- /* 292 */ "raisetype ::= FAIL",
- /* 293 */ "cmd ::= DROP TRIGGER ifexists fullname",
- /* 294 */ "cmd ::= ATTACH database_kw_opt expr AS expr key_opt",
- /* 295 */ "cmd ::= DETACH database_kw_opt expr",
- /* 296 */ "key_opt ::=",
- /* 297 */ "key_opt ::= KEY expr",
- /* 298 */ "database_kw_opt ::= DATABASE",
- /* 299 */ "database_kw_opt ::=",
- /* 300 */ "cmd ::= REINDEX",
- /* 301 */ "cmd ::= REINDEX nm dbnm",
- /* 302 */ "cmd ::= ANALYZE",
- /* 303 */ "cmd ::= ANALYZE nm dbnm",
- /* 304 */ "cmd ::= ALTER TABLE fullname RENAME TO nm",
- /* 305 */ "cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt column",
- /* 306 */ "add_column_fullname ::= fullname",
- /* 307 */ "kwcolumn_opt ::=",
- /* 308 */ "kwcolumn_opt ::= COLUMNKW",
- /* 309 */ "cmd ::= create_vtab",
- /* 310 */ "cmd ::= create_vtab LP vtabarglist RP",
- /* 311 */ "create_vtab ::= createkw VIRTUAL TABLE nm dbnm USING nm",
- /* 312 */ "vtabarglist ::= vtabarg",
- /* 313 */ "vtabarglist ::= vtabarglist COMMA vtabarg",
- /* 314 */ "vtabarg ::=",
- /* 315 */ "vtabarg ::= vtabarg vtabargtoken",
- /* 316 */ "vtabargtoken ::= ANY",
- /* 317 */ "vtabargtoken ::= lp anylist RP",
- /* 318 */ "lp ::= LP",
- /* 319 */ "anylist ::=",
- /* 320 */ "anylist ::= anylist ANY",
+ /* 259 */ "cmd ::= PRAGMA nm dbnm LP minus_num RP",
+ /* 260 */ "nmnum ::= plus_num",
+ /* 261 */ "nmnum ::= nm",
+ /* 262 */ "nmnum ::= ON",
+ /* 263 */ "nmnum ::= DELETE",
+ /* 264 */ "nmnum ::= DEFAULT",
+ /* 265 */ "plus_num ::= plus_opt number",
+ /* 266 */ "minus_num ::= MINUS number",
+ /* 267 */ "number ::= INTEGER|FLOAT",
+ /* 268 */ "plus_opt ::= PLUS",
+ /* 269 */ "plus_opt ::=",
+ /* 270 */ "cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END",
+ /* 271 */ "trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause",
+ /* 272 */ "trigger_time ::= BEFORE",
+ /* 273 */ "trigger_time ::= AFTER",
+ /* 274 */ "trigger_time ::= INSTEAD OF",
+ /* 275 */ "trigger_time ::=",
+ /* 276 */ "trigger_event ::= DELETE|INSERT",
+ /* 277 */ "trigger_event ::= UPDATE",
+ /* 278 */ "trigger_event ::= UPDATE OF inscollist",
+ /* 279 */ "foreach_clause ::=",
+ /* 280 */ "foreach_clause ::= FOR EACH ROW",
+ /* 281 */ "when_clause ::=",
+ /* 282 */ "when_clause ::= WHEN expr",
+ /* 283 */ "trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI",
+ /* 284 */ "trigger_cmd_list ::= trigger_cmd SEMI",
+ /* 285 */ "trigger_cmd ::= UPDATE orconf nm SET setlist where_opt",
+ /* 286 */ "trigger_cmd ::= insert_cmd INTO nm inscollist_opt VALUES LP itemlist RP",
+ /* 287 */ "trigger_cmd ::= insert_cmd INTO nm inscollist_opt select",
+ /* 288 */ "trigger_cmd ::= DELETE FROM nm where_opt",
+ /* 289 */ "trigger_cmd ::= select",
+ /* 290 */ "expr ::= RAISE LP IGNORE RP",
+ /* 291 */ "expr ::= RAISE LP raisetype COMMA nm RP",
+ /* 292 */ "raisetype ::= ROLLBACK",
+ /* 293 */ "raisetype ::= ABORT",
+ /* 294 */ "raisetype ::= FAIL",
+ /* 295 */ "cmd ::= DROP TRIGGER ifexists fullname",
+ /* 296 */ "cmd ::= ATTACH database_kw_opt expr AS expr key_opt",
+ /* 297 */ "cmd ::= DETACH database_kw_opt expr",
+ /* 298 */ "key_opt ::=",
+ /* 299 */ "key_opt ::= KEY expr",
+ /* 300 */ "database_kw_opt ::= DATABASE",
+ /* 301 */ "database_kw_opt ::=",
+ /* 302 */ "cmd ::= REINDEX",
+ /* 303 */ "cmd ::= REINDEX nm dbnm",
+ /* 304 */ "cmd ::= ANALYZE",
+ /* 305 */ "cmd ::= ANALYZE nm dbnm",
+ /* 306 */ "cmd ::= ALTER TABLE fullname RENAME TO nm",
+ /* 307 */ "cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt column",
+ /* 308 */ "add_column_fullname ::= fullname",
+ /* 309 */ "kwcolumn_opt ::=",
+ /* 310 */ "kwcolumn_opt ::= COLUMNKW",
+ /* 311 */ "cmd ::= create_vtab",
+ /* 312 */ "cmd ::= create_vtab LP vtabarglist RP",
+ /* 313 */ "create_vtab ::= createkw VIRTUAL TABLE nm dbnm USING nm",
+ /* 314 */ "vtabarglist ::= vtabarg",
+ /* 315 */ "vtabarglist ::= vtabarglist COMMA vtabarg",
+ /* 316 */ "vtabarg ::=",
+ /* 317 */ "vtabarg ::= vtabarg vtabargtoken",
+ /* 318 */ "vtabargtoken ::= ANY",
+ /* 319 */ "vtabargtoken ::= lp anylist RP",
+ /* 320 */ "lp ::= LP",
+ /* 321 */ "anylist ::=",
+ /* 322 */ "anylist ::= anylist ANY",
};
#endif /* NDEBUG */
{ 147, 4 },
{ 147, 1 },
{ 147, 2 },
+ { 147, 3 },
{ 147, 5 },
- { 147, 5 },
- { 147, 5 },
+ { 147, 6 },
{ 147, 5 },
{ 147, 6 },
- { 147, 3 },
+ { 231, 1 },
+ { 231, 1 },
+ { 231, 1 },
{ 231, 1 },
{ 231, 1 },
{ 170, 2 },
case 90: /* conslist ::= conslist tcons */
case 91: /* conslist ::= tcons */
case 92: /* tcons ::= CONSTRAINT nm */
- case 266: /* plus_opt ::= PLUS */
- case 267: /* plus_opt ::= */
- case 277: /* foreach_clause ::= */
- case 278: /* foreach_clause ::= FOR EACH ROW */
- case 298: /* database_kw_opt ::= DATABASE */
- case 299: /* database_kw_opt ::= */
- case 307: /* kwcolumn_opt ::= */
- case 308: /* kwcolumn_opt ::= COLUMNKW */
- case 312: /* vtabarglist ::= vtabarg */
- case 313: /* vtabarglist ::= vtabarglist COMMA vtabarg */
- case 315: /* vtabarg ::= vtabarg vtabargtoken */
- case 319: /* anylist ::= */
+ case 268: /* plus_opt ::= PLUS */
+ case 269: /* plus_opt ::= */
+ case 279: /* foreach_clause ::= */
+ case 280: /* foreach_clause ::= FOR EACH ROW */
+ case 300: /* database_kw_opt ::= DATABASE */
+ case 301: /* database_kw_opt ::= */
+ case 309: /* kwcolumn_opt ::= */
+ case 310: /* kwcolumn_opt ::= COLUMNKW */
+ case 314: /* vtabarglist ::= vtabarg */
+ case 315: /* vtabarglist ::= vtabarglist COMMA vtabarg */
+ case 317: /* vtabarg ::= vtabarg vtabargtoken */
+ case 321: /* anylist ::= */
{
}
break;
case 137: /* dbnm ::= DOT nm */
case 146: /* indexed_opt ::= INDEXED BY nm */
case 251: /* collate ::= COLLATE ids */
- case 261: /* nmnum ::= plus_num */
- case 262: /* nmnum ::= nm */
- case 263: /* plus_num ::= plus_opt number */
- case 264: /* minus_num ::= MINUS number */
- case 265: /* number ::= INTEGER|FLOAT */
+ case 260: /* nmnum ::= plus_num */
+ case 261: /* nmnum ::= nm */
+ case 262: /* nmnum ::= ON */
+ case 263: /* nmnum ::= DELETE */
+ case 264: /* nmnum ::= DEFAULT */
+ case 265: /* plus_num ::= plus_opt number */
+ case 266: /* minus_num ::= MINUS number */
+ case 267: /* number ::= INTEGER|FLOAT */
{yygotominor.yy0 = yymsp[0].minor.yy0;}
break;
case 45: /* type ::= typetoken */
}
break;
case 244: /* uniqueflag ::= UNIQUE */
- case 291: /* raisetype ::= ABORT */
+ case 293: /* raisetype ::= ABORT */
{yygotominor.yy194 = OE_Abort;}
break;
case 245: /* uniqueflag ::= */
case 254: /* cmd ::= VACUUM nm */
{sqlite3Vacuum(pParse);}
break;
- case 255: /* cmd ::= PRAGMA nm dbnm EQ nmnum */
- case 256: /* cmd ::= PRAGMA nm dbnm EQ ON */
- case 257: /* cmd ::= PRAGMA nm dbnm EQ DELETE */
-{sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,0);}
+ case 255: /* cmd ::= PRAGMA nm dbnm */
+{sqlite3Pragma(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,0,0);}
break;
- case 258: /* cmd ::= PRAGMA nm dbnm EQ minus_num */
-{
- sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,1);
-}
+ case 256: /* cmd ::= PRAGMA nm dbnm EQ nmnum */
+{sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,0);}
break;
- case 259: /* cmd ::= PRAGMA nm dbnm LP nmnum RP */
+ case 257: /* cmd ::= PRAGMA nm dbnm LP nmnum RP */
{sqlite3Pragma(pParse,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,0);}
break;
- case 260: /* cmd ::= PRAGMA nm dbnm */
-{sqlite3Pragma(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,0,0);}
+ case 258: /* cmd ::= PRAGMA nm dbnm EQ minus_num */
+{sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,1);}
break;
- case 268: /* cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
+ case 259: /* cmd ::= PRAGMA nm dbnm LP minus_num RP */
+{sqlite3Pragma(pParse,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,1);}
+ break;
+ case 270: /* cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
{
Token all;
all.z = yymsp[-3].minor.yy0.z;
sqlite3FinishTrigger(pParse, yymsp[-1].minor.yy145, &all);
}
break;
- case 269: /* trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
+ case 271: /* trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
{
sqlite3BeginTrigger(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0, yymsp[-5].minor.yy194, yymsp[-4].minor.yy332.a, yymsp[-4].minor.yy332.b, yymsp[-2].minor.yy185, yymsp[0].minor.yy72, yymsp[-10].minor.yy194, yymsp[-8].minor.yy194);
yygotominor.yy0 = (yymsp[-6].minor.yy0.n==0?yymsp[-7].minor.yy0:yymsp[-6].minor.yy0);
}
break;
- case 270: /* trigger_time ::= BEFORE */
- case 273: /* trigger_time ::= */
+ case 272: /* trigger_time ::= BEFORE */
+ case 275: /* trigger_time ::= */
{ yygotominor.yy194 = TK_BEFORE; }
break;
- case 271: /* trigger_time ::= AFTER */
+ case 273: /* trigger_time ::= AFTER */
{ yygotominor.yy194 = TK_AFTER; }
break;
- case 272: /* trigger_time ::= INSTEAD OF */
+ case 274: /* trigger_time ::= INSTEAD OF */
{ yygotominor.yy194 = TK_INSTEAD;}
break;
- case 274: /* trigger_event ::= DELETE|INSERT */
- case 275: /* trigger_event ::= UPDATE */
+ case 276: /* trigger_event ::= DELETE|INSERT */
+ case 277: /* trigger_event ::= UPDATE */
{yygotominor.yy332.a = yymsp[0].major; yygotominor.yy332.b = 0;}
break;
- case 276: /* trigger_event ::= UPDATE OF inscollist */
+ case 278: /* trigger_event ::= UPDATE OF inscollist */
{yygotominor.yy332.a = TK_UPDATE; yygotominor.yy332.b = yymsp[0].minor.yy254;}
break;
- case 279: /* when_clause ::= */
- case 296: /* key_opt ::= */
+ case 281: /* when_clause ::= */
+ case 298: /* key_opt ::= */
{ yygotominor.yy72 = 0; }
break;
- case 280: /* when_clause ::= WHEN expr */
- case 297: /* key_opt ::= KEY expr */
+ case 282: /* when_clause ::= WHEN expr */
+ case 299: /* key_opt ::= KEY expr */
{ yygotominor.yy72 = yymsp[0].minor.yy72; }
break;
- case 281: /* trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
+ case 283: /* trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
{
/*
if( yymsp[-2].minor.yy145 ){
yygotominor.yy145 = yymsp[-2].minor.yy145;
}
break;
- case 282: /* trigger_cmd_list ::= trigger_cmd SEMI */
+ case 284: /* trigger_cmd_list ::= trigger_cmd SEMI */
{
/* if( yymsp[-1].minor.yy145 ) */
assert( yymsp[-1].minor.yy145!=0 );
yygotominor.yy145 = yymsp[-1].minor.yy145;
}
break;
- case 283: /* trigger_cmd ::= UPDATE orconf nm SET setlist where_opt */
+ case 285: /* trigger_cmd ::= UPDATE orconf nm SET setlist where_opt */
{ yygotominor.yy145 = sqlite3TriggerUpdateStep(pParse->db, &yymsp[-3].minor.yy0, yymsp[-1].minor.yy148, yymsp[0].minor.yy72, yymsp[-4].minor.yy194); }
break;
- case 284: /* trigger_cmd ::= insert_cmd INTO nm inscollist_opt VALUES LP itemlist RP */
+ case 286: /* trigger_cmd ::= insert_cmd INTO nm inscollist_opt VALUES LP itemlist RP */
{yygotominor.yy145 = sqlite3TriggerInsertStep(pParse->db, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy254, yymsp[-1].minor.yy148, 0, yymsp[-7].minor.yy194);}
break;
- case 285: /* trigger_cmd ::= insert_cmd INTO nm inscollist_opt select */
+ case 287: /* trigger_cmd ::= insert_cmd INTO nm inscollist_opt select */
{yygotominor.yy145 = sqlite3TriggerInsertStep(pParse->db, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy254, 0, yymsp[0].minor.yy243, yymsp[-4].minor.yy194);}
break;
- case 286: /* trigger_cmd ::= DELETE FROM nm where_opt */
+ case 288: /* trigger_cmd ::= DELETE FROM nm where_opt */
{yygotominor.yy145 = sqlite3TriggerDeleteStep(pParse->db, &yymsp[-1].minor.yy0, yymsp[0].minor.yy72);}
break;
- case 287: /* trigger_cmd ::= select */
+ case 289: /* trigger_cmd ::= select */
{yygotominor.yy145 = sqlite3TriggerSelectStep(pParse->db, yymsp[0].minor.yy243); }
break;
- case 288: /* expr ::= RAISE LP IGNORE RP */
+ case 290: /* expr ::= RAISE LP IGNORE RP */
{
yygotominor.yy72 = sqlite3PExpr(pParse, TK_RAISE, 0, 0, 0);
if( yygotominor.yy72 ){
}
}
break;
- case 289: /* expr ::= RAISE LP raisetype COMMA nm RP */
+ case 291: /* expr ::= RAISE LP raisetype COMMA nm RP */
{
yygotominor.yy72 = sqlite3PExpr(pParse, TK_RAISE, 0, 0, &yymsp[-1].minor.yy0);
if( yygotominor.yy72 ) {
}
}
break;
- case 290: /* raisetype ::= ROLLBACK */
+ case 292: /* raisetype ::= ROLLBACK */
{yygotominor.yy194 = OE_Rollback;}
break;
- case 292: /* raisetype ::= FAIL */
+ case 294: /* raisetype ::= FAIL */
{yygotominor.yy194 = OE_Fail;}
break;
- case 293: /* cmd ::= DROP TRIGGER ifexists fullname */
+ case 295: /* cmd ::= DROP TRIGGER ifexists fullname */
{
sqlite3DropTrigger(pParse,yymsp[0].minor.yy185,yymsp[-1].minor.yy194);
}
break;
- case 294: /* cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
+ case 296: /* cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
{
sqlite3Attach(pParse, yymsp[-3].minor.yy72, yymsp[-1].minor.yy72, yymsp[0].minor.yy72);
}
break;
- case 295: /* cmd ::= DETACH database_kw_opt expr */
+ case 297: /* cmd ::= DETACH database_kw_opt expr */
{
sqlite3Detach(pParse, yymsp[0].minor.yy72);
}
break;
- case 300: /* cmd ::= REINDEX */
+ case 302: /* cmd ::= REINDEX */
{sqlite3Reindex(pParse, 0, 0);}
break;
- case 301: /* cmd ::= REINDEX nm dbnm */
+ case 303: /* cmd ::= REINDEX nm dbnm */
{sqlite3Reindex(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);}
break;
- case 302: /* cmd ::= ANALYZE */
+ case 304: /* cmd ::= ANALYZE */
{sqlite3Analyze(pParse, 0, 0);}
break;
- case 303: /* cmd ::= ANALYZE nm dbnm */
+ case 305: /* cmd ::= ANALYZE nm dbnm */
{sqlite3Analyze(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);}
break;
- case 304: /* cmd ::= ALTER TABLE fullname RENAME TO nm */
+ case 306: /* cmd ::= ALTER TABLE fullname RENAME TO nm */
{
sqlite3AlterRenameTable(pParse,yymsp[-3].minor.yy185,&yymsp[0].minor.yy0);
}
break;
- case 305: /* cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt column */
+ case 307: /* cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt column */
{
sqlite3AlterFinishAddColumn(pParse, &yymsp[0].minor.yy0);
}
break;
- case 306: /* add_column_fullname ::= fullname */
+ case 308: /* add_column_fullname ::= fullname */
{
pParse->db->lookaside.bEnabled = 0;
sqlite3AlterBeginAddColumn(pParse, yymsp[0].minor.yy185);
}
break;
- case 309: /* cmd ::= create_vtab */
+ case 311: /* cmd ::= create_vtab */
{sqlite3VtabFinishParse(pParse,0);}
break;
- case 310: /* cmd ::= create_vtab LP vtabarglist RP */
+ case 312: /* cmd ::= create_vtab LP vtabarglist RP */
{sqlite3VtabFinishParse(pParse,&yymsp[0].minor.yy0);}
break;
- case 311: /* create_vtab ::= createkw VIRTUAL TABLE nm dbnm USING nm */
+ case 313: /* create_vtab ::= createkw VIRTUAL TABLE nm dbnm USING nm */
{
sqlite3VtabBeginParse(pParse, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
}
break;
- case 314: /* vtabarg ::= */
+ case 316: /* vtabarg ::= */
{sqlite3VtabArgInit(pParse);}
break;
- case 316: /* vtabargtoken ::= ANY */
- case 317: /* vtabargtoken ::= lp anylist RP */
- case 318: /* lp ::= LP */
- case 320: /* anylist ::= anylist ANY */
+ case 318: /* vtabargtoken ::= ANY */
+ case 319: /* vtabargtoken ::= lp anylist RP */
+ case 320: /* lp ::= LP */
+ case 322: /* anylist ::= anylist ANY */
{sqlite3VtabArgExtend(pParse,&yymsp[0].minor.yy0);}
break;
};
if( sqlite3GlobalConfig.isInit ){
sqlite3_os_end();
}
+ sqlite3_reset_auto_extension();
sqlite3MallocEnd();
sqlite3MutexEnd();
sqlite3GlobalConfig.isInit = 0;
if( pStart ){
int i;
LookasideSlot *p;
- assert( sz > sizeof(LookasideSlot*) );
+ assert( sz > (int)sizeof(LookasideSlot*) );
p = (LookasideSlot*)pStart;
for(i=cnt-1; i>=0; i--){
p->pNext = db->lookaside.pFree;
/*
** Obtain the STATIC_MASTER mutex.
*/
-static void enterMutex(){
+static void enterMutex(void){
sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
checkListProperties(0);
}
/*
** Release the STATIC_MASTER mutex.
*/
-static void leaveMutex(){
+static void leaveMutex(void){
assertMutexHeld();
checkListProperties(0);
sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
/*
** Register an unlock-notify callback.
+**
+** This is called after connection "db" has attempted some operation
+** but has received an SQLITE_LOCKED error because another connection
+** (call it pOther) in the same process was busy using the same shared
+** cache. pOther is found by looking at db->pBlockingConnection.
+**
+** If there is no blocking connection, the callback is invoked immediately,
+** before this routine returns.
+**
+** If pOther is already blocked on db, then report SQLITE_LOCKED, to indicate
+** a deadlock.
+**
+** Otherwise, make arrangements to invoke xNotify when pOther drops
+** its locks.
+**
+** Each call to this routine overrides any prior callbacks registered
+** on the same "db". If xNotify==0 then any prior callbacks are immediately
+** cancelled.
*/
SQLITE_API int sqlite3_unlock_notify(
sqlite3 *db,
sqlite3_mutex_enter(db->mutex);
enterMutex();
- if( 0==db->pBlockingConnection ){
+ if( xNotify==0 ){
+ removeFromBlockedList(db);
+ db->pUnlockConnection = 0;
+ db->xUnlockNotify = 0;
+ db->pUnlockArg = 0;
+ }else if( 0==db->pBlockingConnection ){
/* The blocking transaction has been concluded. Or there never was a
** blocking transaction. In either case, invoke the notify callback
** immediately.
}else{
sqlite3 *p;
- for(p=db->pBlockingConnection; p && p!=db; p=p->pUnlockConnection);
+ for(p=db->pBlockingConnection; p && p!=db; p=p->pUnlockConnection){}
if( p ){
rc = SQLITE_LOCKED; /* Deadlock detected. */
}else{
}
/*
-** The transaction opened by database db has just finished. Locks held
+** This function is called when
+** the transaction opened by database db has just finished. Locks held
** by database connection db have been released.
**
** This function loops through each entry in the blocked connections
void (*xUnlockNotify)(void **, int) = 0; /* Unlock-notify cb to invoke */
int nArg = 0; /* Number of entries in aArg[] */
sqlite3 **pp; /* Iterator variable */
+ void **aArg; /* Arguments to the unlock callback */
+ void **aDyn = 0; /* Dynamically allocated space for aArg[] */
+ void *aStatic[16]; /* Starter space for aArg[]. No malloc required */
- void *aStatic[16];
- void **aArg = aStatic;
- void **aDyn = 0;
-
+ aArg = aStatic;
enterMutex(); /* Enter STATIC_MASTER mutex */
/* This loop runs once for each entry in the blocked-connections list. */
projects / php / commitdiff