diff options
Diffstat (limited to '')
-rwxr-xr-x | libraries/sqlite/win32/util.c | 706 |
1 files changed, 706 insertions, 0 deletions
diff --git a/libraries/sqlite/win32/util.c b/libraries/sqlite/win32/util.c new file mode 100755 index 0000000..722df63 --- /dev/null +++ b/libraries/sqlite/win32/util.c | |||
@@ -0,0 +1,706 @@ | |||
1 | /* | ||
2 | ** 2001 September 15 | ||
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 | ** Utility functions used throughout sqlite. | ||
13 | ** | ||
14 | ** This file contains functions for allocating memory, comparing | ||
15 | ** strings, and stuff like that. | ||
16 | ** | ||
17 | ** $Id: util.c,v 1.212 2007/09/01 10:01:13 danielk1977 Exp $ | ||
18 | */ | ||
19 | #include "sqliteInt.h" | ||
20 | #include <stdarg.h> | ||
21 | #include <ctype.h> | ||
22 | |||
23 | |||
24 | /* | ||
25 | ** Set the most recent error code and error string for the sqlite | ||
26 | ** handle "db". The error code is set to "err_code". | ||
27 | ** | ||
28 | ** If it is not NULL, string zFormat specifies the format of the | ||
29 | ** error string in the style of the printf functions: The following | ||
30 | ** format characters are allowed: | ||
31 | ** | ||
32 | ** %s Insert a string | ||
33 | ** %z A string that should be freed after use | ||
34 | ** %d Insert an integer | ||
35 | ** %T Insert a token | ||
36 | ** %S Insert the first element of a SrcList | ||
37 | ** | ||
38 | ** zFormat and any string tokens that follow it are assumed to be | ||
39 | ** encoded in UTF-8. | ||
40 | ** | ||
41 | ** To clear the most recent error for sqlite handle "db", sqlite3Error | ||
42 | ** should be called with err_code set to SQLITE_OK and zFormat set | ||
43 | ** to NULL. | ||
44 | */ | ||
45 | void sqlite3Error(sqlite3 *db, int err_code, const char *zFormat, ...){ | ||
46 | if( db && (db->pErr || (db->pErr = sqlite3ValueNew(db))!=0) ){ | ||
47 | db->errCode = err_code; | ||
48 | if( zFormat ){ | ||
49 | char *z; | ||
50 | va_list ap; | ||
51 | va_start(ap, zFormat); | ||
52 | z = sqlite3VMPrintf(db, zFormat, ap); | ||
53 | va_end(ap); | ||
54 | sqlite3ValueSetStr(db->pErr, -1, z, SQLITE_UTF8, sqlite3_free); | ||
55 | }else{ | ||
56 | sqlite3ValueSetStr(db->pErr, 0, 0, SQLITE_UTF8, SQLITE_STATIC); | ||
57 | } | ||
58 | } | ||
59 | } | ||
60 | |||
61 | /* | ||
62 | ** Add an error message to pParse->zErrMsg and increment pParse->nErr. | ||
63 | ** The following formatting characters are allowed: | ||
64 | ** | ||
65 | ** %s Insert a string | ||
66 | ** %z A string that should be freed after use | ||
67 | ** %d Insert an integer | ||
68 | ** %T Insert a token | ||
69 | ** %S Insert the first element of a SrcList | ||
70 | ** | ||
71 | ** This function should be used to report any error that occurs whilst | ||
72 | ** compiling an SQL statement (i.e. within sqlite3_prepare()). The | ||
73 | ** last thing the sqlite3_prepare() function does is copy the error | ||
74 | ** stored by this function into the database handle using sqlite3Error(). | ||
75 | ** Function sqlite3Error() should be used during statement execution | ||
76 | ** (sqlite3_step() etc.). | ||
77 | */ | ||
78 | void sqlite3ErrorMsg(Parse *pParse, const char *zFormat, ...){ | ||
79 | va_list ap; | ||
80 | pParse->nErr++; | ||
81 | sqlite3_free(pParse->zErrMsg); | ||
82 | va_start(ap, zFormat); | ||
83 | pParse->zErrMsg = sqlite3VMPrintf(pParse->db, zFormat, ap); | ||
84 | va_end(ap); | ||
85 | if( pParse->rc==SQLITE_OK ){ | ||
86 | pParse->rc = SQLITE_ERROR; | ||
87 | } | ||
88 | } | ||
89 | |||
90 | /* | ||
91 | ** Clear the error message in pParse, if any | ||
92 | */ | ||
93 | void sqlite3ErrorClear(Parse *pParse){ | ||
94 | sqlite3_free(pParse->zErrMsg); | ||
95 | pParse->zErrMsg = 0; | ||
96 | pParse->nErr = 0; | ||
97 | } | ||
98 | |||
99 | /* | ||
100 | ** Convert an SQL-style quoted string into a normal string by removing | ||
101 | ** the quote characters. The conversion is done in-place. If the | ||
102 | ** input does not begin with a quote character, then this routine | ||
103 | ** is a no-op. | ||
104 | ** | ||
105 | ** 2002-Feb-14: This routine is extended to remove MS-Access style | ||
106 | ** brackets from around identifers. For example: "[a-b-c]" becomes | ||
107 | ** "a-b-c". | ||
108 | */ | ||
109 | void sqlite3Dequote(char *z){ | ||
110 | int quote; | ||
111 | int i, j; | ||
112 | if( z==0 ) return; | ||
113 | quote = z[0]; | ||
114 | switch( quote ){ | ||
115 | case '\'': break; | ||
116 | case '"': break; | ||
117 | case '`': break; /* For MySQL compatibility */ | ||
118 | case '[': quote = ']'; break; /* For MS SqlServer compatibility */ | ||
119 | default: return; | ||
120 | } | ||
121 | for(i=1, j=0; z[i]; i++){ | ||
122 | if( z[i]==quote ){ | ||
123 | if( z[i+1]==quote ){ | ||
124 | z[j++] = quote; | ||
125 | i++; | ||
126 | }else{ | ||
127 | z[j++] = 0; | ||
128 | break; | ||
129 | } | ||
130 | }else{ | ||
131 | z[j++] = z[i]; | ||
132 | } | ||
133 | } | ||
134 | } | ||
135 | |||
136 | /* An array to map all upper-case characters into their corresponding | ||
137 | ** lower-case character. | ||
138 | */ | ||
139 | const unsigned char sqlite3UpperToLower[] = { | ||
140 | #ifdef SQLITE_ASCII | ||
141 | 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, | ||
142 | 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, | ||
143 | 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, | ||
144 | 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 97, 98, 99,100,101,102,103, | ||
145 | 104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121, | ||
146 | 122, 91, 92, 93, 94, 95, 96, 97, 98, 99,100,101,102,103,104,105,106,107, | ||
147 | 108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125, | ||
148 | 126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143, | ||
149 | 144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161, | ||
150 | 162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179, | ||
151 | 180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197, | ||
152 | 198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215, | ||
153 | 216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233, | ||
154 | 234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251, | ||
155 | 252,253,254,255 | ||
156 | #endif | ||
157 | #ifdef SQLITE_EBCDIC | ||
158 | 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, /* 0x */ | ||
159 | 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, /* 1x */ | ||
160 | 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, /* 2x */ | ||
161 | 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, /* 3x */ | ||
162 | 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, /* 4x */ | ||
163 | 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, /* 5x */ | ||
164 | 96, 97, 66, 67, 68, 69, 70, 71, 72, 73,106,107,108,109,110,111, /* 6x */ | ||
165 | 112, 81, 82, 83, 84, 85, 86, 87, 88, 89,122,123,124,125,126,127, /* 7x */ | ||
166 | 128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143, /* 8x */ | ||
167 | 144,145,146,147,148,149,150,151,152,153,154,155,156,157,156,159, /* 9x */ | ||
168 | 160,161,162,163,164,165,166,167,168,169,170,171,140,141,142,175, /* Ax */ | ||
169 | 176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191, /* Bx */ | ||
170 | 192,129,130,131,132,133,134,135,136,137,202,203,204,205,206,207, /* Cx */ | ||
171 | 208,145,146,147,148,149,150,151,152,153,218,219,220,221,222,223, /* Dx */ | ||
172 | 224,225,162,163,164,165,166,167,168,169,232,203,204,205,206,207, /* Ex */ | ||
173 | 239,240,241,242,243,244,245,246,247,248,249,219,220,221,222,255, /* Fx */ | ||
174 | #endif | ||
175 | }; | ||
176 | #define UpperToLower sqlite3UpperToLower | ||
177 | |||
178 | /* | ||
179 | ** Some systems have stricmp(). Others have strcasecmp(). Because | ||
180 | ** there is no consistency, we will define our own. | ||
181 | */ | ||
182 | int sqlite3StrICmp(const char *zLeft, const char *zRight){ | ||
183 | register unsigned char *a, *b; | ||
184 | a = (unsigned char *)zLeft; | ||
185 | b = (unsigned char *)zRight; | ||
186 | while( *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; } | ||
187 | return UpperToLower[*a] - UpperToLower[*b]; | ||
188 | } | ||
189 | int sqlite3StrNICmp(const char *zLeft, const char *zRight, int N){ | ||
190 | register unsigned char *a, *b; | ||
191 | a = (unsigned char *)zLeft; | ||
192 | b = (unsigned char *)zRight; | ||
193 | while( N-- > 0 && *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; } | ||
194 | return N<0 ? 0 : UpperToLower[*a] - UpperToLower[*b]; | ||
195 | } | ||
196 | |||
197 | /* | ||
198 | ** Return TRUE if z is a pure numeric string. Return FALSE if the | ||
199 | ** string contains any character which is not part of a number. If | ||
200 | ** the string is numeric and contains the '.' character, set *realnum | ||
201 | ** to TRUE (otherwise FALSE). | ||
202 | ** | ||
203 | ** An empty string is considered non-numeric. | ||
204 | */ | ||
205 | int sqlite3IsNumber(const char *z, int *realnum, u8 enc){ | ||
206 | int incr = (enc==SQLITE_UTF8?1:2); | ||
207 | if( enc==SQLITE_UTF16BE ) z++; | ||
208 | if( *z=='-' || *z=='+' ) z += incr; | ||
209 | if( !isdigit(*(u8*)z) ){ | ||
210 | return 0; | ||
211 | } | ||
212 | z += incr; | ||
213 | if( realnum ) *realnum = 0; | ||
214 | while( isdigit(*(u8*)z) ){ z += incr; } | ||
215 | if( *z=='.' ){ | ||
216 | z += incr; | ||
217 | if( !isdigit(*(u8*)z) ) return 0; | ||
218 | while( isdigit(*(u8*)z) ){ z += incr; } | ||
219 | if( realnum ) *realnum = 1; | ||
220 | } | ||
221 | if( *z=='e' || *z=='E' ){ | ||
222 | z += incr; | ||
223 | if( *z=='+' || *z=='-' ) z += incr; | ||
224 | if( !isdigit(*(u8*)z) ) return 0; | ||
225 | while( isdigit(*(u8*)z) ){ z += incr; } | ||
226 | if( realnum ) *realnum = 1; | ||
227 | } | ||
228 | return *z==0; | ||
229 | } | ||
230 | |||
231 | /* | ||
232 | ** The string z[] is an ascii representation of a real number. | ||
233 | ** Convert this string to a double. | ||
234 | ** | ||
235 | ** This routine assumes that z[] really is a valid number. If it | ||
236 | ** is not, the result is undefined. | ||
237 | ** | ||
238 | ** This routine is used instead of the library atof() function because | ||
239 | ** the library atof() might want to use "," as the decimal point instead | ||
240 | ** of "." depending on how locale is set. But that would cause problems | ||
241 | ** for SQL. So this routine always uses "." regardless of locale. | ||
242 | */ | ||
243 | int sqlite3AtoF(const char *z, double *pResult){ | ||
244 | #ifndef SQLITE_OMIT_FLOATING_POINT | ||
245 | int sign = 1; | ||
246 | const char *zBegin = z; | ||
247 | LONGDOUBLE_TYPE v1 = 0.0; | ||
248 | while( isspace(*(u8*)z) ) z++; | ||
249 | if( *z=='-' ){ | ||
250 | sign = -1; | ||
251 | z++; | ||
252 | }else if( *z=='+' ){ | ||
253 | z++; | ||
254 | } | ||
255 | while( isdigit(*(u8*)z) ){ | ||
256 | v1 = v1*10.0 + (*z - '0'); | ||
257 | z++; | ||
258 | } | ||
259 | if( *z=='.' ){ | ||
260 | LONGDOUBLE_TYPE divisor = 1.0; | ||
261 | z++; | ||
262 | while( isdigit(*(u8*)z) ){ | ||
263 | v1 = v1*10.0 + (*z - '0'); | ||
264 | divisor *= 10.0; | ||
265 | z++; | ||
266 | } | ||
267 | v1 /= divisor; | ||
268 | } | ||
269 | if( *z=='e' || *z=='E' ){ | ||
270 | int esign = 1; | ||
271 | int eval = 0; | ||
272 | LONGDOUBLE_TYPE scale = 1.0; | ||
273 | z++; | ||
274 | if( *z=='-' ){ | ||
275 | esign = -1; | ||
276 | z++; | ||
277 | }else if( *z=='+' ){ | ||
278 | z++; | ||
279 | } | ||
280 | while( isdigit(*(u8*)z) ){ | ||
281 | eval = eval*10 + *z - '0'; | ||
282 | z++; | ||
283 | } | ||
284 | while( eval>=64 ){ scale *= 1.0e+64; eval -= 64; } | ||
285 | while( eval>=16 ){ scale *= 1.0e+16; eval -= 16; } | ||
286 | while( eval>=4 ){ scale *= 1.0e+4; eval -= 4; } | ||
287 | while( eval>=1 ){ scale *= 1.0e+1; eval -= 1; } | ||
288 | if( esign<0 ){ | ||
289 | v1 /= scale; | ||
290 | }else{ | ||
291 | v1 *= scale; | ||
292 | } | ||
293 | } | ||
294 | *pResult = sign<0 ? -v1 : v1; | ||
295 | return z - zBegin; | ||
296 | #else | ||
297 | return sqlite3Atoi64(z, pResult); | ||
298 | #endif /* SQLITE_OMIT_FLOATING_POINT */ | ||
299 | } | ||
300 | |||
301 | /* | ||
302 | ** Compare the 19-character string zNum against the text representation | ||
303 | ** value 2^63: 9223372036854775808. Return negative, zero, or positive | ||
304 | ** if zNum is less than, equal to, or greater than the string. | ||
305 | ** | ||
306 | ** Unlike memcmp() this routine is guaranteed to return the difference | ||
307 | ** in the values of the last digit if the only difference is in the | ||
308 | ** last digit. So, for example, | ||
309 | ** | ||
310 | ** compare2pow63("9223372036854775800") | ||
311 | ** | ||
312 | ** will return -8. | ||
313 | */ | ||
314 | static int compare2pow63(const char *zNum){ | ||
315 | int c; | ||
316 | c = memcmp(zNum,"922337203685477580",18); | ||
317 | if( c==0 ){ | ||
318 | c = zNum[18] - '8'; | ||
319 | } | ||
320 | return c; | ||
321 | } | ||
322 | |||
323 | |||
324 | /* | ||
325 | ** Return TRUE if zNum is a 64-bit signed integer and write | ||
326 | ** the value of the integer into *pNum. If zNum is not an integer | ||
327 | ** or is an integer that is too large to be expressed with 64 bits, | ||
328 | ** then return false. | ||
329 | ** | ||
330 | ** When this routine was originally written it dealt with only | ||
331 | ** 32-bit numbers. At that time, it was much faster than the | ||
332 | ** atoi() library routine in RedHat 7.2. | ||
333 | */ | ||
334 | int sqlite3Atoi64(const char *zNum, i64 *pNum){ | ||
335 | i64 v = 0; | ||
336 | int neg; | ||
337 | int i, c; | ||
338 | while( isspace(*(u8*)zNum) ) zNum++; | ||
339 | if( *zNum=='-' ){ | ||
340 | neg = 1; | ||
341 | zNum++; | ||
342 | }else if( *zNum=='+' ){ | ||
343 | neg = 0; | ||
344 | zNum++; | ||
345 | }else{ | ||
346 | neg = 0; | ||
347 | } | ||
348 | while( zNum[0]=='0' ){ zNum++; } /* Skip over leading zeros. Ticket #2454 */ | ||
349 | for(i=0; (c=zNum[i])>='0' && c<='9'; i++){ | ||
350 | v = v*10 + c - '0'; | ||
351 | } | ||
352 | *pNum = neg ? -v : v; | ||
353 | if( c!=0 || i==0 || i>19 ){ | ||
354 | /* zNum is empty or contains non-numeric text or is longer | ||
355 | ** than 19 digits (thus guaranting that it is too large) */ | ||
356 | return 0; | ||
357 | }else if( i<19 ){ | ||
358 | /* Less than 19 digits, so we know that it fits in 64 bits */ | ||
359 | return 1; | ||
360 | }else{ | ||
361 | /* 19-digit numbers must be no larger than 9223372036854775807 if positive | ||
362 | ** or 9223372036854775808 if negative. Note that 9223372036854665808 | ||
363 | ** is 2^63. */ | ||
364 | return compare2pow63(zNum)<neg; | ||
365 | } | ||
366 | } | ||
367 | |||
368 | /* | ||
369 | ** The string zNum represents an integer. There might be some other | ||
370 | ** information following the integer too, but that part is ignored. | ||
371 | ** If the integer that the prefix of zNum represents will fit in a | ||
372 | ** 64-bit signed integer, return TRUE. Otherwise return FALSE. | ||
373 | ** | ||
374 | ** This routine returns FALSE for the string -9223372036854775808 even that | ||
375 | ** that number will, in theory fit in a 64-bit integer. Positive | ||
376 | ** 9223373036854775808 will not fit in 64 bits. So it seems safer to return | ||
377 | ** false. | ||
378 | */ | ||
379 | int sqlite3FitsIn64Bits(const char *zNum){ | ||
380 | int i, c; | ||
381 | int neg = 0; | ||
382 | if( *zNum=='-' ){ | ||
383 | neg = 1; | ||
384 | zNum++; | ||
385 | }else if( *zNum=='+' ){ | ||
386 | zNum++; | ||
387 | } | ||
388 | while( *zNum=='0' ){ | ||
389 | zNum++; /* Skip leading zeros. Ticket #2454 */ | ||
390 | } | ||
391 | for(i=0; (c=zNum[i])>='0' && c<='9'; i++){} | ||
392 | if( i<19 ){ | ||
393 | /* Guaranteed to fit if less than 19 digits */ | ||
394 | return 1; | ||
395 | }else if( i>19 ){ | ||
396 | /* Guaranteed to be too big if greater than 19 digits */ | ||
397 | return 0; | ||
398 | }else{ | ||
399 | /* Compare against 2^63. */ | ||
400 | return compare2pow63(zNum)<neg; | ||
401 | } | ||
402 | } | ||
403 | |||
404 | /* | ||
405 | ** If zNum represents an integer that will fit in 32-bits, then set | ||
406 | ** *pValue to that integer and return true. Otherwise return false. | ||
407 | ** | ||
408 | ** Any non-numeric characters that following zNum are ignored. | ||
409 | ** This is different from sqlite3Atoi64() which requires the | ||
410 | ** input number to be zero-terminated. | ||
411 | */ | ||
412 | int sqlite3GetInt32(const char *zNum, int *pValue){ | ||
413 | sqlite_int64 v = 0; | ||
414 | int i, c; | ||
415 | int neg = 0; | ||
416 | if( zNum[0]=='-' ){ | ||
417 | neg = 1; | ||
418 | zNum++; | ||
419 | }else if( zNum[0]=='+' ){ | ||
420 | zNum++; | ||
421 | } | ||
422 | while( zNum[0]=='0' ) zNum++; | ||
423 | for(i=0; i<11 && (c = zNum[i] - '0')>=0 && c<=9; i++){ | ||
424 | v = v*10 + c; | ||
425 | } | ||
426 | |||
427 | /* The longest decimal representation of a 32 bit integer is 10 digits: | ||
428 | ** | ||
429 | ** 1234567890 | ||
430 | ** 2^31 -> 2147483648 | ||
431 | */ | ||
432 | if( i>10 ){ | ||
433 | return 0; | ||
434 | } | ||
435 | if( v-neg>2147483647 ){ | ||
436 | return 0; | ||
437 | } | ||
438 | if( neg ){ | ||
439 | v = -v; | ||
440 | } | ||
441 | *pValue = (int)v; | ||
442 | return 1; | ||
443 | } | ||
444 | |||
445 | /* | ||
446 | ** Check to make sure we have a valid db pointer. This test is not | ||
447 | ** foolproof but it does provide some measure of protection against | ||
448 | ** misuse of the interface such as passing in db pointers that are | ||
449 | ** NULL or which have been previously closed. If this routine returns | ||
450 | ** TRUE it means that the db pointer is invalid and should not be | ||
451 | ** dereferenced for any reason. The calling function should invoke | ||
452 | ** SQLITE_MISUSE immediately. | ||
453 | */ | ||
454 | int sqlite3SafetyCheck(sqlite3 *db){ | ||
455 | int magic; | ||
456 | if( db==0 ) return 1; | ||
457 | magic = db->magic; | ||
458 | if( magic!=SQLITE_MAGIC_CLOSED && | ||
459 | magic!=SQLITE_MAGIC_OPEN && | ||
460 | magic!=SQLITE_MAGIC_BUSY ) return 1; | ||
461 | return 0; | ||
462 | } | ||
463 | |||
464 | /* | ||
465 | ** The variable-length integer encoding is as follows: | ||
466 | ** | ||
467 | ** KEY: | ||
468 | ** A = 0xxxxxxx 7 bits of data and one flag bit | ||
469 | ** B = 1xxxxxxx 7 bits of data and one flag bit | ||
470 | ** C = xxxxxxxx 8 bits of data | ||
471 | ** | ||
472 | ** 7 bits - A | ||
473 | ** 14 bits - BA | ||
474 | ** 21 bits - BBA | ||
475 | ** 28 bits - BBBA | ||
476 | ** 35 bits - BBBBA | ||
477 | ** 42 bits - BBBBBA | ||
478 | ** 49 bits - BBBBBBA | ||
479 | ** 56 bits - BBBBBBBA | ||
480 | ** 64 bits - BBBBBBBBC | ||
481 | */ | ||
482 | |||
483 | /* | ||
484 | ** Write a 64-bit variable-length integer to memory starting at p[0]. | ||
485 | ** The length of data write will be between 1 and 9 bytes. The number | ||
486 | ** of bytes written is returned. | ||
487 | ** | ||
488 | ** A variable-length integer consists of the lower 7 bits of each byte | ||
489 | ** for all bytes that have the 8th bit set and one byte with the 8th | ||
490 | ** bit clear. Except, if we get to the 9th byte, it stores the full | ||
491 | ** 8 bits and is the last byte. | ||
492 | */ | ||
493 | int sqlite3PutVarint(unsigned char *p, u64 v){ | ||
494 | int i, j, n; | ||
495 | u8 buf[10]; | ||
496 | if( v & (((u64)0xff000000)<<32) ){ | ||
497 | p[8] = v; | ||
498 | v >>= 8; | ||
499 | for(i=7; i>=0; i--){ | ||
500 | p[i] = (v & 0x7f) | 0x80; | ||
501 | v >>= 7; | ||
502 | } | ||
503 | return 9; | ||
504 | } | ||
505 | n = 0; | ||
506 | do{ | ||
507 | buf[n++] = (v & 0x7f) | 0x80; | ||
508 | v >>= 7; | ||
509 | }while( v!=0 ); | ||
510 | buf[0] &= 0x7f; | ||
511 | assert( n<=9 ); | ||
512 | for(i=0, j=n-1; j>=0; j--, i++){ | ||
513 | p[i] = buf[j]; | ||
514 | } | ||
515 | return n; | ||
516 | } | ||
517 | |||
518 | /* | ||
519 | ** Read a 64-bit variable-length integer from memory starting at p[0]. | ||
520 | ** Return the number of bytes read. The value is stored in *v. | ||
521 | */ | ||
522 | int sqlite3GetVarint(const unsigned char *p, u64 *v){ | ||
523 | u32 x; | ||
524 | u64 x64; | ||
525 | int n; | ||
526 | unsigned char c; | ||
527 | if( ((c = p[0]) & 0x80)==0 ){ | ||
528 | *v = c; | ||
529 | return 1; | ||
530 | } | ||
531 | x = c & 0x7f; | ||
532 | if( ((c = p[1]) & 0x80)==0 ){ | ||
533 | *v = (x<<7) | c; | ||
534 | return 2; | ||
535 | } | ||
536 | x = (x<<7) | (c&0x7f); | ||
537 | if( ((c = p[2]) & 0x80)==0 ){ | ||
538 | *v = (x<<7) | c; | ||
539 | return 3; | ||
540 | } | ||
541 | x = (x<<7) | (c&0x7f); | ||
542 | if( ((c = p[3]) & 0x80)==0 ){ | ||
543 | *v = (x<<7) | c; | ||
544 | return 4; | ||
545 | } | ||
546 | x64 = (x<<7) | (c&0x7f); | ||
547 | n = 4; | ||
548 | do{ | ||
549 | c = p[n++]; | ||
550 | if( n==9 ){ | ||
551 | x64 = (x64<<8) | c; | ||
552 | break; | ||
553 | } | ||
554 | x64 = (x64<<7) | (c&0x7f); | ||
555 | }while( (c & 0x80)!=0 ); | ||
556 | *v = x64; | ||
557 | return n; | ||
558 | } | ||
559 | |||
560 | /* | ||
561 | ** Read a 32-bit variable-length integer from memory starting at p[0]. | ||
562 | ** Return the number of bytes read. The value is stored in *v. | ||
563 | */ | ||
564 | int sqlite3GetVarint32(const unsigned char *p, u32 *v){ | ||
565 | u32 x; | ||
566 | int n; | ||
567 | unsigned char c; | ||
568 | if( ((signed char*)p)[0]>=0 ){ | ||
569 | *v = p[0]; | ||
570 | return 1; | ||
571 | } | ||
572 | x = p[0] & 0x7f; | ||
573 | if( ((signed char*)p)[1]>=0 ){ | ||
574 | *v = (x<<7) | p[1]; | ||
575 | return 2; | ||
576 | } | ||
577 | x = (x<<7) | (p[1] & 0x7f); | ||
578 | n = 2; | ||
579 | do{ | ||
580 | x = (x<<7) | ((c = p[n++])&0x7f); | ||
581 | }while( (c & 0x80)!=0 && n<9 ); | ||
582 | *v = x; | ||
583 | return n; | ||
584 | } | ||
585 | |||
586 | /* | ||
587 | ** Return the number of bytes that will be needed to store the given | ||
588 | ** 64-bit integer. | ||
589 | */ | ||
590 | int sqlite3VarintLen(u64 v){ | ||
591 | int i = 0; | ||
592 | do{ | ||
593 | i++; | ||
594 | v >>= 7; | ||
595 | }while( v!=0 && i<9 ); | ||
596 | return i; | ||
597 | } | ||
598 | |||
599 | |||
600 | /* | ||
601 | ** Read or write a four-byte big-endian integer value. | ||
602 | */ | ||
603 | u32 sqlite3Get4byte(const u8 *p){ | ||
604 | return (p[0]<<24) | (p[1]<<16) | (p[2]<<8) | p[3]; | ||
605 | } | ||
606 | void sqlite3Put4byte(unsigned char *p, u32 v){ | ||
607 | p[0] = v>>24; | ||
608 | p[1] = v>>16; | ||
609 | p[2] = v>>8; | ||
610 | p[3] = v; | ||
611 | } | ||
612 | |||
613 | |||
614 | |||
615 | #if !defined(SQLITE_OMIT_BLOB_LITERAL) || defined(SQLITE_HAS_CODEC) \ | ||
616 | || defined(SQLITE_TEST) | ||
617 | /* | ||
618 | ** Translate a single byte of Hex into an integer. | ||
619 | */ | ||
620 | static int hexToInt(int h){ | ||
621 | if( h>='0' && h<='9' ){ | ||
622 | return h - '0'; | ||
623 | }else if( h>='a' && h<='f' ){ | ||
624 | return h - 'a' + 10; | ||
625 | }else{ | ||
626 | assert( h>='A' && h<='F' ); | ||
627 | return h - 'A' + 10; | ||
628 | } | ||
629 | } | ||
630 | #endif /* !SQLITE_OMIT_BLOB_LITERAL || SQLITE_HAS_CODEC || SQLITE_TEST */ | ||
631 | |||
632 | #if !defined(SQLITE_OMIT_BLOB_LITERAL) || defined(SQLITE_HAS_CODEC) | ||
633 | /* | ||
634 | ** Convert a BLOB literal of the form "x'hhhhhh'" into its binary | ||
635 | ** value. Return a pointer to its binary value. Space to hold the | ||
636 | ** binary value has been obtained from malloc and must be freed by | ||
637 | ** the calling routine. | ||
638 | */ | ||
639 | void *sqlite3HexToBlob(sqlite3 *db, const char *z){ | ||
640 | char *zBlob; | ||
641 | int i; | ||
642 | int n = strlen(z); | ||
643 | if( n%2 ) return 0; | ||
644 | |||
645 | zBlob = (char *)sqlite3DbMallocRaw(db, n/2); | ||
646 | if( zBlob ){ | ||
647 | for(i=0; i<n; i+=2){ | ||
648 | zBlob[i/2] = (hexToInt(z[i])<<4) | hexToInt(z[i+1]); | ||
649 | } | ||
650 | } | ||
651 | return zBlob; | ||
652 | } | ||
653 | #endif /* !SQLITE_OMIT_BLOB_LITERAL || SQLITE_HAS_CODEC */ | ||
654 | |||
655 | |||
656 | /* | ||
657 | ** Change the sqlite.magic from SQLITE_MAGIC_OPEN to SQLITE_MAGIC_BUSY. | ||
658 | ** Return an error (non-zero) if the magic was not SQLITE_MAGIC_OPEN | ||
659 | ** when this routine is called. | ||
660 | ** | ||
661 | ** This routine is called when entering an SQLite API. The SQLITE_MAGIC_OPEN | ||
662 | ** value indicates that the database connection passed into the API is | ||
663 | ** open and is not being used by another thread. By changing the value | ||
664 | ** to SQLITE_MAGIC_BUSY we indicate that the connection is in use. | ||
665 | ** sqlite3SafetyOff() below will change the value back to SQLITE_MAGIC_OPEN | ||
666 | ** when the API exits. | ||
667 | ** | ||
668 | ** This routine is a attempt to detect if two threads use the | ||
669 | ** same sqlite* pointer at the same time. There is a race | ||
670 | ** condition so it is possible that the error is not detected. | ||
671 | ** But usually the problem will be seen. The result will be an | ||
672 | ** error which can be used to debug the application that is | ||
673 | ** using SQLite incorrectly. | ||
674 | ** | ||
675 | ** Ticket #202: If db->magic is not a valid open value, take care not | ||
676 | ** to modify the db structure at all. It could be that db is a stale | ||
677 | ** pointer. In other words, it could be that there has been a prior | ||
678 | ** call to sqlite3_close(db) and db has been deallocated. And we do | ||
679 | ** not want to write into deallocated memory. | ||
680 | */ | ||
681 | int sqlite3SafetyOn(sqlite3 *db){ | ||
682 | if( db->magic==SQLITE_MAGIC_OPEN ){ | ||
683 | db->magic = SQLITE_MAGIC_BUSY; | ||
684 | return 0; | ||
685 | }else if( db->magic==SQLITE_MAGIC_BUSY ){ | ||
686 | db->magic = SQLITE_MAGIC_ERROR; | ||
687 | db->u1.isInterrupted = 1; | ||
688 | } | ||
689 | return 1; | ||
690 | } | ||
691 | |||
692 | /* | ||
693 | ** Change the magic from SQLITE_MAGIC_BUSY to SQLITE_MAGIC_OPEN. | ||
694 | ** Return an error (non-zero) if the magic was not SQLITE_MAGIC_BUSY | ||
695 | ** when this routine is called. | ||
696 | */ | ||
697 | int sqlite3SafetyOff(sqlite3 *db){ | ||
698 | if( db->magic==SQLITE_MAGIC_BUSY ){ | ||
699 | db->magic = SQLITE_MAGIC_OPEN; | ||
700 | return 0; | ||
701 | }else { | ||
702 | db->magic = SQLITE_MAGIC_ERROR; | ||
703 | db->u1.isInterrupted = 1; | ||
704 | return 1; | ||
705 | } | ||
706 | } | ||