Many hyperlinks are disabled.
Use anonymous login
to enable hyperlinks.
Overview
Comment: | More optimizations. (CVS 816) |
---|---|
Downloads: | Tarball | ZIP archive |
Timelines: | family | ancestors | descendants | both | trunk |
Files: | files | file ages | folders |
SHA1: |
a362981b20fd33254ad498619eedf75b |
User & Date: | drh 2003-01-07 02:47:48.000 |
Context
2003-01-07
| ||
13:43 | When constructing records and index keys, use static string space rather than mallocing (when possible) for a small speed improvement. (CVS 817) (check-in: 657c9fb513 user: drh tags: trunk) | |
02:47 | More optimizations. (CVS 816) (check-in: a362981b20 user: drh tags: trunk) | |
01:44 | Optimizations to the tokenizer. (CVS 815) (check-in: 032b3daa1d user: drh tags: trunk) | |
Changes
Changes to src/parse.y.
︙ | ︙ | |||
10 11 12 13 14 15 16 | ** ************************************************************************* ** This file contains SQLite's grammar for SQL. Process this file ** using the lemon parser generator to generate C code that runs ** the parser. Lemon will also generate a header file containing ** numeric codes for all of the tokens. ** | | | 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 | ** ************************************************************************* ** This file contains SQLite's grammar for SQL. Process this file ** using the lemon parser generator to generate C code that runs ** the parser. Lemon will also generate a header file containing ** numeric codes for all of the tokens. ** ** @(#) $Id: parse.y,v 1.86 2003/01/07 02:47:48 drh Exp $ */ %token_prefix TK_ %token_type {Token} %default_type {Token} %extra_argument {Parse *pParse} %syntax_error { sqliteSetString(&pParse->zErrMsg,"syntax error",0); |
︙ | ︙ | |||
44 45 46 47 48 49 50 | ** TK_DELETE, or TK_INSTEAD. If the event is of the form ** ** UPDATE ON (a,b,c) ** ** Then the "b" IdList records the list "a,b,c". */ struct TrigEvent { int a; IdList * b; }; | | > | 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 | ** TK_DELETE, or TK_INSTEAD. If the event is of the form ** ** UPDATE ON (a,b,c) ** ** Then the "b" IdList records the list "a,b,c". */ struct TrigEvent { int a; IdList * b; }; } // end %include // These are extra tokens used by the lexer but never seen by the // parser. We put them in a rule so that the parser generator will // add them to the parse.h output file. // %nonassoc END_OF_FILE ILLEGAL SPACE UNCLOSED_STRING COMMENT FUNCTION COLUMN AGG_FUNCTION. |
︙ | ︙ |
Changes to src/tokenize.c.
︙ | ︙ | |||
11 12 13 14 15 16 17 | ************************************************************************* ** An tokenizer for SQL ** ** This file contains C code that splits an SQL input string up into ** individual tokens and sends those tokens one-by-one over to the ** parser for analysis. ** | | | 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 | ************************************************************************* ** An tokenizer for SQL ** ** This file contains C code that splits an SQL input string up into ** individual tokens and sends those tokens one-by-one over to the ** parser for analysis. ** ** $Id: tokenize.c,v 1.53 2003/01/07 02:47:48 drh Exp $ */ #include "sqliteInt.h" #include "os.h" #include <ctype.h> #include <stdlib.h> /* |
︙ | ︙ | |||
438 439 440 441 442 443 444 | } break; } case TK_ILLEGAL: { sqliteSetNString(pzErrMsg, "unrecognized token: \"", -1, pParse->sLastToken.z, pParse->sLastToken.n, "\"", 1, 0); nErr++; | | | 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 | } break; } case TK_ILLEGAL: { sqliteSetNString(pzErrMsg, "unrecognized token: \"", -1, pParse->sLastToken.z, pParse->sLastToken.n, "\"", 1, 0); nErr++; goto abort_parse; } default: { sqliteParser(pEngine, tokenType, pParse->sLastToken, pParse); if( pParse->zErrMsg && pParse->sErrToken.z ){ sqliteSetNString(pzErrMsg, "near \"", -1, pParse->sErrToken.z, pParse->sErrToken.n, "\": ", -1, |
︙ | ︙ |
Changes to src/vdbe.c.
︙ | ︙ | |||
32 33 34 35 36 37 38 | ** ** Various scripts scan this source file in order to generate HTML ** documentation, headers files, or other derived files. The formatting ** of the code in this file is, therefore, important. See other comments ** in this file for details. If in doubt, do not deviate from existing ** commenting and indentation practices when changing or adding code. ** | | | 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 | ** ** Various scripts scan this source file in order to generate HTML ** documentation, headers files, or other derived files. The formatting ** of the code in this file is, therefore, important. See other comments ** in this file for details. If in doubt, do not deviate from existing ** commenting and indentation practices when changing or adding code. ** ** $Id: vdbe.c,v 1.192 2003/01/07 02:47:48 drh Exp $ */ #include "sqliteInt.h" #include <ctype.h> /* ** The makefile scans this source file and creates the following ** array of string constants which are the names of all VDBE opcodes. |
︙ | ︙ | |||
1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 | unsigned long long int x; __asm__("rdtsc\n\t" "mov %%edx, %%ecx\n\t" :"=A" (x)); return x; } #endif /* ** Execute the program in the VDBE. ** ** If an error occurs, an error message is written to memory obtained ** from sqliteMalloc() and *pzErrMsg is made to point to that memory. ** The return parameter is the number of errors. | > > > > > > > > > > > > > > | 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 | unsigned long long int x; __asm__("rdtsc\n\t" "mov %%edx, %%ecx\n\t" :"=A" (x)); return x; } #endif /* ** The CHECK_FOR_INTERRUPT macro defined here looks to see if the ** sqlite_interrupt() routine has been called. If it has been, then ** processing of the VDBE program is interrupted. ** ** This macro added to every instruction that does a jump in order to ** implement a loop. This test used to be on every single instruction, ** but that meant we more testing that we needed. By only testing the ** flag on jump instructions, we get a (small) speed improvement. */ #define CHECK_FOR_INTERRUPT \ if( db->flags & SQLITE_Interrupt ) goto abort_due_to_interrupt; /* ** Execute the program in the VDBE. ** ** If an error occurs, an error message is written to memory obtained ** from sqliteMalloc() and *pzErrMsg is made to point to that memory. ** The return parameter is the number of errors. |
︙ | ︙ | |||
1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 | /* No instruction ever pushes more than a single element onto the ** stack. And the stack never grows on successive executions of the ** same loop. So the total number of instructions is an upper bound ** on the maximum stack depth required. ** ** Allocation all the stack space we will ever need. */ zStack = p->zStack = sqliteMalloc( p->nOp*sizeof(zStack[0]) ); aStack = p->aStack = sqliteMalloc( p->nOp*sizeof(aStack[0]) ); p->tos = -1; #ifdef VDBE_PROFILE { int i; for(i=0; i<p->nOp; i++){ | > | 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 | /* No instruction ever pushes more than a single element onto the ** stack. And the stack never grows on successive executions of the ** same loop. So the total number of instructions is an upper bound ** on the maximum stack depth required. ** ** Allocation all the stack space we will ever need. */ sqliteVdbeAddOp(p, OP_Halt, 0, 0); zStack = p->zStack = sqliteMalloc( p->nOp*sizeof(zStack[0]) ); aStack = p->aStack = sqliteMalloc( p->nOp*sizeof(aStack[0]) ); p->tos = -1; #ifdef VDBE_PROFILE { int i; for(i=0; i<p->nOp; i++){ |
︙ | ︙ | |||
1395 1396 1397 1398 1399 1400 1401 | rc = SQLITE_OK; #ifdef MEMORY_DEBUG if( access("vdbe_trace",0)==0 ){ p->trace = stdout; } #endif if( sqlite_malloc_failed ) goto no_mem; | | | < < < < < < < < < < < < < | 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 | rc = SQLITE_OK; #ifdef MEMORY_DEBUG if( access("vdbe_trace",0)==0 ){ p->trace = stdout; } #endif if( sqlite_malloc_failed ) goto no_mem; for(pc=0; rc==SQLITE_OK; pc++){ assert( pc>=0 && pc<p->nOp ); #ifdef VDBE_PROFILE origPc = pc; start = hwtime(); #endif pOp = &p->aOp[pc]; /* Only allow tracing if NDEBUG is not defined. */ #ifndef NDEBUG if( p->trace ){ vdbePrintOp(p->trace, pc, pOp); } #endif |
︙ | ︙ | |||
1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 | ** ** An unconditional jump to address P2. ** The next instruction executed will be ** the one at index P2 from the beginning of ** the program. */ case OP_Goto: { pc = pOp->p2 - 1; break; } /* Opcode: Gosub * P2 * ** ** Push the current address plus 1 onto the return address stack | > | 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 | ** ** An unconditional jump to address P2. ** The next instruction executed will be ** the one at index P2 from the beginning of ** the program. */ case OP_Goto: { CHECK_FOR_INTERRUPT; pc = pOp->p2 - 1; break; } /* Opcode: Gosub * P2 * ** ** Push the current address plus 1 onto the return address stack |
︙ | ︙ | |||
1531 1532 1533 1534 1535 1536 1537 | errorAction = pOp->p2; if( pOp->p3 ){ sqliteSetString(pzErrMsg, pOp->p3, 0); goto cleanup; } goto abort_due_to_error; }else{ | | < | 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 | errorAction = pOp->p2; if( pOp->p3 ){ sqliteSetString(pzErrMsg, pOp->p3, 0); goto cleanup; } goto abort_due_to_error; }else{ goto cleanup; } } /* Opcode: Integer P1 * P3 ** ** The integer value P1 is pushed onto the stack. If P3 is not zero ** then it is assumed to be a string representation of the same integer. */ |
︙ | ︙ | |||
3943 3944 3945 3946 3947 3948 3949 3950 3951 3952 3953 3954 3955 3956 | sqliteBtreeKeySize(pCrsr, &amt); if( amt<=0 ){ rc = SQLITE_CORRUPT; goto abort_due_to_error; } if( amt>NBFS ){ z = sqliteMallocRaw( amt ); aStack[tos].flags = STK_Str | STK_Dyn; }else{ z = aStack[tos].z; aStack[tos].flags = STK_Str; } sqliteBtreeKey(pCrsr, 0, amt, z); zStack[tos] = z; | > | 3945 3946 3947 3948 3949 3950 3951 3952 3953 3954 3955 3956 3957 3958 3959 | sqliteBtreeKeySize(pCrsr, &amt); if( amt<=0 ){ rc = SQLITE_CORRUPT; goto abort_due_to_error; } if( amt>NBFS ){ z = sqliteMallocRaw( amt ); if( z==0 ) goto no_mem; aStack[tos].flags = STK_Str | STK_Dyn; }else{ z = aStack[tos].z; aStack[tos].flags = STK_Str; } sqliteBtreeKey(pCrsr, 0, amt, z); zStack[tos] = z; |
︙ | ︙ | |||
4039 4040 4041 4042 4043 4044 4045 4046 4047 4048 4049 4050 4051 4052 | ** jump immediately to P2. */ case OP_Prev: case OP_Next: { Cursor *pC; BtCursor *pCrsr; if( VERIFY( pOp->p1>=0 && pOp->p1<p->nCursor && ) (pCrsr = (pC = &p->aCsr[pOp->p1])->pCursor)!=0 ){ int res; if( pC->nullRow ){ res = 1; }else{ rc = pOp->opcode==OP_Next ? sqliteBtreeNext(pCrsr, &res) : | > | 4042 4043 4044 4045 4046 4047 4048 4049 4050 4051 4052 4053 4054 4055 4056 | ** jump immediately to P2. */ case OP_Prev: case OP_Next: { Cursor *pC; BtCursor *pCrsr; CHECK_FOR_INTERRUPT; if( VERIFY( pOp->p1>=0 && pOp->p1<p->nCursor && ) (pCrsr = (pC = &p->aCsr[pOp->p1])->pCursor)!=0 ){ int res; if( pC->nullRow ){ res = 1; }else{ rc = pOp->opcode==OP_Next ? sqliteBtreeNext(pCrsr, &res) : |
︙ | ︙ | |||
4313 4314 4315 4316 4317 4318 4319 | int j; HashElem *i; char *z; VERIFY( if( iSet<0 || iSet>=p->nSet ) goto bad_instruction; ) pSet = &p->aSet[iSet]; nRoot = sqliteHashCount(&pSet->hash); | | > | 4317 4318 4319 4320 4321 4322 4323 4324 4325 4326 4327 4328 4329 4330 4331 4332 | int j; HashElem *i; char *z; VERIFY( if( iSet<0 || iSet>=p->nSet ) goto bad_instruction; ) pSet = &p->aSet[iSet]; nRoot = sqliteHashCount(&pSet->hash); aRoot = sqliteMallocRaw( sizeof(int)*(nRoot+1) ); if( aRoot==0 ) goto no_mem; for(j=0, i=sqliteHashFirst(&pSet->hash); i; i=sqliteHashNext(i), j++){ toInt((char*)sqliteHashKey(i), &aRoot[j]); } aRoot[j] = 0; z = sqliteBtreeIntegrityCheck(pOp->p2 ? db->pBeTemp : pBt, aRoot, nRoot); if( z==0 || z[0]==0 ){ if( z ) sqliteFree(z); |
︙ | ︙ | |||
4374 4375 4376 4377 4378 4379 4380 4381 4382 4383 4384 4385 4386 4387 | ** ** Attempt to read an integer from the temporary storage buffer ** and push it onto the stack. If the storage buffer is empty, ** push nothing but instead jump to P2. */ case OP_ListRead: { Keylist *pKeylist; pKeylist = p->pList; if( pKeylist!=0 ){ VERIFY( if( pKeylist->nRead<0 || pKeylist->nRead>=pKeylist->nUsed || pKeylist->nRead>=pKeylist->nKey ) goto bad_instruction; ) | > | 4379 4380 4381 4382 4383 4384 4385 4386 4387 4388 4389 4390 4391 4392 4393 | ** ** Attempt to read an integer from the temporary storage buffer ** and push it onto the stack. If the storage buffer is empty, ** push nothing but instead jump to P2. */ case OP_ListRead: { Keylist *pKeylist; CHECK_FOR_INTERRUPT; pKeylist = p->pList; if( pKeylist!=0 ){ VERIFY( if( pKeylist->nRead<0 || pKeylist->nRead>=pKeylist->nUsed || pKeylist->nRead>=pKeylist->nKey ) goto bad_instruction; ) |
︙ | ︙ | |||
4417 4418 4419 4420 4421 4422 4423 4424 4425 4426 4427 4428 4429 4430 | ** opcode. The list is empty after this is executed. */ case OP_ListPush: { p->keylistStackDepth++; assert(p->keylistStackDepth > 0); p->keylistStack = sqliteRealloc(p->keylistStack, sizeof(Keylist *) * p->keylistStackDepth); p->keylistStack[p->keylistStackDepth - 1] = p->pList; p->pList = 0; break; } /* Opcode: ListPop * * * ** | > | 4423 4424 4425 4426 4427 4428 4429 4430 4431 4432 4433 4434 4435 4436 4437 | ** opcode. The list is empty after this is executed. */ case OP_ListPush: { p->keylistStackDepth++; assert(p->keylistStackDepth > 0); p->keylistStack = sqliteRealloc(p->keylistStack, sizeof(Keylist *) * p->keylistStackDepth); if( p->keylistStack==0 ) goto no_mem; p->keylistStack[p->keylistStackDepth - 1] = p->pList; p->pList = 0; break; } /* Opcode: ListPop * * * ** |
︙ | ︙ | |||
4620 4621 4622 4623 4624 4625 4626 4627 4628 4629 4630 4631 4632 4633 | ** Push the data for the topmost element in the sorter onto the ** stack, then remove the element from the sorter. If the sorter ** is empty, push nothing on the stack and instead jump immediately ** to instruction P2. */ case OP_SortNext: { Sorter *pSorter = p->pSort; if( pSorter!=0 ){ p->pSort = pSorter->pNext; p->tos++; zStack[p->tos] = pSorter->pData; aStack[p->tos].n = pSorter->nData; aStack[p->tos].flags = STK_Str|STK_Dyn; sqliteFree(pSorter->zKey); | > | 4627 4628 4629 4630 4631 4632 4633 4634 4635 4636 4637 4638 4639 4640 4641 | ** Push the data for the topmost element in the sorter onto the ** stack, then remove the element from the sorter. If the sorter ** is empty, push nothing on the stack and instead jump immediately ** to instruction P2. */ case OP_SortNext: { Sorter *pSorter = p->pSort; CHECK_FOR_INTERRUPT; if( pSorter!=0 ){ p->pSort = pSorter->pNext; p->tos++; zStack[p->tos] = pSorter->pData; aStack[p->tos].n = pSorter->nData; aStack[p->tos].flags = STK_Str|STK_Dyn; sqliteFree(pSorter->zKey); |
︙ | ︙ | |||
4706 4707 4708 4709 4710 4711 4712 4713 4714 4715 4716 4717 4718 4719 | ** Input ends if a line consists of just "\.". A field containing only ** "\N" is a null field. The backslash \ character can be used be used ** to escape newlines or the delimiter. */ case OP_FileRead: { int n, eol, nField, i, c, nDelim; char *zDelim, *z; if( p->pFile==0 ) goto fileread_jump; nField = pOp->p1; if( nField<=0 ) goto fileread_jump; if( nField!=p->nField || p->azField==0 ){ char **azField = sqliteRealloc(p->azField, sizeof(char*)*nField+1); if( azField==0 ){ goto no_mem; } p->azField = azField; | > | 4714 4715 4716 4717 4718 4719 4720 4721 4722 4723 4724 4725 4726 4727 4728 | ** Input ends if a line consists of just "\.". A field containing only ** "\N" is a null field. The backslash \ character can be used be used ** to escape newlines or the delimiter. */ case OP_FileRead: { int n, eol, nField, i, c, nDelim; char *zDelim, *z; CHECK_FOR_INTERRUPT; if( p->pFile==0 ) goto fileread_jump; nField = pOp->p1; if( nField<=0 ) goto fileread_jump; if( nField!=p->nField || p->azField==0 ){ char **azField = sqliteRealloc(p->azField, sizeof(char*)*nField+1); if( azField==0 ){ goto no_mem; } p->azField = azField; |
︙ | ︙ | |||
4945 4946 4947 4948 4949 4950 4951 4952 4953 4954 4955 4956 4957 4958 | ** Reset the aggregator so that it no longer contains any data. ** Future aggregator elements will contain P2 values each. */ case OP_AggReset: { AggReset(&p->agg); p->agg.nMem = pOp->p2; p->agg.apFunc = sqliteMalloc( p->agg.nMem*sizeof(p->agg.apFunc[0]) ); break; } /* Opcode: AggInit * P2 P3 ** ** Initialize the function parameters for an aggregate function. ** The aggregate will operate out of aggregate column P2. | > | 4954 4955 4956 4957 4958 4959 4960 4961 4962 4963 4964 4965 4966 4967 4968 | ** Reset the aggregator so that it no longer contains any data. ** Future aggregator elements will contain P2 values each. */ case OP_AggReset: { AggReset(&p->agg); p->agg.nMem = pOp->p2; p->agg.apFunc = sqliteMalloc( p->agg.nMem*sizeof(p->agg.apFunc[0]) ); if( p->agg.apFunc==0 ) goto no_mem; break; } /* Opcode: AggInit * P2 P3 ** ** Initialize the function parameters for an aggregate function. ** The aggregate will operate out of aggregate column P2. |
︙ | ︙ | |||
5113 5114 5115 5116 5117 5118 5119 5120 5121 5122 5123 5124 5125 5126 | ** The order of aggregator opcodes is important. The order is: ** AggReset AggFocus AggNext. In other words, you must execute ** AggReset first, then zero or more AggFocus operations, then ** zero or more AggNext operations. You must not execute an AggFocus ** in between an AggNext and an AggReset. */ case OP_AggNext: { if( p->agg.pSearch==0 ){ p->agg.pSearch = sqliteHashFirst(&p->agg.hash); }else{ p->agg.pSearch = sqliteHashNext(p->agg.pSearch); } if( p->agg.pSearch==0 ){ pc = pOp->p2 - 1; | > | 5123 5124 5125 5126 5127 5128 5129 5130 5131 5132 5133 5134 5135 5136 5137 | ** The order of aggregator opcodes is important. The order is: ** AggReset AggFocus AggNext. In other words, you must execute ** AggReset first, then zero or more AggFocus operations, then ** zero or more AggNext operations. You must not execute an AggFocus ** in between an AggNext and an AggReset. */ case OP_AggNext: { CHECK_FOR_INTERRUPT; if( p->agg.pSearch==0 ){ p->agg.pSearch = sqliteHashFirst(&p->agg.hash); }else{ p->agg.pSearch = sqliteHashNext(p->agg.pSearch); } if( p->agg.pSearch==0 ){ pc = pOp->p2 - 1; |
︙ | ︙ | |||
5239 5240 5241 5242 5243 5244 5245 5246 5247 5248 5249 5250 5251 5252 | ** are no more elements in the set, do not do the push and fall through. ** Otherwise, jump to P2 after pushing the next set element. */ case OP_SetFirst: case OP_SetNext: { Set *pSet; int tos; if( pOp->p1<0 || pOp->p1>=p->nSet ){ if( pOp->opcode==OP_SetFirst ) pc = pOp->p2 - 1; break; } pSet = &p->aSet[pOp->p1]; if( pOp->opcode==OP_SetFirst ){ pSet->prev = sqliteHashFirst(&pSet->hash); | > | 5250 5251 5252 5253 5254 5255 5256 5257 5258 5259 5260 5261 5262 5263 5264 | ** are no more elements in the set, do not do the push and fall through. ** Otherwise, jump to P2 after pushing the next set element. */ case OP_SetFirst: case OP_SetNext: { Set *pSet; int tos; CHECK_FOR_INTERRUPT; if( pOp->p1<0 || pOp->p1>=p->nSet ){ if( pOp->opcode==OP_SetFirst ) pc = pOp->p2 - 1; break; } pSet = &p->aSet[pOp->p1]; if( pOp->opcode==OP_SetFirst ){ pSet->prev = sqliteHashFirst(&pSet->hash); |
︙ | ︙ | |||
5435 5436 5437 5438 5439 5440 5441 5442 5443 5444 5445 5446 5447 5448 5449 | /* Jump to here for any other kind of fatal error. The "rc" variable ** should hold the error number. */ abort_due_to_error: sqliteSetString(pzErrMsg, sqlite_error_string(rc), 0); goto cleanup; /* Jump to here if a operator is encountered that requires more stack ** operands than are currently available on the stack. */ not_enough_stack: sprintf(zBuf,"%d",pc); sqliteSetString(pzErrMsg, "too few operands on stack at ", zBuf, 0); rc = SQLITE_INTERNAL; | > > > > > > > > > > > > > > < | 5447 5448 5449 5450 5451 5452 5453 5454 5455 5456 5457 5458 5459 5460 5461 5462 5463 5464 5465 5466 5467 5468 5469 5470 5471 5472 5473 5474 5475 5476 5477 5478 5479 5480 5481 5482 5483 5484 5485 5486 | /* Jump to here for any other kind of fatal error. The "rc" variable ** should hold the error number. */ abort_due_to_error: sqliteSetString(pzErrMsg, sqlite_error_string(rc), 0); goto cleanup; /* Jump to here if the sqlite_interrupt() API sets the interrupt ** flag. */ abort_due_to_interrupt: assert( db->flags & SQLITE_Interrupt ); db->flags &= ~SQLITE_Interrupt; if( db->magic!=SQLITE_MAGIC_BUSY ){ rc = SQLITE_MISUSE; }else{ rc = SQLITE_INTERRUPT; } sqliteSetString(pzErrMsg, sqlite_error_string(rc), 0); goto cleanup; /* Jump to here if a operator is encountered that requires more stack ** operands than are currently available on the stack. */ not_enough_stack: sprintf(zBuf,"%d",pc); sqliteSetString(pzErrMsg, "too few operands on stack at ", zBuf, 0); rc = SQLITE_INTERNAL; /* Jump here if an illegal or illformed instruction is executed. */ VERIFY( bad_instruction: sprintf(zBuf,"%d",pc); sqliteSetString(pzErrMsg, "illegal operation at ", zBuf, 0); rc = SQLITE_INTERNAL; goto cleanup; ) } |