Lines Matching refs:state
1077 * If the lock is already at or below the requested lock state, then the call
1180 ** opcode causes the xFileControl method to write the current state of
2571 ** If the first argument is -1, then no changes are made to state of either the
5133 ** machine back to its initial state.
5497 ** object back to its initial state, ready to be re-executed.
5584 ** functions that have side effects or reveal internal application state.
5979 ** routine to allocate memory for storing their state.
6751 ** CAPI3REF: Determine the transaction state of a database
6755 ** [transaction state] of schema S in database connection D. ^If S is NULL,
6756 ** then the highest transaction state of any schema on database connection D
6770 ** KEYWORDS: {transaction state}
6772 ** These constants define the current transaction state of a database file.
6774 ** constants in order to describe the transaction state of schema S
6779 ** <dd>The SQLITE_TXN_NONE state means that no transaction is currently
6783 ** <dd>The SQLITE_TXN_READ state means that the database is currently
6785 ** but nothing in the database file has changed. The transaction state
6788 ** state will revert to SQLITE_TXN_NONE following a [ROLLBACK] or
6792 ** <dd>The SQLITE_TXN_WRITE state means that the database is currently
6794 ** but has not yet committed. The transaction state will change to
8376 ** state of SQLite and to inject faults into SQLite for testing
9215 ** The sqlite3_backup object records state information about an ongoing
9507 ** system in a deadlocked state, then SQLITE_LOCKED is returned and no
9509 ** a deadlocked state if connection A has registered for an unlock-notify
10526 ** An instance of the snapshot object records the state of a [WAL mode]
10537 ** The sqlite3_snapshot object records state information about an historical
10551 ** new [sqlite3_snapshot] object that records the current state of
10622 ** SQLITE_IOERR error code - is returned, then the final state of the
11097 ** no-op, and may be used to query the current state of the session.
11099 ** The return value indicates the final state of the session object: 0 if
11126 ** of the indirect flag, and may be used to query the current state of the
11129 ** The return value indicates the final state of the indirect flag: 0 if
11960 ** function returns SQLITE_NOMEM. In all cases, if an error occurs the state
12142 ** rolled back, restoring the target database to its original state, and an
12253 ** database in a state containing foreign key violations, the conflict
12319 ** Suppose there is a site hosting a database in state S0. And that
12320 ** modifications are made that move that database to state S1 and a
12323 ** applied to the database. The database is then in state
12324 ** (S1+"remote"), where the exact state depends on any conflict
12526 ** an error state, whereby all subsequent calls to iterator functions
15375 /* Functions used to query pager state and configuration. */
17017 u32 mDbFlags; /* flags recording internal state */
19468 ** This structure also contains some state information.
22562 ** restoring the state of the VM to as it was before the sub-program
22824 ** state of the virtual machine.
23154 ** state vector. If writable static data is unsupported on the target,
23155 ** we have to locate the state vector at run-time. In the more common
23157 ** to the "sqlite3Stat" state vector declared above.
23741 ** Put the DateTime object into its error state.
25355 ** we have to locate the state vector at run-time. In the more common
25357 ** to the "sqlite3Hooks" state vector declared above.
26600 ** linked into the hash tables. That is not the normal state of
32646 ** This structure is the current state of the generator.
32649 u32 s[16]; /* 64 bytes of chacha20 state */
32687 ** state vector. If writable static data is unsupported on the target,
32688 ** we have to locate the state vector at run-time. In the more common
32690 ** to the "sqlite3Prng" state vector declared above.
32718 /* Initialize the state of the random number generator once,
32758 ** For testing purposes, we sometimes want to preserve the state of
32759 ** PRNG and restore the PRNG to its saved state at a later time, or
32760 ** to reset the PRNG to its initial state. These routines accomplish
33727 ** The equivalent of sqlite3Error(db, SQLITE_OK). Clear the error state
35350 ** to the empty state.
36997 void *lockingContext; /* Locking style specific state */
37898 ** a locked and an unlocked state.
38470 ** Sometimes when requesting one lock state, additional lock states
38472 ** transitions leaving the lock state different from what it started but
39089 ** Sometimes when requesting one lock state, additional lock states
39091 ** transitions leaving the lock state different from what it started but
39104 ** With dotfile locking, we really only support state (4): EXCLUSIVE.
39173 ** lock state. No need to mess with the file on disk.
39306 ** Sometimes when requesting one lock state, additional lock states
39308 ** transitions leaving the lock state different from what it started but
39483 ** Sometimes when requesting one lock state, additional lock states
39485 ** transitions leaving the lock state different from what it started but
39607 ** The afpLockingContext structure contains all afp lock specific state
39706 ** the original state */
39733 ** Sometimes when requesting one lock state, additional lock states
39735 ** transitions leaving the lock state different from what it started but
41190 ** Structure used internally by this VFS to record the state of an
41295 /* Update the global lock state and do debug tracing */
41789 ** Change the lock state for a shared-memory segment.
44815 ** Sometimes when requesting one lock state, additional lock states
44817 ** transitions leaving the lock state different from what it started but
48299 ** Sometimes when requesting one lock state, additional lock states
48301 ** transitions leaving the lock state different from what it started but
48437 /* Update the state of the lock has held in the file descriptor then
48831 ** Structure used internally by this VFS to record the state of an
49142 ** Change the lock state for a shared-memory segment.
54794 ** This function is used by test procedures to inspect the internal state
55411 ** snapshot is like a read-transaction. It is the state of the database
55413 ** preserves the current state even if the other threads or processes
55616 ** The Pager.eState variable stores the current 'state' of a pager. A
55618 ** state diagram.
55638 ** List of state transitions and the C [function] that performs each:
55655 ** The pager starts up in this state. Nothing is guaranteed in this
55656 ** state - the file may or may not be locked and the database size is
55665 ** In this state all the requirements for reading the database in
55668 ** open. The database size is known in this state.
55670 ** A connection running with locking_mode=normal enters this state when
55671 ** it opens a read-transaction on the database and returns to state
55674 ** this state even after the read-transaction is closed. The only way
55676 ** is via the ERROR state (see below).
55689 ** The pager moves to this state from READER when a write-transaction
55690 ** is first opened on the database. In WRITER_LOCKED state, all locks
55696 ** moving to this state, but the journal file is not written to or opened
55697 ** to in this state. If the transaction is committed or rolled back while
55698 ** in WRITER_LOCKED state, all that is required is to unlock the database
55718 ** A pager moves from WRITER_LOCKED state to this state when a page is
55731 ** The pager transitions from WRITER_CACHEMOD into WRITER_DBMOD state
55733 ** never enter this state (since they do not modify the database file,
55745 ** It is not possible for a WAL connection to enter this state.
55747 ** A rollback-mode pager changes to WRITER_FINISHED state from WRITER_DBMOD
55748 ** state after the entire transaction has been successfully written into the
55749 ** database file. In this state the transaction may be committed simply
55750 ** by finalizing the journal file. Once in WRITER_FINISHED state, it is
55763 ** The ERROR state is entered when an IO or disk-full error (including
55765 ** difficult to be sure that the in-memory pager state (cache contents,
55768 ** Temporary pager files may enter the ERROR state, but in-memory pagers
55772 ** the contents of the page-cache may be left in an inconsistent state.
55773 ** At this point it would be dangerous to change back to READER state
55777 ** file. To avoid this hazard, the pager switches into the ERROR state
55780 ** Once it has entered the ERROR state, any attempt to use the pager
55783 ** transition back to OPEN state, discarding the contents of the
55784 ** page-cache and any other in-memory state at the same time. Everything
55787 ** the pager into READER state). At that point the system has recovered
55790 ** Specifically, the pager jumps into the ERROR state if:
55804 ** persists, the pager enters the ERROR state via condition (1) above.
55811 ** state.
55815 ** last reference is dropped the pager should move back to OPEN state).
55821 ** * A pager is never in WRITER_DBMOD or WRITER_FINISHED state if the
55826 ** state. There are two exceptions: immediately after exclusive-mode has
55828 ** executed), and when the pager is leaving the "error state".
55861 ** from ERROR to OPEN state. At this point there may be a hot-journal file
55877 ** database in the ERROR state, Pager.eLock is set to UNKNOWN_LOCK. It
55878 ** is only changed back to a real locking state after a successful call
55879 ** to xLock(EXCLUSIVE). Also, the code to do the OPEN->SHARED state transition
55886 ** PAGER_OPEN state.
55952 ** The current 'state' of the pager object. See the comment and state
55953 ** diagram above for a description of the pager state.
56010 ** is cleared anyway (and the pager will move to ERROR state).
56097 ** The Pager.errCode variable is only ever used in PAGER_ERROR state. It
56098 ** is set to zero in all other states. In PAGER_ERROR state, Pager.errCode
56136 ** the "state" of the pager, while other class members describe the
56139 u8 eState; /* Pager state (OPEN, READER, WRITER_LOCKED..) */
56351 ** the internal state of the Pager object.
56366 /* Regardless of the current state, a temp-file connection always behaves
56385 ** state.
56473 ** in ERROR state. Otherwise the pager should have already dropped
56474 ** back to OPEN state.
56488 ** containing the state of the Pager object passed as an argument. This
56664 ** Pager.eLock variable to the new locking state.
56667 ** called, do not modify it unless the new locking state is EXCLUSIVE_LOCK.
57313 ** in the ERROR state. Otherwise, it switches the pager to PAGER_OPEN
57314 ** state.
57321 ** If the pager is in ERROR state when this function is called, the
57323 ** the OPEN state. Regardless of whether the pager is in exclusive-mode
57364 /* If the pager is in the ERROR state and the call to unlock the database
57374 /* The pager state may be changed from PAGER_ERROR to PAGER_OPEN here
57384 ** it can safely move back to PAGER_OPEN state. This happens in both
57408 ** the pager to transition into the ERROR state may ahve occurred.
57414 ** IOERR sub-codes, the pager enters the ERROR state and the error code
57415 ** is stored in Pager.errCode. While the pager remains in the ERROR state,
57418 ** The ERROR state indicates that the contents of the pager-cache
57419 ** cannot be trusted. This state can be cleared by completely discarding
57473 ** This routine is never called in PAGER_ERROR state. If it is called
57474 ** in PAGER_NONE or PAGER_SHARED state and the lock held is less
57506 ** After the journal is finalized, the pager moves to PAGER_READER state.
57653 ** If the pager has already entered the ERROR state, do not attempt
57656 ** the database file and move the pager back to OPEN state. If this
57661 ** If the pager has not already entered the ERROR state, but an IO or
57663 ** the pager to enter the ERROR state. Which will be cleared by the
57805 /* Either the state is greater than PAGER_WRITER_CACHEMOD (a transaction
57808 ** is in state OPEN and holds an EXCLUSIVE lock. Hot-journal rollback
57859 /* If the pager is in CACHEMOD state, then there must be a copy of this
57870 ** If in WRITER_DBMOD, WRITER_FINISHED or OPEN state, then we update the
57872 ** not dirty. Since this code is only executed in PAGER_OPEN state for
57874 ** if the pager is in OPEN state.
58151 ** DBMOD or OPEN state, this function is a no-op. Otherwise, the size
58254 ** the state it was in before we started making changes.
58440 ** code. This will cause the pager to enter the error state
58457 ** state prior to the start of the transaction, so invoke the
58592 ** needed, as determined by the pPager->changeCountDone state variable.
58782 ** to PAGER_READER state to determine the size of the database file
59086 ** in a state which would cause damage to the database
59240 ** If the pager is in the error state when this function is called, it
59241 ** is a no-op. The value returned is the error state error code (i.e.
59262 ** conditions above is not true, the pager was in error state when this
59270 ** function may be called from within PagerOpen(), before the state
59274 ** PAGER_ERROR state. But since PAGER_ERROR state guarantees that
59442 ** the lock. If the lock is obtained successfully, set the Pager.state
59508 ** just sets the internal state of the pager object so that the
59706 ** into the ERROR state. This causes UnlockAndRollback to unlock the
59933 /* This function is only called for rollback pagers in WRITER_DBMOD state. */
60038 ** Append a record of the current state of page pPg to the sub-journal.
60133 ** Spilling is also prohibited when in an error state since that could
60136 ** while in the error state, hence it is impossible for this routine to
60137 ** be called in the error state. Nevertheless, we include a NEVER()
60138 ** test for the error state as a safeguard against future changes.
60564 /* pPager->state = PAGER_UNLOCK; */
60627 ** PAGER_SHARED state. It tests if there is a hot journal present in
60757 ** 1) If the pager is currently in PAGER_OPEN state (no lock held
60767 ** no outstanding references to any pages, and is in the error state,
60768 ** then an attempt is made to clear the error state by discarding
60780 ** outstanding pages. This implies that the pager state should either
60845 ** may mean that the pager was in the error-state when this
60895 ** to ERROR state in the state diagram at the top of this file,
60897 ** shortly transition the pager object to the OPEN state. Calling
60899 ** to be in ERROR state when there are zero outstanding page
61006 ** on the current state of the pager.
61009 ** getPageError() -- Used if the pager is in an error state
61230 /* The page getter method for when the pager is an error state */
61346 /* If already in the error state, this function is a no-op. But on
61348 ** an error state. */
61452 ** PAGER_RESERVED state. Otherwise, return an error code to the caller.
61470 /* Change to WRITER_LOCKED state.
61561 ** It is never called in the ERROR state.
61578 ** an error might occur and the pager would end up in WRITER_LOCKED state
62200 ** moves into the error state. Otherwise, SQLITE_OK is returned.
62245 ** The pager falls back to PAGER_READER state if successful, or PAGER_ERROR
62246 ** state if an error occurs.
62248 ** If the pager is already in PAGER_ERROR state when this function is called,
62254 ** in-memory cache pages to the state they were in when the transaction
62265 ** their pre-transaction state by re-reading data from the database or
62272 /* PagerRollback() is a no-op if called in READER or OPEN state. If
62273 ** the pager is already in the ERROR state, the rollback is not
62290 ** state to indicate that the contents of the cache may not be trusted.
62497 ** contents of the database to its original state.
62558 ** back journal_mode=off, put the pager in the error state. This way,
62958 int state = pPager->eState;
62959 assert( state==PAGER_OPEN || state==PAGER_READER );
62960 if( state==PAGER_OPEN ){
62970 if( rc==SQLITE_OK && state==PAGER_READER ){
62972 }else if( state==PAGER_OPEN ){
62975 assert( state==pPager->eState );
62994 ** Return TRUE if the pager is in a state where it is OK to change the
64289 ** through the unlocked state first.
65565 ** as it would leave the system in a state where the contents of
66370 ** it takes a snapshot of the state of the WAL and wal-index for the current
66725 /* Restore the clients cache of the wal-index header to the state it
66853 ** Information about the current state of the WAL file and where
67977 ** the shared-cache enters 'pending-lock' state and isPending is
67980 ** The shared-cache leaves the 'pending lock' state when either of
67986 ** while in the 'pending-lock' state, no connection may start a new
68002 u8 inTransaction; /* Transaction state */
68150 ** this state, restoreCursorPosition() can be called to attempt to
68156 ** cursor. The error has left the cache in an inconsistent state.
68227 /* A bunch of assert() statements to check the transaction state variables
68251 ** in order to keep track of some global state information.
69321 ** and BtCursor.pKey. The cursor's state is set to CURSOR_REQUIRESEEK.
71010 ** so that the cache is restored to its original state at the start of
72001 ** have been tripped into the CURSOR_FAULT state are not counted.
72763 ** the database can be restored to its original state by playing back
72829 ** reaches 0, set the shared state to TRANS_NONE. The unlockBtreeIfUnused()
72839 /* Set the current transaction state to TRANS_NONE and unlock the
72867 ** reset the b-tree objects internal state to indicate that the write
72869 ** transitioned to the error state.
72881 ** transaction and set the shared state to TRANS_READ.
72918 ** This routine sets the state to CURSOR_FAULT and the error
72973 ** state of the database. Assume pBt->pPage1 is valid.
73135 ** but which are not in the READ_UNCOMMITTED state may not have
73793 ** in the CURSOR_VALID state. It is only used by the sqlite3_blob_read()
73969 ** If the b-tree structure is empty, the cursor state is set to
73972 ** (or virtual root) page and the cursor state is set to CURSOR_VALID.
76484 ** in a corrupted state. So if this routine fails, the database should
77671 /* Ensure that the cursor is not in the CURSOR_FAULT state and that it
77882 ** set the cursor state to "invalid". This makes common insert operations
77902 ** Also, set the cursor state to invalid. This stops saveCursorPosition()
78044 ** But if that bit is set, then the cursor is left in a state such that
78099 ** key and leaving the cursor in CURSOR_REQUIRESEEK state before
78103 ** will be left in CURSOR_SKIPNEXT state pointing to the entry immediately
79481 ** to describe the current transaction state of Btree p.
79801 ** invoked by the pager layer to report various state changes in
81793 ** to read from the disk) then the pMem is left in an inconsistent state.
84934 ** opcode array of prepared state for other memory needs of the prepared
85012 ** to its initial state after it has been run.
85678 ** call this on a VM that is in the SQLITE_STATE_HALT state.
85700 ** state. We need to rollback the statement transaction, if there is
85735 ** consistent state.
85742 ** the pager to a consistent state.
85948 ** To look at it another way, this routine resets the state of the
87984 ** back to its starting state so that it can be reused. A success code from
95419 ** This operation leaves the cursor in a state where it can be
95438 ** This operation leaves the cursor in a state where it cannot be
95492 ** This operation leaves the cursor in a state where it cannot be
95615 ** This opcode leaves the cursor in a state where it cannot be advanced
95638 ** This opcode leaves the cursor in a state where it cannot be advanced
96017 ** left in an undefined state.
97503 /* Register pRt is used to store the memory required to save the state
100035 int *aTree; /* Current state of incremental merge */
100191 int eFWErr; /* Non-zero if in an error state */
101005 ** Reset a sorting cursor back to its original empty state.
104579 ** to the state they where in before the "column" LHS expression was
114867 ** share an instance of the following structure to hold their state
120278 ** suitable state to query for the column names and types to be used
126352 ** The following structure keeps track of state information for the
133378 ** state vector. If writable static data is unsupported on the target,
133379 ** we have to locate the state vector at run-time. In the more common
133381 ** to the "sqlite3Autoext" state vector declared above.
136738 ** Report the current state of file logs for all databases
143708 /* Prior errors might have left pParse->pWith in a goofy state, so
146408 ** To state it another way: This routine returns a list of all triggers
151765 ** An instance of this object holds the complete state of the query
158769 ** object in an initialized state, as if it had been newly allocated.
165628 ** current row of csrCurrent and the current state of all
166774 ** current state and lookahead token. These tables are used to implement
166775 ** functions that take a state number and lookahead value and return an
166782 ** token onto the stack and goto state N.
166784 ** N between YY_MIN_SHIFTREDUCE Shift to an arbitrary state then
166798 ** Given state S and lookahead X, the action is computed as either:
166816 ** yy_shift_ofst[] For each state, the offset into yy_action for
166818 ** yy_reduce_ofst[] For each state, the offset into yy_action for
166820 ** yy_default[] Default action for each state.
167645 ** + The state number for the parser at this level of the stack.
167659 YYACTIONTYPE stateno; /* The state-number, or reduce action in SHIFTREDUCE */
167667 /* The state of the parser is completely contained in an instance of
168746 ** is in state X and has a lookahead token Y. In a well-tested
168754 ** Write into out a description of every state/lookahead combination that
168759 ** Return the number of missed state/lookahead combinations.
168787 YYACTIONTYPE stateno /* Current state number */
168851 YYACTIONTYPE stateno, /* Current state number */
168905 fprintf(yyTraceFILE,"%s%s '%s', go to state %d\n",
168924 YYACTIONTYPE yyNewState, /* The new state to shift in */
169800 int yygoto; /* The next state */
171433 ** "sqlite3ParserAlloc" which describes the current state of the parser.
171477 fprintf(yyTraceFILE,"%sInput '%s' in state %d\n",
171497 fprintf(yyTraceFILE, "%sReduce %d [%s]%s, pop back to state %d.\n",
171566 ** * Begin popping the stack until we enter a state where
173078 ** This implementation uses a state machine with 8 states:
173083 ** returns 1 if it ends in the START state and 0 if it ends
173084 ** in any other state.
173117 ** Whitespace never causes a state transition and is always ignored.
173125 u8 state = 0; /* Current state, using numbers defined in header comment */
173196 if( *zSql==0 ) return state==1;
173277 state = trans[state][token];
173280 return state==1;
174683 ** Return the transaction state for a single databse, or the maximum
174684 ** transaction state over all attached databases if zSchema is null.
176359 int eState; /* Parser state when parsing URI */
177454 ** Save the current state of the PRNG.
177462 ** Restore the state of the PRNG to the last state saved using
177834 ** state/lookahead combinations in the parser state machine
177835 ** which are never exercised. If any state is missed, make the
186067 /* State 0. In this state the integer just read was a docid. */
186074 /* State 1. In this state we are expecting either a 1, indicating
186078 ** The only difference between state 1 and state 2 is that if the
186079 ** integer encountered in state 1 is not 0 or 1, then we need to
187687 ** to the empty state.
192726 ** a state that if the next two calls are:
193595 ** An object of this type contains the state required to create or append
196782 ** An instance of the following structure is used to store state while
196931 ** occurs. If a value other than SQLITE_OK is returned, the state the
198416 ** initial state.
200450 /* Reset a JsonEachCursor back to its original state. Free any memory
202037 ** Reset a cursor back to its initial state.
202792 /* Reset the cursor to the same state as rtreeOpen() leaves it in. */
206705 /* Reset the cursor to the same state as rtreeOpen() leaves it in. */
208234 ** When state is saved, any commit to the *-oal file and the commit to
208243 ** not really clear how to get out of this state. The system could just
208250 ** data to disk when saving the state of an ongoing update to the RBU
208501 ** is marked as fully applied. Otherwise, the state of the RBU
208508 ** time sqlite3rbu_close() is called, various state information is saved
208512 ** To remove all RBU extension state information, returning an RBU database
208552 ** the current state of the update (how many rows have been updated, which
208555 ** organize removing a separate state file after the update is concluded.
208557 ** the RBU extension can store the state of the update.
208586 ** to store the state of the RBU vacuum operation if it is suspended. The
208588 ** operation, the state database should either not exist or be empty
208591 ** returned SQLITE_DONE, the vacuum state is stored in the state database.
208593 ** handle specifying the same target and state databases.
208596 ** name of the state database is "<database>-vacuum", where <database>
208598 ** state database is not already present in the file-system, it is created
208602 ** state database ends with "-vactmp". This name is reserved for internal
208605 ** This function does not delete the state database after an RBU vacuum
208608 ** of the state tables within the state database are zeroed. This way,
208692 ** Force RBU to save its state to disk.
208695 ** system recovery RBU may resume the update from the point at which the state
208708 ** current state of the RBU update appliation to the RBU database.
208930 ** The rbu_state table is used to save the state of a partially applied
209058 ** * a special "cleanup table" state.
209085 int bCleanup; /* True in "cleanup" state */
209193 char *zState; /* Path to state db (or NULL if zRbu) */
209194 char zStateDb[5]; /* Db name for state ("stat" or "main") */
209208 /* The following state variables are used as part of the incremental
211599 /* If using separate RBU and state databases, attach the state database to
211637 p->zErrmsg = sqlite3_mprintf("invalid state database");
211809 ** object, then the rbu handle is set to DONE state. This occurs if some
212007 ** The RBU handle is currently in RBU_STAGE_OAL state, with a SHARED lock
212406 ** the state database is empty. If this RBU handle was opened for an
212467 /* If this is an RBU vacuum operation and the state table was empty
212797 /* Open the target, RBU and state databases */
213044 ** state table. This causes the next call to sqlite3rbu_vacuum()
213045 ** specifying the current target and state databases to start a new
213122 ** Return the current state of the RBU vacuum or update operation.
213760 ** rbu is in the RBU_STAGE_OAL state, use heap memory for *-shm space
218072 ** object is already in the error state (sqlite3_session.rc != SQLITE_OK),
218750 /* If the iterator is in the error-state, return immediately. */
222990 ** current state and lookahead token. These tables are used to implement
222991 ** functions that take a state number and lookahead value and return an
222998 ** token onto the stack and goto state N.
223000 ** N between fts5YY_MIN_SHIFTREDUCE Shift to an arbitrary state then
223014 ** Given state S and lookahead X, the action is computed as either:
223032 ** fts5yy_shift_ofst[] For each state, the offset into fts5yy_action for
223034 ** fts5yy_reduce_ofst[] For each state, the offset into fts5yy_action for
223036 ** fts5yy_default[] Default action for each state.
223114 ** + The state number for the parser at this level of the stack.
223128 fts5YYACTIONTYPE stateno; /* The state-number, or reduce action in SHIFTREDUCE */
223136 /* The state of the parser is completely contained in an instance of
223482 ** is in state X and has a lookahead token Y. In a well-tested
223490 ** Write into out a description of every state/lookahead combination that
223495 ** Return the number of missed state/lookahead combinations.
223523 fts5YYACTIONTYPE stateno /* Current state number */
223587 fts5YYACTIONTYPE stateno, /* Current state number */
223641 fprintf(fts5yyTraceFILE,"%s%s '%s', go to state %d\n",
223660 fts5YYACTIONTYPE fts5yyNewState, /* The new state to shift in */
223782 int fts5yygoto; /* The next state */
224039 ** "sqlite3Fts5ParserAlloc" which describes the current state of the parser.
224083 fprintf(fts5yyTraceFILE,"%sInput '%s' in state %d\n",
224103 fprintf(fts5yyTraceFILE, "%sReduce %d [%s]%s, pop back to state %d.\n",
224172 ** * Begin popping the stack until we enter a state where
225547 ** undefined state.
230045 ** * extra fields in the "structure record" record the state of ongoing
230296 /* Error state. */
230526 Fts5CResult *aFirst; /* Current merge state (see above) */
231797 ** The iterator is in an unusual state when this function is called: the
231805 ** is in its regular state - Fts5SegIter.iLeafOffset points to the first
232904 ** Set the pIter->bEof variable based on the state of the sub-iterators.
236508 ** set to an SQLite error code before returning. The final state of buffer
236892 ** structure is used to record the current transaction state. This information
238466 /* Put any active cursors into REQUIRE_SEEK state. */