Annotation of embedaddon/sqlite3/src/util.c, revision 1.1.1.1
1.1 misho 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: */
18: #include "sqliteInt.h"
19: #include <stdarg.h>
20: #ifdef SQLITE_HAVE_ISNAN
21: # include <math.h>
22: #endif
23:
24: /*
25: ** Routine needed to support the testcase() macro.
26: */
27: #ifdef SQLITE_COVERAGE_TEST
28: void sqlite3Coverage(int x){
29: static unsigned dummy = 0;
30: dummy += (unsigned)x;
31: }
32: #endif
33:
34: #ifndef SQLITE_OMIT_FLOATING_POINT
35: /*
36: ** Return true if the floating point value is Not a Number (NaN).
37: **
38: ** Use the math library isnan() function if compiled with SQLITE_HAVE_ISNAN.
39: ** Otherwise, we have our own implementation that works on most systems.
40: */
41: int sqlite3IsNaN(double x){
42: int rc; /* The value return */
43: #if !defined(SQLITE_HAVE_ISNAN)
44: /*
45: ** Systems that support the isnan() library function should probably
46: ** make use of it by compiling with -DSQLITE_HAVE_ISNAN. But we have
47: ** found that many systems do not have a working isnan() function so
48: ** this implementation is provided as an alternative.
49: **
50: ** This NaN test sometimes fails if compiled on GCC with -ffast-math.
51: ** On the other hand, the use of -ffast-math comes with the following
52: ** warning:
53: **
54: ** This option [-ffast-math] should never be turned on by any
55: ** -O option since it can result in incorrect output for programs
56: ** which depend on an exact implementation of IEEE or ISO
57: ** rules/specifications for math functions.
58: **
59: ** Under MSVC, this NaN test may fail if compiled with a floating-
60: ** point precision mode other than /fp:precise. From the MSDN
61: ** documentation:
62: **
63: ** The compiler [with /fp:precise] will properly handle comparisons
64: ** involving NaN. For example, x != x evaluates to true if x is NaN
65: ** ...
66: */
67: #ifdef __FAST_MATH__
68: # error SQLite will not work correctly with the -ffast-math option of GCC.
69: #endif
70: volatile double y = x;
71: volatile double z = y;
72: rc = (y!=z);
73: #else /* if defined(SQLITE_HAVE_ISNAN) */
74: rc = isnan(x);
75: #endif /* SQLITE_HAVE_ISNAN */
76: testcase( rc );
77: return rc;
78: }
79: #endif /* SQLITE_OMIT_FLOATING_POINT */
80:
81: /*
82: ** Compute a string length that is limited to what can be stored in
83: ** lower 30 bits of a 32-bit signed integer.
84: **
85: ** The value returned will never be negative. Nor will it ever be greater
86: ** than the actual length of the string. For very long strings (greater
87: ** than 1GiB) the value returned might be less than the true string length.
88: */
89: int sqlite3Strlen30(const char *z){
90: const char *z2 = z;
91: if( z==0 ) return 0;
92: while( *z2 ){ z2++; }
93: return 0x3fffffff & (int)(z2 - z);
94: }
95:
96: /*
97: ** Set the most recent error code and error string for the sqlite
98: ** handle "db". The error code is set to "err_code".
99: **
100: ** If it is not NULL, string zFormat specifies the format of the
101: ** error string in the style of the printf functions: The following
102: ** format characters are allowed:
103: **
104: ** %s Insert a string
105: ** %z A string that should be freed after use
106: ** %d Insert an integer
107: ** %T Insert a token
108: ** %S Insert the first element of a SrcList
109: **
110: ** zFormat and any string tokens that follow it are assumed to be
111: ** encoded in UTF-8.
112: **
113: ** To clear the most recent error for sqlite handle "db", sqlite3Error
114: ** should be called with err_code set to SQLITE_OK and zFormat set
115: ** to NULL.
116: */
117: void sqlite3Error(sqlite3 *db, int err_code, const char *zFormat, ...){
118: if( db && (db->pErr || (db->pErr = sqlite3ValueNew(db))!=0) ){
119: db->errCode = err_code;
120: if( zFormat ){
121: char *z;
122: va_list ap;
123: va_start(ap, zFormat);
124: z = sqlite3VMPrintf(db, zFormat, ap);
125: va_end(ap);
126: sqlite3ValueSetStr(db->pErr, -1, z, SQLITE_UTF8, SQLITE_DYNAMIC);
127: }else{
128: sqlite3ValueSetStr(db->pErr, 0, 0, SQLITE_UTF8, SQLITE_STATIC);
129: }
130: }
131: }
132:
133: /*
134: ** Add an error message to pParse->zErrMsg and increment pParse->nErr.
135: ** The following formatting characters are allowed:
136: **
137: ** %s Insert a string
138: ** %z A string that should be freed after use
139: ** %d Insert an integer
140: ** %T Insert a token
141: ** %S Insert the first element of a SrcList
142: **
143: ** This function should be used to report any error that occurs whilst
144: ** compiling an SQL statement (i.e. within sqlite3_prepare()). The
145: ** last thing the sqlite3_prepare() function does is copy the error
146: ** stored by this function into the database handle using sqlite3Error().
147: ** Function sqlite3Error() should be used during statement execution
148: ** (sqlite3_step() etc.).
149: */
150: void sqlite3ErrorMsg(Parse *pParse, const char *zFormat, ...){
151: char *zMsg;
152: va_list ap;
153: sqlite3 *db = pParse->db;
154: va_start(ap, zFormat);
155: zMsg = sqlite3VMPrintf(db, zFormat, ap);
156: va_end(ap);
157: if( db->suppressErr ){
158: sqlite3DbFree(db, zMsg);
159: }else{
160: pParse->nErr++;
161: sqlite3DbFree(db, pParse->zErrMsg);
162: pParse->zErrMsg = zMsg;
163: pParse->rc = SQLITE_ERROR;
164: }
165: }
166:
167: /*
168: ** Convert an SQL-style quoted string into a normal string by removing
169: ** the quote characters. The conversion is done in-place. If the
170: ** input does not begin with a quote character, then this routine
171: ** is a no-op.
172: **
173: ** The input string must be zero-terminated. A new zero-terminator
174: ** is added to the dequoted string.
175: **
176: ** The return value is -1 if no dequoting occurs or the length of the
177: ** dequoted string, exclusive of the zero terminator, if dequoting does
178: ** occur.
179: **
180: ** 2002-Feb-14: This routine is extended to remove MS-Access style
181: ** brackets from around identifers. For example: "[a-b-c]" becomes
182: ** "a-b-c".
183: */
184: int sqlite3Dequote(char *z){
185: char quote;
186: int i, j;
187: if( z==0 ) return -1;
188: quote = z[0];
189: switch( quote ){
190: case '\'': break;
191: case '"': break;
192: case '`': break; /* For MySQL compatibility */
193: case '[': quote = ']'; break; /* For MS SqlServer compatibility */
194: default: return -1;
195: }
196: for(i=1, j=0; ALWAYS(z[i]); i++){
197: if( z[i]==quote ){
198: if( z[i+1]==quote ){
199: z[j++] = quote;
200: i++;
201: }else{
202: break;
203: }
204: }else{
205: z[j++] = z[i];
206: }
207: }
208: z[j] = 0;
209: return j;
210: }
211:
212: /* Convenient short-hand */
213: #define UpperToLower sqlite3UpperToLower
214:
215: /*
216: ** Some systems have stricmp(). Others have strcasecmp(). Because
217: ** there is no consistency, we will define our own.
218: **
219: ** IMPLEMENTATION-OF: R-20522-24639 The sqlite3_strnicmp() API allows
220: ** applications and extensions to compare the contents of two buffers
221: ** containing UTF-8 strings in a case-independent fashion, using the same
222: ** definition of case independence that SQLite uses internally when
223: ** comparing identifiers.
224: */
225: int sqlite3StrICmp(const char *zLeft, const char *zRight){
226: register unsigned char *a, *b;
227: a = (unsigned char *)zLeft;
228: b = (unsigned char *)zRight;
229: while( *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; }
230: return UpperToLower[*a] - UpperToLower[*b];
231: }
232: int sqlite3_strnicmp(const char *zLeft, const char *zRight, int N){
233: register unsigned char *a, *b;
234: a = (unsigned char *)zLeft;
235: b = (unsigned char *)zRight;
236: while( N-- > 0 && *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; }
237: return N<0 ? 0 : UpperToLower[*a] - UpperToLower[*b];
238: }
239:
240: /*
241: ** The string z[] is an text representation of a real number.
242: ** Convert this string to a double and write it into *pResult.
243: **
244: ** The string z[] is length bytes in length (bytes, not characters) and
245: ** uses the encoding enc. The string is not necessarily zero-terminated.
246: **
247: ** Return TRUE if the result is a valid real number (or integer) and FALSE
248: ** if the string is empty or contains extraneous text. Valid numbers
249: ** are in one of these formats:
250: **
251: ** [+-]digits[E[+-]digits]
252: ** [+-]digits.[digits][E[+-]digits]
253: ** [+-].digits[E[+-]digits]
254: **
255: ** Leading and trailing whitespace is ignored for the purpose of determining
256: ** validity.
257: **
258: ** If some prefix of the input string is a valid number, this routine
259: ** returns FALSE but it still converts the prefix and writes the result
260: ** into *pResult.
261: */
262: int sqlite3AtoF(const char *z, double *pResult, int length, u8 enc){
263: #ifndef SQLITE_OMIT_FLOATING_POINT
264: int incr = (enc==SQLITE_UTF8?1:2);
265: const char *zEnd = z + length;
266: /* sign * significand * (10 ^ (esign * exponent)) */
267: int sign = 1; /* sign of significand */
268: i64 s = 0; /* significand */
269: int d = 0; /* adjust exponent for shifting decimal point */
270: int esign = 1; /* sign of exponent */
271: int e = 0; /* exponent */
272: int eValid = 1; /* True exponent is either not used or is well-formed */
273: double result;
274: int nDigits = 0;
275:
276: *pResult = 0.0; /* Default return value, in case of an error */
277:
278: if( enc==SQLITE_UTF16BE ) z++;
279:
280: /* skip leading spaces */
281: while( z<zEnd && sqlite3Isspace(*z) ) z+=incr;
282: if( z>=zEnd ) return 0;
283:
284: /* get sign of significand */
285: if( *z=='-' ){
286: sign = -1;
287: z+=incr;
288: }else if( *z=='+' ){
289: z+=incr;
290: }
291:
292: /* skip leading zeroes */
293: while( z<zEnd && z[0]=='0' ) z+=incr, nDigits++;
294:
295: /* copy max significant digits to significand */
296: while( z<zEnd && sqlite3Isdigit(*z) && s<((LARGEST_INT64-9)/10) ){
297: s = s*10 + (*z - '0');
298: z+=incr, nDigits++;
299: }
300:
301: /* skip non-significant significand digits
302: ** (increase exponent by d to shift decimal left) */
303: while( z<zEnd && sqlite3Isdigit(*z) ) z+=incr, nDigits++, d++;
304: if( z>=zEnd ) goto do_atof_calc;
305:
306: /* if decimal point is present */
307: if( *z=='.' ){
308: z+=incr;
309: /* copy digits from after decimal to significand
310: ** (decrease exponent by d to shift decimal right) */
311: while( z<zEnd && sqlite3Isdigit(*z) && s<((LARGEST_INT64-9)/10) ){
312: s = s*10 + (*z - '0');
313: z+=incr, nDigits++, d--;
314: }
315: /* skip non-significant digits */
316: while( z<zEnd && sqlite3Isdigit(*z) ) z+=incr, nDigits++;
317: }
318: if( z>=zEnd ) goto do_atof_calc;
319:
320: /* if exponent is present */
321: if( *z=='e' || *z=='E' ){
322: z+=incr;
323: eValid = 0;
324: if( z>=zEnd ) goto do_atof_calc;
325: /* get sign of exponent */
326: if( *z=='-' ){
327: esign = -1;
328: z+=incr;
329: }else if( *z=='+' ){
330: z+=incr;
331: }
332: /* copy digits to exponent */
333: while( z<zEnd && sqlite3Isdigit(*z) ){
334: e = e<10000 ? (e*10 + (*z - '0')) : 10000;
335: z+=incr;
336: eValid = 1;
337: }
338: }
339:
340: /* skip trailing spaces */
341: if( nDigits && eValid ){
342: while( z<zEnd && sqlite3Isspace(*z) ) z+=incr;
343: }
344:
345: do_atof_calc:
346: /* adjust exponent by d, and update sign */
347: e = (e*esign) + d;
348: if( e<0 ) {
349: esign = -1;
350: e *= -1;
351: } else {
352: esign = 1;
353: }
354:
355: /* if 0 significand */
356: if( !s ) {
357: /* In the IEEE 754 standard, zero is signed.
358: ** Add the sign if we've seen at least one digit */
359: result = (sign<0 && nDigits) ? -(double)0 : (double)0;
360: } else {
361: /* attempt to reduce exponent */
362: if( esign>0 ){
363: while( s<(LARGEST_INT64/10) && e>0 ) e--,s*=10;
364: }else{
365: while( !(s%10) && e>0 ) e--,s/=10;
366: }
367:
368: /* adjust the sign of significand */
369: s = sign<0 ? -s : s;
370:
371: /* if exponent, scale significand as appropriate
372: ** and store in result. */
373: if( e ){
374: double scale = 1.0;
375: /* attempt to handle extremely small/large numbers better */
376: if( e>307 && e<342 ){
377: while( e%308 ) { scale *= 1.0e+1; e -= 1; }
378: if( esign<0 ){
379: result = s / scale;
380: result /= 1.0e+308;
381: }else{
382: result = s * scale;
383: result *= 1.0e+308;
384: }
385: }else if( e>=342 ){
386: if( esign<0 ){
387: result = 0.0*s;
388: }else{
389: result = 1e308*1e308*s; /* Infinity */
390: }
391: }else{
392: /* 1.0e+22 is the largest power of 10 than can be
393: ** represented exactly. */
394: while( e%22 ) { scale *= 1.0e+1; e -= 1; }
395: while( e>0 ) { scale *= 1.0e+22; e -= 22; }
396: if( esign<0 ){
397: result = s / scale;
398: }else{
399: result = s * scale;
400: }
401: }
402: } else {
403: result = (double)s;
404: }
405: }
406:
407: /* store the result */
408: *pResult = result;
409:
410: /* return true if number and no extra non-whitespace chracters after */
411: return z>=zEnd && nDigits>0 && eValid;
412: #else
413: return !sqlite3Atoi64(z, pResult, length, enc);
414: #endif /* SQLITE_OMIT_FLOATING_POINT */
415: }
416:
417: /*
418: ** Compare the 19-character string zNum against the text representation
419: ** value 2^63: 9223372036854775808. Return negative, zero, or positive
420: ** if zNum is less than, equal to, or greater than the string.
421: ** Note that zNum must contain exactly 19 characters.
422: **
423: ** Unlike memcmp() this routine is guaranteed to return the difference
424: ** in the values of the last digit if the only difference is in the
425: ** last digit. So, for example,
426: **
427: ** compare2pow63("9223372036854775800", 1)
428: **
429: ** will return -8.
430: */
431: static int compare2pow63(const char *zNum, int incr){
432: int c = 0;
433: int i;
434: /* 012345678901234567 */
435: const char *pow63 = "922337203685477580";
436: for(i=0; c==0 && i<18; i++){
437: c = (zNum[i*incr]-pow63[i])*10;
438: }
439: if( c==0 ){
440: c = zNum[18*incr] - '8';
441: testcase( c==(-1) );
442: testcase( c==0 );
443: testcase( c==(+1) );
444: }
445: return c;
446: }
447:
448:
449: /*
450: ** Convert zNum to a 64-bit signed integer.
451: **
452: ** If the zNum value is representable as a 64-bit twos-complement
453: ** integer, then write that value into *pNum and return 0.
454: **
455: ** If zNum is exactly 9223372036854665808, return 2. This special
456: ** case is broken out because while 9223372036854665808 cannot be a
457: ** signed 64-bit integer, its negative -9223372036854665808 can be.
458: **
459: ** If zNum is too big for a 64-bit integer and is not
460: ** 9223372036854665808 then return 1.
461: **
462: ** length is the number of bytes in the string (bytes, not characters).
463: ** The string is not necessarily zero-terminated. The encoding is
464: ** given by enc.
465: */
466: int sqlite3Atoi64(const char *zNum, i64 *pNum, int length, u8 enc){
467: int incr = (enc==SQLITE_UTF8?1:2);
468: u64 u = 0;
469: int neg = 0; /* assume positive */
470: int i;
471: int c = 0;
472: const char *zStart;
473: const char *zEnd = zNum + length;
474: if( enc==SQLITE_UTF16BE ) zNum++;
475: while( zNum<zEnd && sqlite3Isspace(*zNum) ) zNum+=incr;
476: if( zNum<zEnd ){
477: if( *zNum=='-' ){
478: neg = 1;
479: zNum+=incr;
480: }else if( *zNum=='+' ){
481: zNum+=incr;
482: }
483: }
484: zStart = zNum;
485: while( zNum<zEnd && zNum[0]=='0' ){ zNum+=incr; } /* Skip leading zeros. */
486: for(i=0; &zNum[i]<zEnd && (c=zNum[i])>='0' && c<='9'; i+=incr){
487: u = u*10 + c - '0';
488: }
489: if( u>LARGEST_INT64 ){
490: *pNum = SMALLEST_INT64;
491: }else if( neg ){
492: *pNum = -(i64)u;
493: }else{
494: *pNum = (i64)u;
495: }
496: testcase( i==18 );
497: testcase( i==19 );
498: testcase( i==20 );
499: if( (c!=0 && &zNum[i]<zEnd) || (i==0 && zStart==zNum) || i>19*incr ){
500: /* zNum is empty or contains non-numeric text or is longer
501: ** than 19 digits (thus guaranteeing that it is too large) */
502: return 1;
503: }else if( i<19*incr ){
504: /* Less than 19 digits, so we know that it fits in 64 bits */
505: assert( u<=LARGEST_INT64 );
506: return 0;
507: }else{
508: /* zNum is a 19-digit numbers. Compare it against 9223372036854775808. */
509: c = compare2pow63(zNum, incr);
510: if( c<0 ){
511: /* zNum is less than 9223372036854775808 so it fits */
512: assert( u<=LARGEST_INT64 );
513: return 0;
514: }else if( c>0 ){
515: /* zNum is greater than 9223372036854775808 so it overflows */
516: return 1;
517: }else{
518: /* zNum is exactly 9223372036854775808. Fits if negative. The
519: ** special case 2 overflow if positive */
520: assert( u-1==LARGEST_INT64 );
521: assert( (*pNum)==SMALLEST_INT64 );
522: return neg ? 0 : 2;
523: }
524: }
525: }
526:
527: /*
528: ** If zNum represents an integer that will fit in 32-bits, then set
529: ** *pValue to that integer and return true. Otherwise return false.
530: **
531: ** Any non-numeric characters that following zNum are ignored.
532: ** This is different from sqlite3Atoi64() which requires the
533: ** input number to be zero-terminated.
534: */
535: int sqlite3GetInt32(const char *zNum, int *pValue){
536: sqlite_int64 v = 0;
537: int i, c;
538: int neg = 0;
539: if( zNum[0]=='-' ){
540: neg = 1;
541: zNum++;
542: }else if( zNum[0]=='+' ){
543: zNum++;
544: }
545: while( zNum[0]=='0' ) zNum++;
546: for(i=0; i<11 && (c = zNum[i] - '0')>=0 && c<=9; i++){
547: v = v*10 + c;
548: }
549:
550: /* The longest decimal representation of a 32 bit integer is 10 digits:
551: **
552: ** 1234567890
553: ** 2^31 -> 2147483648
554: */
555: testcase( i==10 );
556: if( i>10 ){
557: return 0;
558: }
559: testcase( v-neg==2147483647 );
560: if( v-neg>2147483647 ){
561: return 0;
562: }
563: if( neg ){
564: v = -v;
565: }
566: *pValue = (int)v;
567: return 1;
568: }
569:
570: /*
571: ** Return a 32-bit integer value extracted from a string. If the
572: ** string is not an integer, just return 0.
573: */
574: int sqlite3Atoi(const char *z){
575: int x = 0;
576: if( z ) sqlite3GetInt32(z, &x);
577: return x;
578: }
579:
580: /*
581: ** The variable-length integer encoding is as follows:
582: **
583: ** KEY:
584: ** A = 0xxxxxxx 7 bits of data and one flag bit
585: ** B = 1xxxxxxx 7 bits of data and one flag bit
586: ** C = xxxxxxxx 8 bits of data
587: **
588: ** 7 bits - A
589: ** 14 bits - BA
590: ** 21 bits - BBA
591: ** 28 bits - BBBA
592: ** 35 bits - BBBBA
593: ** 42 bits - BBBBBA
594: ** 49 bits - BBBBBBA
595: ** 56 bits - BBBBBBBA
596: ** 64 bits - BBBBBBBBC
597: */
598:
599: /*
600: ** Write a 64-bit variable-length integer to memory starting at p[0].
601: ** The length of data write will be between 1 and 9 bytes. The number
602: ** of bytes written is returned.
603: **
604: ** A variable-length integer consists of the lower 7 bits of each byte
605: ** for all bytes that have the 8th bit set and one byte with the 8th
606: ** bit clear. Except, if we get to the 9th byte, it stores the full
607: ** 8 bits and is the last byte.
608: */
609: int sqlite3PutVarint(unsigned char *p, u64 v){
610: int i, j, n;
611: u8 buf[10];
612: if( v & (((u64)0xff000000)<<32) ){
613: p[8] = (u8)v;
614: v >>= 8;
615: for(i=7; i>=0; i--){
616: p[i] = (u8)((v & 0x7f) | 0x80);
617: v >>= 7;
618: }
619: return 9;
620: }
621: n = 0;
622: do{
623: buf[n++] = (u8)((v & 0x7f) | 0x80);
624: v >>= 7;
625: }while( v!=0 );
626: buf[0] &= 0x7f;
627: assert( n<=9 );
628: for(i=0, j=n-1; j>=0; j--, i++){
629: p[i] = buf[j];
630: }
631: return n;
632: }
633:
634: /*
635: ** This routine is a faster version of sqlite3PutVarint() that only
636: ** works for 32-bit positive integers and which is optimized for
637: ** the common case of small integers. A MACRO version, putVarint32,
638: ** is provided which inlines the single-byte case. All code should use
639: ** the MACRO version as this function assumes the single-byte case has
640: ** already been handled.
641: */
642: int sqlite3PutVarint32(unsigned char *p, u32 v){
643: #ifndef putVarint32
644: if( (v & ~0x7f)==0 ){
645: p[0] = v;
646: return 1;
647: }
648: #endif
649: if( (v & ~0x3fff)==0 ){
650: p[0] = (u8)((v>>7) | 0x80);
651: p[1] = (u8)(v & 0x7f);
652: return 2;
653: }
654: return sqlite3PutVarint(p, v);
655: }
656:
657: /*
658: ** Bitmasks used by sqlite3GetVarint(). These precomputed constants
659: ** are defined here rather than simply putting the constant expressions
660: ** inline in order to work around bugs in the RVT compiler.
661: **
662: ** SLOT_2_0 A mask for (0x7f<<14) | 0x7f
663: **
664: ** SLOT_4_2_0 A mask for (0x7f<<28) | SLOT_2_0
665: */
666: #define SLOT_2_0 0x001fc07f
667: #define SLOT_4_2_0 0xf01fc07f
668:
669:
670: /*
671: ** Read a 64-bit variable-length integer from memory starting at p[0].
672: ** Return the number of bytes read. The value is stored in *v.
673: */
674: u8 sqlite3GetVarint(const unsigned char *p, u64 *v){
675: u32 a,b,s;
676:
677: a = *p;
678: /* a: p0 (unmasked) */
679: if (!(a&0x80))
680: {
681: *v = a;
682: return 1;
683: }
684:
685: p++;
686: b = *p;
687: /* b: p1 (unmasked) */
688: if (!(b&0x80))
689: {
690: a &= 0x7f;
691: a = a<<7;
692: a |= b;
693: *v = a;
694: return 2;
695: }
696:
697: /* Verify that constants are precomputed correctly */
698: assert( SLOT_2_0 == ((0x7f<<14) | (0x7f)) );
699: assert( SLOT_4_2_0 == ((0xfU<<28) | (0x7f<<14) | (0x7f)) );
700:
701: p++;
702: a = a<<14;
703: a |= *p;
704: /* a: p0<<14 | p2 (unmasked) */
705: if (!(a&0x80))
706: {
707: a &= SLOT_2_0;
708: b &= 0x7f;
709: b = b<<7;
710: a |= b;
711: *v = a;
712: return 3;
713: }
714:
715: /* CSE1 from below */
716: a &= SLOT_2_0;
717: p++;
718: b = b<<14;
719: b |= *p;
720: /* b: p1<<14 | p3 (unmasked) */
721: if (!(b&0x80))
722: {
723: b &= SLOT_2_0;
724: /* moved CSE1 up */
725: /* a &= (0x7f<<14)|(0x7f); */
726: a = a<<7;
727: a |= b;
728: *v = a;
729: return 4;
730: }
731:
732: /* a: p0<<14 | p2 (masked) */
733: /* b: p1<<14 | p3 (unmasked) */
734: /* 1:save off p0<<21 | p1<<14 | p2<<7 | p3 (masked) */
735: /* moved CSE1 up */
736: /* a &= (0x7f<<14)|(0x7f); */
737: b &= SLOT_2_0;
738: s = a;
739: /* s: p0<<14 | p2 (masked) */
740:
741: p++;
742: a = a<<14;
743: a |= *p;
744: /* a: p0<<28 | p2<<14 | p4 (unmasked) */
745: if (!(a&0x80))
746: {
747: /* we can skip these cause they were (effectively) done above in calc'ing s */
748: /* a &= (0x7f<<28)|(0x7f<<14)|(0x7f); */
749: /* b &= (0x7f<<14)|(0x7f); */
750: b = b<<7;
751: a |= b;
752: s = s>>18;
753: *v = ((u64)s)<<32 | a;
754: return 5;
755: }
756:
757: /* 2:save off p0<<21 | p1<<14 | p2<<7 | p3 (masked) */
758: s = s<<7;
759: s |= b;
760: /* s: p0<<21 | p1<<14 | p2<<7 | p3 (masked) */
761:
762: p++;
763: b = b<<14;
764: b |= *p;
765: /* b: p1<<28 | p3<<14 | p5 (unmasked) */
766: if (!(b&0x80))
767: {
768: /* we can skip this cause it was (effectively) done above in calc'ing s */
769: /* b &= (0x7f<<28)|(0x7f<<14)|(0x7f); */
770: a &= SLOT_2_0;
771: a = a<<7;
772: a |= b;
773: s = s>>18;
774: *v = ((u64)s)<<32 | a;
775: return 6;
776: }
777:
778: p++;
779: a = a<<14;
780: a |= *p;
781: /* a: p2<<28 | p4<<14 | p6 (unmasked) */
782: if (!(a&0x80))
783: {
784: a &= SLOT_4_2_0;
785: b &= SLOT_2_0;
786: b = b<<7;
787: a |= b;
788: s = s>>11;
789: *v = ((u64)s)<<32 | a;
790: return 7;
791: }
792:
793: /* CSE2 from below */
794: a &= SLOT_2_0;
795: p++;
796: b = b<<14;
797: b |= *p;
798: /* b: p3<<28 | p5<<14 | p7 (unmasked) */
799: if (!(b&0x80))
800: {
801: b &= SLOT_4_2_0;
802: /* moved CSE2 up */
803: /* a &= (0x7f<<14)|(0x7f); */
804: a = a<<7;
805: a |= b;
806: s = s>>4;
807: *v = ((u64)s)<<32 | a;
808: return 8;
809: }
810:
811: p++;
812: a = a<<15;
813: a |= *p;
814: /* a: p4<<29 | p6<<15 | p8 (unmasked) */
815:
816: /* moved CSE2 up */
817: /* a &= (0x7f<<29)|(0x7f<<15)|(0xff); */
818: b &= SLOT_2_0;
819: b = b<<8;
820: a |= b;
821:
822: s = s<<4;
823: b = p[-4];
824: b &= 0x7f;
825: b = b>>3;
826: s |= b;
827:
828: *v = ((u64)s)<<32 | a;
829:
830: return 9;
831: }
832:
833: /*
834: ** Read a 32-bit variable-length integer from memory starting at p[0].
835: ** Return the number of bytes read. The value is stored in *v.
836: **
837: ** If the varint stored in p[0] is larger than can fit in a 32-bit unsigned
838: ** integer, then set *v to 0xffffffff.
839: **
840: ** A MACRO version, getVarint32, is provided which inlines the
841: ** single-byte case. All code should use the MACRO version as
842: ** this function assumes the single-byte case has already been handled.
843: */
844: u8 sqlite3GetVarint32(const unsigned char *p, u32 *v){
845: u32 a,b;
846:
847: /* The 1-byte case. Overwhelmingly the most common. Handled inline
848: ** by the getVarin32() macro */
849: a = *p;
850: /* a: p0 (unmasked) */
851: #ifndef getVarint32
852: if (!(a&0x80))
853: {
854: /* Values between 0 and 127 */
855: *v = a;
856: return 1;
857: }
858: #endif
859:
860: /* The 2-byte case */
861: p++;
862: b = *p;
863: /* b: p1 (unmasked) */
864: if (!(b&0x80))
865: {
866: /* Values between 128 and 16383 */
867: a &= 0x7f;
868: a = a<<7;
869: *v = a | b;
870: return 2;
871: }
872:
873: /* The 3-byte case */
874: p++;
875: a = a<<14;
876: a |= *p;
877: /* a: p0<<14 | p2 (unmasked) */
878: if (!(a&0x80))
879: {
880: /* Values between 16384 and 2097151 */
881: a &= (0x7f<<14)|(0x7f);
882: b &= 0x7f;
883: b = b<<7;
884: *v = a | b;
885: return 3;
886: }
887:
888: /* A 32-bit varint is used to store size information in btrees.
889: ** Objects are rarely larger than 2MiB limit of a 3-byte varint.
890: ** A 3-byte varint is sufficient, for example, to record the size
891: ** of a 1048569-byte BLOB or string.
892: **
893: ** We only unroll the first 1-, 2-, and 3- byte cases. The very
894: ** rare larger cases can be handled by the slower 64-bit varint
895: ** routine.
896: */
897: #if 1
898: {
899: u64 v64;
900: u8 n;
901:
902: p -= 2;
903: n = sqlite3GetVarint(p, &v64);
904: assert( n>3 && n<=9 );
905: if( (v64 & SQLITE_MAX_U32)!=v64 ){
906: *v = 0xffffffff;
907: }else{
908: *v = (u32)v64;
909: }
910: return n;
911: }
912:
913: #else
914: /* For following code (kept for historical record only) shows an
915: ** unrolling for the 3- and 4-byte varint cases. This code is
916: ** slightly faster, but it is also larger and much harder to test.
917: */
918: p++;
919: b = b<<14;
920: b |= *p;
921: /* b: p1<<14 | p3 (unmasked) */
922: if (!(b&0x80))
923: {
924: /* Values between 2097152 and 268435455 */
925: b &= (0x7f<<14)|(0x7f);
926: a &= (0x7f<<14)|(0x7f);
927: a = a<<7;
928: *v = a | b;
929: return 4;
930: }
931:
932: p++;
933: a = a<<14;
934: a |= *p;
935: /* a: p0<<28 | p2<<14 | p4 (unmasked) */
936: if (!(a&0x80))
937: {
938: /* Values between 268435456 and 34359738367 */
939: a &= SLOT_4_2_0;
940: b &= SLOT_4_2_0;
941: b = b<<7;
942: *v = a | b;
943: return 5;
944: }
945:
946: /* We can only reach this point when reading a corrupt database
947: ** file. In that case we are not in any hurry. Use the (relatively
948: ** slow) general-purpose sqlite3GetVarint() routine to extract the
949: ** value. */
950: {
951: u64 v64;
952: u8 n;
953:
954: p -= 4;
955: n = sqlite3GetVarint(p, &v64);
956: assert( n>5 && n<=9 );
957: *v = (u32)v64;
958: return n;
959: }
960: #endif
961: }
962:
963: /*
964: ** Return the number of bytes that will be needed to store the given
965: ** 64-bit integer.
966: */
967: int sqlite3VarintLen(u64 v){
968: int i = 0;
969: do{
970: i++;
971: v >>= 7;
972: }while( v!=0 && ALWAYS(i<9) );
973: return i;
974: }
975:
976:
977: /*
978: ** Read or write a four-byte big-endian integer value.
979: */
980: u32 sqlite3Get4byte(const u8 *p){
981: return (p[0]<<24) | (p[1]<<16) | (p[2]<<8) | p[3];
982: }
983: void sqlite3Put4byte(unsigned char *p, u32 v){
984: p[0] = (u8)(v>>24);
985: p[1] = (u8)(v>>16);
986: p[2] = (u8)(v>>8);
987: p[3] = (u8)v;
988: }
989:
990:
991:
992: /*
993: ** Translate a single byte of Hex into an integer.
994: ** This routine only works if h really is a valid hexadecimal
995: ** character: 0..9a..fA..F
996: */
997: u8 sqlite3HexToInt(int h){
998: assert( (h>='0' && h<='9') || (h>='a' && h<='f') || (h>='A' && h<='F') );
999: #ifdef SQLITE_ASCII
1000: h += 9*(1&(h>>6));
1001: #endif
1002: #ifdef SQLITE_EBCDIC
1003: h += 9*(1&~(h>>4));
1004: #endif
1005: return (u8)(h & 0xf);
1006: }
1007:
1008: #if !defined(SQLITE_OMIT_BLOB_LITERAL) || defined(SQLITE_HAS_CODEC)
1009: /*
1010: ** Convert a BLOB literal of the form "x'hhhhhh'" into its binary
1011: ** value. Return a pointer to its binary value. Space to hold the
1012: ** binary value has been obtained from malloc and must be freed by
1013: ** the calling routine.
1014: */
1015: void *sqlite3HexToBlob(sqlite3 *db, const char *z, int n){
1016: char *zBlob;
1017: int i;
1018:
1019: zBlob = (char *)sqlite3DbMallocRaw(db, n/2 + 1);
1020: n--;
1021: if( zBlob ){
1022: for(i=0; i<n; i+=2){
1023: zBlob[i/2] = (sqlite3HexToInt(z[i])<<4) | sqlite3HexToInt(z[i+1]);
1024: }
1025: zBlob[i/2] = 0;
1026: }
1027: return zBlob;
1028: }
1029: #endif /* !SQLITE_OMIT_BLOB_LITERAL || SQLITE_HAS_CODEC */
1030:
1031: /*
1032: ** Log an error that is an API call on a connection pointer that should
1033: ** not have been used. The "type" of connection pointer is given as the
1034: ** argument. The zType is a word like "NULL" or "closed" or "invalid".
1035: */
1036: static void logBadConnection(const char *zType){
1037: sqlite3_log(SQLITE_MISUSE,
1038: "API call with %s database connection pointer",
1039: zType
1040: );
1041: }
1042:
1043: /*
1044: ** Check to make sure we have a valid db pointer. This test is not
1045: ** foolproof but it does provide some measure of protection against
1046: ** misuse of the interface such as passing in db pointers that are
1047: ** NULL or which have been previously closed. If this routine returns
1048: ** 1 it means that the db pointer is valid and 0 if it should not be
1049: ** dereferenced for any reason. The calling function should invoke
1050: ** SQLITE_MISUSE immediately.
1051: **
1052: ** sqlite3SafetyCheckOk() requires that the db pointer be valid for
1053: ** use. sqlite3SafetyCheckSickOrOk() allows a db pointer that failed to
1054: ** open properly and is not fit for general use but which can be
1055: ** used as an argument to sqlite3_errmsg() or sqlite3_close().
1056: */
1057: int sqlite3SafetyCheckOk(sqlite3 *db){
1058: u32 magic;
1059: if( db==0 ){
1060: logBadConnection("NULL");
1061: return 0;
1062: }
1063: magic = db->magic;
1064: if( magic!=SQLITE_MAGIC_OPEN ){
1065: if( sqlite3SafetyCheckSickOrOk(db) ){
1066: testcase( sqlite3GlobalConfig.xLog!=0 );
1067: logBadConnection("unopened");
1068: }
1069: return 0;
1070: }else{
1071: return 1;
1072: }
1073: }
1074: int sqlite3SafetyCheckSickOrOk(sqlite3 *db){
1075: u32 magic;
1076: magic = db->magic;
1077: if( magic!=SQLITE_MAGIC_SICK &&
1078: magic!=SQLITE_MAGIC_OPEN &&
1079: magic!=SQLITE_MAGIC_BUSY ){
1080: testcase( sqlite3GlobalConfig.xLog!=0 );
1081: logBadConnection("invalid");
1082: return 0;
1083: }else{
1084: return 1;
1085: }
1086: }
1087:
1088: /*
1089: ** Attempt to add, substract, or multiply the 64-bit signed value iB against
1090: ** the other 64-bit signed integer at *pA and store the result in *pA.
1091: ** Return 0 on success. Or if the operation would have resulted in an
1092: ** overflow, leave *pA unchanged and return 1.
1093: */
1094: int sqlite3AddInt64(i64 *pA, i64 iB){
1095: i64 iA = *pA;
1096: testcase( iA==0 ); testcase( iA==1 );
1097: testcase( iB==-1 ); testcase( iB==0 );
1098: if( iB>=0 ){
1099: testcase( iA>0 && LARGEST_INT64 - iA == iB );
1100: testcase( iA>0 && LARGEST_INT64 - iA == iB - 1 );
1101: if( iA>0 && LARGEST_INT64 - iA < iB ) return 1;
1102: *pA += iB;
1103: }else{
1104: testcase( iA<0 && -(iA + LARGEST_INT64) == iB + 1 );
1105: testcase( iA<0 && -(iA + LARGEST_INT64) == iB + 2 );
1106: if( iA<0 && -(iA + LARGEST_INT64) > iB + 1 ) return 1;
1107: *pA += iB;
1108: }
1109: return 0;
1110: }
1111: int sqlite3SubInt64(i64 *pA, i64 iB){
1112: testcase( iB==SMALLEST_INT64+1 );
1113: if( iB==SMALLEST_INT64 ){
1114: testcase( (*pA)==(-1) ); testcase( (*pA)==0 );
1115: if( (*pA)>=0 ) return 1;
1116: *pA -= iB;
1117: return 0;
1118: }else{
1119: return sqlite3AddInt64(pA, -iB);
1120: }
1121: }
1122: #define TWOPOWER32 (((i64)1)<<32)
1123: #define TWOPOWER31 (((i64)1)<<31)
1124: int sqlite3MulInt64(i64 *pA, i64 iB){
1125: i64 iA = *pA;
1126: i64 iA1, iA0, iB1, iB0, r;
1127:
1128: iA1 = iA/TWOPOWER32;
1129: iA0 = iA % TWOPOWER32;
1130: iB1 = iB/TWOPOWER32;
1131: iB0 = iB % TWOPOWER32;
1132: if( iA1*iB1 != 0 ) return 1;
1133: assert( iA1*iB0==0 || iA0*iB1==0 );
1134: r = iA1*iB0 + iA0*iB1;
1135: testcase( r==(-TWOPOWER31)-1 );
1136: testcase( r==(-TWOPOWER31) );
1137: testcase( r==TWOPOWER31 );
1138: testcase( r==TWOPOWER31-1 );
1139: if( r<(-TWOPOWER31) || r>=TWOPOWER31 ) return 1;
1140: r *= TWOPOWER32;
1141: if( sqlite3AddInt64(&r, iA0*iB0) ) return 1;
1142: *pA = r;
1143: return 0;
1144: }
1145:
1146: /*
1147: ** Compute the absolute value of a 32-bit signed integer, of possible. Or
1148: ** if the integer has a value of -2147483648, return +2147483647
1149: */
1150: int sqlite3AbsInt32(int x){
1151: if( x>=0 ) return x;
1152: if( x==(int)0x80000000 ) return 0x7fffffff;
1153: return -x;
1154: }
1155:
1156: #ifdef SQLITE_ENABLE_8_3_NAMES
1157: /*
1158: ** If SQLITE_ENABLE_8_3_NAMES is set at compile-time and if the database
1159: ** filename in zBaseFilename is a URI with the "8_3_names=1" parameter and
1160: ** if filename in z[] has a suffix (a.k.a. "extension") that is longer than
1161: ** three characters, then shorten the suffix on z[] to be the last three
1162: ** characters of the original suffix.
1163: **
1164: ** If SQLITE_ENABLE_8_3_NAMES is set to 2 at compile-time, then always
1165: ** do the suffix shortening regardless of URI parameter.
1166: **
1167: ** Examples:
1168: **
1169: ** test.db-journal => test.nal
1170: ** test.db-wal => test.wal
1171: ** test.db-shm => test.shm
1172: ** test.db-mj7f3319fa => test.9fa
1173: */
1174: void sqlite3FileSuffix3(const char *zBaseFilename, char *z){
1175: #if SQLITE_ENABLE_8_3_NAMES<2
1176: if( sqlite3_uri_boolean(zBaseFilename, "8_3_names", 0) )
1177: #endif
1178: {
1179: int i, sz;
1180: sz = sqlite3Strlen30(z);
1181: for(i=sz-1; i>0 && z[i]!='/' && z[i]!='.'; i--){}
1182: if( z[i]=='.' && ALWAYS(sz>i+4) ) memmove(&z[i+1], &z[sz-3], 4);
1183: }
1184: }
1185: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to util.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / src