monotone

monotone Mtn Source Tree

Root/sqlite/util.c

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

Archive Download this file

Branches

Tags

Quick Links:     www.monotone.ca    -     Downloads    -     Documentation    -     Wiki    -     Code Forge    -     Build Status