diff options
author | dan miller | 2007-10-21 08:36:32 +0000 |
---|---|---|
committer | dan miller | 2007-10-21 08:36:32 +0000 |
commit | 2f8d7092bc2c9609fa98d6888106b96f38b22828 (patch) | |
tree | da6c37579258cc965b52a75aee6135fe44237698 /libraries/sqlite/win32/vdbeInt.h | |
parent | * Committing new PolicyManager based on an ACL system. (diff) | |
download | opensim-SC-2f8d7092bc2c9609fa98d6888106b96f38b22828.zip opensim-SC-2f8d7092bc2c9609fa98d6888106b96f38b22828.tar.gz opensim-SC-2f8d7092bc2c9609fa98d6888106b96f38b22828.tar.bz2 opensim-SC-2f8d7092bc2c9609fa98d6888106b96f38b22828.tar.xz |
libraries moved to opensim-libs, a new repository
Diffstat (limited to '')
-rwxr-xr-x | libraries/sqlite/win32/vdbeInt.h | 427 |
1 files changed, 0 insertions, 427 deletions
diff --git a/libraries/sqlite/win32/vdbeInt.h b/libraries/sqlite/win32/vdbeInt.h deleted file mode 100755 index a807bdd..0000000 --- a/libraries/sqlite/win32/vdbeInt.h +++ /dev/null | |||
@@ -1,427 +0,0 @@ | |||
1 | /* | ||
2 | ** 2003 September 6 | ||
3 | ** | ||
4 | ** The author disclaims copyright to this source code. In place of | ||
5 | ** a legal notice, here is a blessing: | ||
6 | ** | ||
7 | ** May you do good and not evil. | ||
8 | ** May you find forgiveness for yourself and forgive others. | ||
9 | ** May you share freely, never taking more than you give. | ||
10 | ** | ||
11 | ************************************************************************* | ||
12 | ** This is the header file for information that is private to the | ||
13 | ** VDBE. This information used to all be at the top of the single | ||
14 | ** source code file "vdbe.c". When that file became too big (over | ||
15 | ** 6000 lines long) it was split up into several smaller files and | ||
16 | ** this header information was factored out. | ||
17 | */ | ||
18 | #ifndef _VDBEINT_H_ | ||
19 | #define _VDBEINT_H_ | ||
20 | |||
21 | /* | ||
22 | ** intToKey() and keyToInt() used to transform the rowid. But with | ||
23 | ** the latest versions of the design they are no-ops. | ||
24 | */ | ||
25 | #define keyToInt(X) (X) | ||
26 | #define intToKey(X) (X) | ||
27 | |||
28 | |||
29 | /* | ||
30 | ** SQL is translated into a sequence of instructions to be | ||
31 | ** executed by a virtual machine. Each instruction is an instance | ||
32 | ** of the following structure. | ||
33 | */ | ||
34 | typedef struct VdbeOp Op; | ||
35 | |||
36 | /* | ||
37 | ** Boolean values | ||
38 | */ | ||
39 | typedef unsigned char Bool; | ||
40 | |||
41 | /* | ||
42 | ** A cursor is a pointer into a single BTree within a database file. | ||
43 | ** The cursor can seek to a BTree entry with a particular key, or | ||
44 | ** loop over all entries of the Btree. You can also insert new BTree | ||
45 | ** entries or retrieve the key or data from the entry that the cursor | ||
46 | ** is currently pointing to. | ||
47 | ** | ||
48 | ** Every cursor that the virtual machine has open is represented by an | ||
49 | ** instance of the following structure. | ||
50 | ** | ||
51 | ** If the Cursor.isTriggerRow flag is set it means that this cursor is | ||
52 | ** really a single row that represents the NEW or OLD pseudo-table of | ||
53 | ** a row trigger. The data for the row is stored in Cursor.pData and | ||
54 | ** the rowid is in Cursor.iKey. | ||
55 | */ | ||
56 | struct Cursor { | ||
57 | BtCursor *pCursor; /* The cursor structure of the backend */ | ||
58 | int iDb; /* Index of cursor database in db->aDb[] (or -1) */ | ||
59 | i64 lastRowid; /* Last rowid from a Next or NextIdx operation */ | ||
60 | i64 nextRowid; /* Next rowid returned by OP_NewRowid */ | ||
61 | Bool zeroed; /* True if zeroed out and ready for reuse */ | ||
62 | Bool rowidIsValid; /* True if lastRowid is valid */ | ||
63 | Bool atFirst; /* True if pointing to first entry */ | ||
64 | Bool useRandomRowid; /* Generate new record numbers semi-randomly */ | ||
65 | Bool nullRow; /* True if pointing to a row with no data */ | ||
66 | Bool nextRowidValid; /* True if the nextRowid field is valid */ | ||
67 | Bool pseudoTable; /* This is a NEW or OLD pseudo-tables of a trigger */ | ||
68 | Bool deferredMoveto; /* A call to sqlite3BtreeMoveto() is needed */ | ||
69 | Bool isTable; /* True if a table requiring integer keys */ | ||
70 | Bool isIndex; /* True if an index containing keys only - no data */ | ||
71 | u8 bogusIncrKey; /* Something for pIncrKey to point to if pKeyInfo==0 */ | ||
72 | i64 movetoTarget; /* Argument to the deferred sqlite3BtreeMoveto() */ | ||
73 | Btree *pBt; /* Separate file holding temporary table */ | ||
74 | int nData; /* Number of bytes in pData */ | ||
75 | char *pData; /* Data for a NEW or OLD pseudo-table */ | ||
76 | i64 iKey; /* Key for the NEW or OLD pseudo-table row */ | ||
77 | u8 *pIncrKey; /* Pointer to pKeyInfo->incrKey */ | ||
78 | KeyInfo *pKeyInfo; /* Info about index keys needed by index cursors */ | ||
79 | int nField; /* Number of fields in the header */ | ||
80 | i64 seqCount; /* Sequence counter */ | ||
81 | sqlite3_vtab_cursor *pVtabCursor; /* The cursor for a virtual table */ | ||
82 | const sqlite3_module *pModule; /* Module for cursor pVtabCursor */ | ||
83 | |||
84 | /* Cached information about the header for the data record that the | ||
85 | ** cursor is currently pointing to. Only valid if cacheValid is true. | ||
86 | ** aRow might point to (ephemeral) data for the current row, or it might | ||
87 | ** be NULL. | ||
88 | */ | ||
89 | int cacheStatus; /* Cache is valid if this matches Vdbe.cacheCtr */ | ||
90 | int payloadSize; /* Total number of bytes in the record */ | ||
91 | u32 *aType; /* Type values for all entries in the record */ | ||
92 | u32 *aOffset; /* Cached offsets to the start of each columns data */ | ||
93 | u8 *aRow; /* Data for the current row, if all on one page */ | ||
94 | }; | ||
95 | typedef struct Cursor Cursor; | ||
96 | |||
97 | /* | ||
98 | ** Number of bytes of string storage space available to each stack | ||
99 | ** layer without having to malloc. NBFS is short for Number of Bytes | ||
100 | ** For Strings. | ||
101 | */ | ||
102 | #define NBFS 32 | ||
103 | |||
104 | /* | ||
105 | ** A value for Cursor.cacheValid that means the cache is always invalid. | ||
106 | */ | ||
107 | #define CACHE_STALE 0 | ||
108 | |||
109 | /* | ||
110 | ** Internally, the vdbe manipulates nearly all SQL values as Mem | ||
111 | ** structures. Each Mem struct may cache multiple representations (string, | ||
112 | ** integer etc.) of the same value. A value (and therefore Mem structure) | ||
113 | ** has the following properties: | ||
114 | ** | ||
115 | ** Each value has a manifest type. The manifest type of the value stored | ||
116 | ** in a Mem struct is returned by the MemType(Mem*) macro. The type is | ||
117 | ** one of SQLITE_NULL, SQLITE_INTEGER, SQLITE_REAL, SQLITE_TEXT or | ||
118 | ** SQLITE_BLOB. | ||
119 | */ | ||
120 | struct Mem { | ||
121 | union { | ||
122 | i64 i; /* Integer value. Or FuncDef* when flags==MEM_Agg */ | ||
123 | FuncDef *pDef; /* Used only when flags==MEM_Agg */ | ||
124 | } u; | ||
125 | double r; /* Real value */ | ||
126 | sqlite3 *db; /* The associated database connection */ | ||
127 | char *z; /* String or BLOB value */ | ||
128 | int n; /* Number of characters in string value, including '\0' */ | ||
129 | u16 flags; /* Some combination of MEM_Null, MEM_Str, MEM_Dyn, etc. */ | ||
130 | u8 type; /* One of SQLITE_NULL, SQLITE_TEXT, SQLITE_INTEGER, etc */ | ||
131 | u8 enc; /* SQLITE_UTF8, SQLITE_UTF16BE, SQLITE_UTF16LE */ | ||
132 | void (*xDel)(void *); /* If not null, call this function to delete Mem.z */ | ||
133 | char zShort[NBFS]; /* Space for short strings */ | ||
134 | }; | ||
135 | typedef struct Mem Mem; | ||
136 | |||
137 | /* One or more of the following flags are set to indicate the validOK | ||
138 | ** representations of the value stored in the Mem struct. | ||
139 | ** | ||
140 | ** If the MEM_Null flag is set, then the value is an SQL NULL value. | ||
141 | ** No other flags may be set in this case. | ||
142 | ** | ||
143 | ** If the MEM_Str flag is set then Mem.z points at a string representation. | ||
144 | ** Usually this is encoded in the same unicode encoding as the main | ||
145 | ** database (see below for exceptions). If the MEM_Term flag is also | ||
146 | ** set, then the string is nul terminated. The MEM_Int and MEM_Real | ||
147 | ** flags may coexist with the MEM_Str flag. | ||
148 | ** | ||
149 | ** Multiple of these values can appear in Mem.flags. But only one | ||
150 | ** at a time can appear in Mem.type. | ||
151 | */ | ||
152 | #define MEM_Null 0x0001 /* Value is NULL */ | ||
153 | #define MEM_Str 0x0002 /* Value is a string */ | ||
154 | #define MEM_Int 0x0004 /* Value is an integer */ | ||
155 | #define MEM_Real 0x0008 /* Value is a real number */ | ||
156 | #define MEM_Blob 0x0010 /* Value is a BLOB */ | ||
157 | |||
158 | /* Whenever Mem contains a valid string or blob representation, one of | ||
159 | ** the following flags must be set to determine the memory management | ||
160 | ** policy for Mem.z. The MEM_Term flag tells us whether or not the | ||
161 | ** string is \000 or \u0000 terminated | ||
162 | */ | ||
163 | #define MEM_Term 0x0020 /* String rep is nul terminated */ | ||
164 | #define MEM_Dyn 0x0040 /* Need to call sqliteFree() on Mem.z */ | ||
165 | #define MEM_Static 0x0080 /* Mem.z points to a static string */ | ||
166 | #define MEM_Ephem 0x0100 /* Mem.z points to an ephemeral string */ | ||
167 | #define MEM_Short 0x0200 /* Mem.z points to Mem.zShort */ | ||
168 | #define MEM_Agg 0x0400 /* Mem.z points to an agg function context */ | ||
169 | #define MEM_Zero 0x0800 /* Mem.i contains count of 0s appended to blob */ | ||
170 | |||
171 | #ifdef SQLITE_OMIT_INCRBLOB | ||
172 | #undef MEM_Zero | ||
173 | #define MEM_Zero 0x0000 | ||
174 | #endif | ||
175 | |||
176 | |||
177 | /* A VdbeFunc is just a FuncDef (defined in sqliteInt.h) that contains | ||
178 | ** additional information about auxiliary information bound to arguments | ||
179 | ** of the function. This is used to implement the sqlite3_get_auxdata() | ||
180 | ** and sqlite3_set_auxdata() APIs. The "auxdata" is some auxiliary data | ||
181 | ** that can be associated with a constant argument to a function. This | ||
182 | ** allows functions such as "regexp" to compile their constant regular | ||
183 | ** expression argument once and reused the compiled code for multiple | ||
184 | ** invocations. | ||
185 | */ | ||
186 | struct VdbeFunc { | ||
187 | FuncDef *pFunc; /* The definition of the function */ | ||
188 | int nAux; /* Number of entries allocated for apAux[] */ | ||
189 | struct AuxData { | ||
190 | void *pAux; /* Aux data for the i-th argument */ | ||
191 | void (*xDelete)(void *); /* Destructor for the aux data */ | ||
192 | } apAux[1]; /* One slot for each function argument */ | ||
193 | }; | ||
194 | typedef struct VdbeFunc VdbeFunc; | ||
195 | |||
196 | /* | ||
197 | ** The "context" argument for a installable function. A pointer to an | ||
198 | ** instance of this structure is the first argument to the routines used | ||
199 | ** implement the SQL functions. | ||
200 | ** | ||
201 | ** There is a typedef for this structure in sqlite.h. So all routines, | ||
202 | ** even the public interface to SQLite, can use a pointer to this structure. | ||
203 | ** But this file is the only place where the internal details of this | ||
204 | ** structure are known. | ||
205 | ** | ||
206 | ** This structure is defined inside of vdbeInt.h because it uses substructures | ||
207 | ** (Mem) which are only defined there. | ||
208 | */ | ||
209 | struct sqlite3_context { | ||
210 | FuncDef *pFunc; /* Pointer to function information. MUST BE FIRST */ | ||
211 | VdbeFunc *pVdbeFunc; /* Auxilary data, if created. */ | ||
212 | Mem s; /* The return value is stored here */ | ||
213 | Mem *pMem; /* Memory cell used to store aggregate context */ | ||
214 | u8 isError; /* Set to true for an error */ | ||
215 | CollSeq *pColl; /* Collating sequence */ | ||
216 | }; | ||
217 | |||
218 | /* | ||
219 | ** A Set structure is used for quick testing to see if a value | ||
220 | ** is part of a small set. Sets are used to implement code like | ||
221 | ** this: | ||
222 | ** x.y IN ('hi','hoo','hum') | ||
223 | */ | ||
224 | typedef struct Set Set; | ||
225 | struct Set { | ||
226 | Hash hash; /* A set is just a hash table */ | ||
227 | HashElem *prev; /* Previously accessed hash elemen */ | ||
228 | }; | ||
229 | |||
230 | /* | ||
231 | ** A FifoPage structure holds a single page of valves. Pages are arranged | ||
232 | ** in a list. | ||
233 | */ | ||
234 | typedef struct FifoPage FifoPage; | ||
235 | struct FifoPage { | ||
236 | int nSlot; /* Number of entries aSlot[] */ | ||
237 | int iWrite; /* Push the next value into this entry in aSlot[] */ | ||
238 | int iRead; /* Read the next value from this entry in aSlot[] */ | ||
239 | FifoPage *pNext; /* Next page in the fifo */ | ||
240 | i64 aSlot[1]; /* One or more slots for rowid values */ | ||
241 | }; | ||
242 | |||
243 | /* | ||
244 | ** The Fifo structure is typedef-ed in vdbeInt.h. But the implementation | ||
245 | ** of that structure is private to this file. | ||
246 | ** | ||
247 | ** The Fifo structure describes the entire fifo. | ||
248 | */ | ||
249 | typedef struct Fifo Fifo; | ||
250 | struct Fifo { | ||
251 | int nEntry; /* Total number of entries */ | ||
252 | FifoPage *pFirst; /* First page on the list */ | ||
253 | FifoPage *pLast; /* Last page on the list */ | ||
254 | }; | ||
255 | |||
256 | /* | ||
257 | ** A Context stores the last insert rowid, the last statement change count, | ||
258 | ** and the current statement change count (i.e. changes since last statement). | ||
259 | ** The current keylist is also stored in the context. | ||
260 | ** Elements of Context structure type make up the ContextStack, which is | ||
261 | ** updated by the ContextPush and ContextPop opcodes (used by triggers). | ||
262 | ** The context is pushed before executing a trigger a popped when the | ||
263 | ** trigger finishes. | ||
264 | */ | ||
265 | typedef struct Context Context; | ||
266 | struct Context { | ||
267 | i64 lastRowid; /* Last insert rowid (sqlite3.lastRowid) */ | ||
268 | int nChange; /* Statement changes (Vdbe.nChanges) */ | ||
269 | Fifo sFifo; /* Records that will participate in a DELETE or UPDATE */ | ||
270 | }; | ||
271 | |||
272 | /* | ||
273 | ** An instance of the virtual machine. This structure contains the complete | ||
274 | ** state of the virtual machine. | ||
275 | ** | ||
276 | ** The "sqlite3_stmt" structure pointer that is returned by sqlite3_compile() | ||
277 | ** is really a pointer to an instance of this structure. | ||
278 | ** | ||
279 | ** The Vdbe.inVtabMethod variable is set to non-zero for the duration of | ||
280 | ** any virtual table method invocations made by the vdbe program. It is | ||
281 | ** set to 2 for xDestroy method calls and 1 for all other methods. This | ||
282 | ** variable is used for two purposes: to allow xDestroy methods to execute | ||
283 | ** "DROP TABLE" statements and to prevent some nasty side effects of | ||
284 | ** malloc failure when SQLite is invoked recursively by a virtual table | ||
285 | ** method function. | ||
286 | */ | ||
287 | struct Vdbe { | ||
288 | sqlite3 *db; /* The whole database */ | ||
289 | Vdbe *pPrev,*pNext; /* Linked list of VDBEs with the same Vdbe.db */ | ||
290 | int nOp; /* Number of instructions in the program */ | ||
291 | int nOpAlloc; /* Number of slots allocated for aOp[] */ | ||
292 | Op *aOp; /* Space to hold the virtual machine's program */ | ||
293 | int nLabel; /* Number of labels used */ | ||
294 | int nLabelAlloc; /* Number of slots allocated in aLabel[] */ | ||
295 | int *aLabel; /* Space to hold the labels */ | ||
296 | Mem *aStack; /* The operand stack, except string values */ | ||
297 | Mem *pTos; /* Top entry in the operand stack */ | ||
298 | Mem **apArg; /* Arguments to currently executing user function */ | ||
299 | Mem *aColName; /* Column names to return */ | ||
300 | int nCursor; /* Number of slots in apCsr[] */ | ||
301 | Cursor **apCsr; /* One element of this array for each open cursor */ | ||
302 | int nVar; /* Number of entries in aVar[] */ | ||
303 | Mem *aVar; /* Values for the OP_Variable opcode. */ | ||
304 | char **azVar; /* Name of variables */ | ||
305 | int okVar; /* True if azVar[] has been initialized */ | ||
306 | int magic; /* Magic number for sanity checking */ | ||
307 | int nMem; /* Number of memory locations currently allocated */ | ||
308 | Mem *aMem; /* The memory locations */ | ||
309 | int nCallback; /* Number of callbacks invoked so far */ | ||
310 | int cacheCtr; /* Cursor row cache generation counter */ | ||
311 | Fifo sFifo; /* A list of ROWIDs */ | ||
312 | int contextStackTop; /* Index of top element in the context stack */ | ||
313 | int contextStackDepth; /* The size of the "context" stack */ | ||
314 | Context *contextStack; /* Stack used by opcodes ContextPush & ContextPop*/ | ||
315 | int pc; /* The program counter */ | ||
316 | int rc; /* Value to return */ | ||
317 | unsigned uniqueCnt; /* Used by OP_MakeRecord when P2!=0 */ | ||
318 | int errorAction; /* Recovery action to do in case of an error */ | ||
319 | int inTempTrans; /* True if temp database is transactioned */ | ||
320 | int returnStack[25]; /* Return address stack for OP_Gosub & OP_Return */ | ||
321 | int returnDepth; /* Next unused element in returnStack[] */ | ||
322 | int nResColumn; /* Number of columns in one row of the result set */ | ||
323 | char **azResColumn; /* Values for one row of result */ | ||
324 | int popStack; /* Pop the stack this much on entry to VdbeExec() */ | ||
325 | char *zErrMsg; /* Error message written here */ | ||
326 | u8 resOnStack; /* True if there are result values on the stack */ | ||
327 | u8 explain; /* True if EXPLAIN present on SQL command */ | ||
328 | u8 changeCntOn; /* True to update the change-counter */ | ||
329 | u8 aborted; /* True if ROLLBACK in another VM causes an abort */ | ||
330 | u8 expired; /* True if the VM needs to be recompiled */ | ||
331 | u8 minWriteFileFormat; /* Minimum file format for writable database files */ | ||
332 | u8 inVtabMethod; /* See comments above */ | ||
333 | int nChange; /* Number of db changes made since last reset */ | ||
334 | i64 startTime; /* Time when query started - used for profiling */ | ||
335 | int btreeMask; /* Bitmask of db->aDb[] entries referenced */ | ||
336 | BtreeMutexArray aMutex; /* An array of Btree used here and needing locks */ | ||
337 | int nSql; /* Number of bytes in zSql */ | ||
338 | char *zSql; /* Text of the SQL statement that generated this */ | ||
339 | #ifdef SQLITE_DEBUG | ||
340 | FILE *trace; /* Write an execution trace here, if not NULL */ | ||
341 | #endif | ||
342 | int openedStatement; /* True if this VM has opened a statement journal */ | ||
343 | #ifdef SQLITE_SSE | ||
344 | int fetchId; /* Statement number used by sqlite3_fetch_statement */ | ||
345 | int lru; /* Counter used for LRU cache replacement */ | ||
346 | #endif | ||
347 | }; | ||
348 | |||
349 | /* | ||
350 | ** The following are allowed values for Vdbe.magic | ||
351 | */ | ||
352 | #define VDBE_MAGIC_INIT 0x26bceaa5 /* Building a VDBE program */ | ||
353 | #define VDBE_MAGIC_RUN 0xbdf20da3 /* VDBE is ready to execute */ | ||
354 | #define VDBE_MAGIC_HALT 0x519c2973 /* VDBE has completed execution */ | ||
355 | #define VDBE_MAGIC_DEAD 0xb606c3c8 /* The VDBE has been deallocated */ | ||
356 | |||
357 | /* | ||
358 | ** Function prototypes | ||
359 | */ | ||
360 | void sqlite3VdbeFreeCursor(Vdbe *, Cursor*); | ||
361 | void sqliteVdbePopStack(Vdbe*,int); | ||
362 | int sqlite3VdbeCursorMoveto(Cursor*); | ||
363 | #if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE) | ||
364 | void sqlite3VdbePrintOp(FILE*, int, Op*); | ||
365 | #endif | ||
366 | int sqlite3VdbeSerialTypeLen(u32); | ||
367 | u32 sqlite3VdbeSerialType(Mem*, int); | ||
368 | int sqlite3VdbeSerialPut(unsigned char*, int, Mem*, int); | ||
369 | int sqlite3VdbeSerialGet(const unsigned char*, u32, Mem*); | ||
370 | void sqlite3VdbeDeleteAuxData(VdbeFunc*, int); | ||
371 | |||
372 | int sqlite2BtreeKeyCompare(BtCursor *, const void *, int, int, int *); | ||
373 | int sqlite3VdbeIdxKeyCompare(Cursor*,int,const unsigned char*,int*); | ||
374 | int sqlite3VdbeIdxRowid(BtCursor *, i64 *); | ||
375 | int sqlite3MemCompare(const Mem*, const Mem*, const CollSeq*); | ||
376 | int sqlite3VdbeRecordCompare(void*,int,const void*,int, const void*); | ||
377 | int sqlite3VdbeIdxRowidLen(const u8*); | ||
378 | int sqlite3VdbeExec(Vdbe*); | ||
379 | int sqlite3VdbeList(Vdbe*); | ||
380 | int sqlite3VdbeHalt(Vdbe*); | ||
381 | int sqlite3VdbeChangeEncoding(Mem *, int); | ||
382 | int sqlite3VdbeMemTooBig(Mem*); | ||
383 | int sqlite3VdbeMemCopy(Mem*, const Mem*); | ||
384 | void sqlite3VdbeMemShallowCopy(Mem*, const Mem*, int); | ||
385 | int sqlite3VdbeMemMove(Mem*, Mem*); | ||
386 | int sqlite3VdbeMemNulTerminate(Mem*); | ||
387 | int sqlite3VdbeMemSetStr(Mem*, const char*, int, u8, void(*)(void*)); | ||
388 | void sqlite3VdbeMemSetInt64(Mem*, i64); | ||
389 | void sqlite3VdbeMemSetDouble(Mem*, double); | ||
390 | void sqlite3VdbeMemSetNull(Mem*); | ||
391 | void sqlite3VdbeMemSetZeroBlob(Mem*,int); | ||
392 | int sqlite3VdbeMemMakeWriteable(Mem*); | ||
393 | int sqlite3VdbeMemDynamicify(Mem*); | ||
394 | int sqlite3VdbeMemStringify(Mem*, int); | ||
395 | i64 sqlite3VdbeIntValue(Mem*); | ||
396 | int sqlite3VdbeMemIntegerify(Mem*); | ||
397 | double sqlite3VdbeRealValue(Mem*); | ||
398 | void sqlite3VdbeIntegerAffinity(Mem*); | ||
399 | int sqlite3VdbeMemRealify(Mem*); | ||
400 | int sqlite3VdbeMemNumerify(Mem*); | ||
401 | int sqlite3VdbeMemFromBtree(BtCursor*,int,int,int,Mem*); | ||
402 | void sqlite3VdbeMemRelease(Mem *p); | ||
403 | int sqlite3VdbeMemFinalize(Mem*, FuncDef*); | ||
404 | const char *sqlite3OpcodeName(int); | ||
405 | |||
406 | #ifndef NDEBUG | ||
407 | void sqlite3VdbeMemSanity(Mem*); | ||
408 | int sqlite3VdbeOpcodeNoPush(u8); | ||
409 | #endif | ||
410 | int sqlite3VdbeMemTranslate(Mem*, u8); | ||
411 | #ifdef SQLITE_DEBUG | ||
412 | void sqlite3VdbePrintSql(Vdbe*); | ||
413 | void sqlite3VdbeMemPrettyPrint(Mem *pMem, char *zBuf); | ||
414 | #endif | ||
415 | int sqlite3VdbeMemHandleBom(Mem *pMem); | ||
416 | void sqlite3VdbeFifoInit(Fifo*); | ||
417 | int sqlite3VdbeFifoPush(Fifo*, i64); | ||
418 | int sqlite3VdbeFifoPop(Fifo*, i64*); | ||
419 | void sqlite3VdbeFifoClear(Fifo*); | ||
420 | |||
421 | #ifndef SQLITE_OMIT_INCRBLOB | ||
422 | int sqlite3VdbeMemExpandBlob(Mem *); | ||
423 | #else | ||
424 | #define sqlite3VdbeMemExpandBlob(x) SQLITE_OK | ||
425 | #endif | ||
426 | |||
427 | #endif /* !defined(_VDBEINT_H_) */ | ||