2
+ − 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.cpp 1282 2008-11-13 09:31:33Z LarsPson $
+ − 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, int negFlag){
+ − 380 int i, c;
+ − 381 int neg = 0;
+ − 382 if( *zNum=='-' ){
+ − 383 neg = 1;
+ − 384 zNum++;
+ − 385 }else if( *zNum=='+' ){
+ − 386 zNum++;
+ − 387 }
+ − 388 if( negFlag ) neg = 1-neg;
+ − 389 while( *zNum=='0' ){
+ − 390 zNum++; /* Skip leading zeros. Ticket #2454 */
+ − 391 }
+ − 392 for(i=0; (c=zNum[i])>='0' && c<='9'; i++){}
+ − 393 if( i<19 ){
+ − 394 /* Guaranteed to fit if less than 19 digits */
+ − 395 return 1;
+ − 396 }else if( i>19 ){
+ − 397 /* Guaranteed to be too big if greater than 19 digits */
+ − 398 return 0;
+ − 399 }else{
+ − 400 /* Compare against 2^63. */
+ − 401 return compare2pow63(zNum)<neg;
+ − 402 }
+ − 403 }
+ − 404
+ − 405 /*
+ − 406 ** If zNum represents an integer that will fit in 32-bits, then set
+ − 407 ** *pValue to that integer and return true. Otherwise return false.
+ − 408 **
+ − 409 ** Any non-numeric characters that following zNum are ignored.
+ − 410 ** This is different from sqlite3Atoi64() which requires the
+ − 411 ** input number to be zero-terminated.
+ − 412 */
+ − 413 int sqlite3GetInt32(const char *zNum, int *pValue){
+ − 414 sqlite_int64 v = 0;
+ − 415 int i, c;
+ − 416 int neg = 0;
+ − 417 if( zNum[0]=='-' ){
+ − 418 neg = 1;
+ − 419 zNum++;
+ − 420 }else if( zNum[0]=='+' ){
+ − 421 zNum++;
+ − 422 }
+ − 423 while( zNum[0]=='0' ) zNum++;
+ − 424 for(i=0; i<11 && (c = zNum[i] - '0')>=0 && c<=9; i++){
+ − 425 v = v*10 + c;
+ − 426 }
+ − 427
+ − 428 /* The longest decimal representation of a 32 bit integer is 10 digits:
+ − 429 **
+ − 430 ** 1234567890
+ − 431 ** 2^31 -> 2147483648
+ − 432 */
+ − 433 if( i>10 ){
+ − 434 return 0;
+ − 435 }
+ − 436 if( v-neg>2147483647 ){
+ − 437 return 0;
+ − 438 }
+ − 439 if( neg ){
+ − 440 v = -v;
+ − 441 }
+ − 442 *pValue = (int)v;
+ − 443 return 1;
+ − 444 }
+ − 445
+ − 446 /*
+ − 447 ** Check to make sure we have a valid db pointer. This test is not
+ − 448 ** foolproof but it does provide some measure of protection against
+ − 449 ** misuse of the interface such as passing in db pointers that are
+ − 450 ** NULL or which have been previously closed. If this routine returns
+ − 451 ** TRUE it means that the db pointer is invalid and should not be
+ − 452 ** dereferenced for any reason. The calling function should invoke
+ − 453 ** SQLITE_MISUSE immediately.
+ − 454 */
+ − 455 int sqlite3SafetyCheck(sqlite3 *db){
+ − 456 int magic;
+ − 457 if( db==0 ) return 1;
+ − 458 magic = db->magic;
+ − 459 if( magic!=SQLITE_MAGIC_CLOSED &&
+ − 460 magic!=SQLITE_MAGIC_OPEN &&
+ − 461 magic!=SQLITE_MAGIC_BUSY ) return 1;
+ − 462 return 0;
+ − 463 }
+ − 464
+ − 465 /*
+ − 466 ** The variable-length integer encoding is as follows:
+ − 467 **
+ − 468 ** KEY:
+ − 469 ** A = 0xxxxxxx 7 bits of data and one flag bit
+ − 470 ** B = 1xxxxxxx 7 bits of data and one flag bit
+ − 471 ** C = xxxxxxxx 8 bits of data
+ − 472 **
+ − 473 ** 7 bits - A
+ − 474 ** 14 bits - BA
+ − 475 ** 21 bits - BBA
+ − 476 ** 28 bits - BBBA
+ − 477 ** 35 bits - BBBBA
+ − 478 ** 42 bits - BBBBBA
+ − 479 ** 49 bits - BBBBBBA
+ − 480 ** 56 bits - BBBBBBBA
+ − 481 ** 64 bits - BBBBBBBBC
+ − 482 */
+ − 483
+ − 484 /*
+ − 485 ** Write a 64-bit variable-length integer to memory starting at p[0].
+ − 486 ** The length of data write will be between 1 and 9 bytes. The number
+ − 487 ** of bytes written is returned.
+ − 488 **
+ − 489 ** A variable-length integer consists of the lower 7 bits of each byte
+ − 490 ** for all bytes that have the 8th bit set and one byte with the 8th
+ − 491 ** bit clear. Except, if we get to the 9th byte, it stores the full
+ − 492 ** 8 bits and is the last byte.
+ − 493 */
+ − 494 int sqlite3PutVarint(unsigned char *p, u64 v){
+ − 495 int i, j, n;
+ − 496 u8 buf[10];
+ − 497 if( v & (((u64)0xff000000)<<32) ){
+ − 498 p[8] = v;
+ − 499 v >>= 8;
+ − 500 for(i=7; i>=0; i--){
+ − 501 p[i] = (v & 0x7f) | 0x80;
+ − 502 v >>= 7;
+ − 503 }
+ − 504 return 9;
+ − 505 }
+ − 506 n = 0;
+ − 507 do{
+ − 508 buf[n++] = (v & 0x7f) | 0x80;
+ − 509 v >>= 7;
+ − 510 }while( v!=0 );
+ − 511 buf[0] &= 0x7f;
+ − 512 assert( n<=9 );
+ − 513 for(i=0, j=n-1; j>=0; j--, i++){
+ − 514 p[i] = buf[j];
+ − 515 }
+ − 516 return n;
+ − 517 }
+ − 518
+ − 519 /*
+ − 520 ** Read a 64-bit variable-length integer from memory starting at p[0].
+ − 521 ** Return the number of bytes read. The value is stored in *v.
+ − 522 */
+ − 523 int sqlite3GetVarint(const unsigned char *p, u64 *v){
+ − 524 u32 x;
+ − 525 u64 x64;
+ − 526 int n;
+ − 527 unsigned char c;
+ − 528 if( ((c = p[0]) & 0x80)==0 ){
+ − 529 *v = c;
+ − 530 return 1;
+ − 531 }
+ − 532 x = c & 0x7f;
+ − 533 if( ((c = p[1]) & 0x80)==0 ){
+ − 534 *v = (x<<7) | c;
+ − 535 return 2;
+ − 536 }
+ − 537 x = (x<<7) | (c&0x7f);
+ − 538 if( ((c = p[2]) & 0x80)==0 ){
+ − 539 *v = (x<<7) | c;
+ − 540 return 3;
+ − 541 }
+ − 542 x = (x<<7) | (c&0x7f);
+ − 543 if( ((c = p[3]) & 0x80)==0 ){
+ − 544 *v = (x<<7) | c;
+ − 545 return 4;
+ − 546 }
+ − 547 x64 = (x<<7) | (c&0x7f);
+ − 548 n = 4;
+ − 549 do{
+ − 550 c = p[n++];
+ − 551 if( n==9 ){
+ − 552 x64 = (x64<<8) | c;
+ − 553 break;
+ − 554 }
+ − 555 x64 = (x64<<7) | (c&0x7f);
+ − 556 }while( (c & 0x80)!=0 );
+ − 557 *v = x64;
+ − 558 return n;
+ − 559 }
+ − 560
+ − 561 /*
+ − 562 ** Read a 32-bit variable-length integer from memory starting at p[0].
+ − 563 ** Return the number of bytes read. The value is stored in *v.
+ − 564 */
+ − 565 int sqlite3GetVarint32(const unsigned char *p, u32 *v){
+ − 566 u32 x;
+ − 567 int n;
+ − 568 unsigned char c;
+ − 569 if( ((signed char*)p)[0]>=0 ){
+ − 570 *v = p[0];
+ − 571 return 1;
+ − 572 }
+ − 573 x = p[0] & 0x7f;
+ − 574 if( ((signed char*)p)[1]>=0 ){
+ − 575 *v = (x<<7) | p[1];
+ − 576 return 2;
+ − 577 }
+ − 578 x = (x<<7) | (p[1] & 0x7f);
+ − 579 n = 2;
+ − 580 do{
+ − 581 x = (x<<7) | ((c = p[n++])&0x7f);
+ − 582 }while( (c & 0x80)!=0 && n<9 );
+ − 583 *v = x;
+ − 584 return n;
+ − 585 }
+ − 586
+ − 587 /*
+ − 588 ** Return the number of bytes that will be needed to store the given
+ − 589 ** 64-bit integer.
+ − 590 */
+ − 591 int sqlite3VarintLen(u64 v){
+ − 592 int i = 0;
+ − 593 do{
+ − 594 i++;
+ − 595 v >>= 7;
+ − 596 }while( v!=0 && i<9 );
+ − 597 return i;
+ − 598 }
+ − 599
+ − 600
+ − 601 /*
+ − 602 ** Read or write a four-byte big-endian integer value.
+ − 603 */
+ − 604 u32 sqlite3Get4byte(const u8 *p){
+ − 605 return (p[0]<<24) | (p[1]<<16) | (p[2]<<8) | p[3];
+ − 606 }
+ − 607 void sqlite3Put4byte(unsigned char *p, u32 v){
+ − 608 p[0] = v>>24;
+ − 609 p[1] = v>>16;
+ − 610 p[2] = v>>8;
+ − 611 p[3] = v;
+ − 612 }
+ − 613
+ − 614
+ − 615
+ − 616 #if !defined(SQLITE_OMIT_BLOB_LITERAL) || defined(SQLITE_HAS_CODEC) \
+ − 617 || defined(SQLITE_TEST)
+ − 618 /*
+ − 619 ** Translate a single byte of Hex into an integer.
+ − 620 */
+ − 621 static int hexToInt(int h){
+ − 622 if( h>='0' && h<='9' ){
+ − 623 return h - '0';
+ − 624 }else if( h>='a' && h<='f' ){
+ − 625 return h - 'a' + 10;
+ − 626 }else{
+ − 627 assert( h>='A' && h<='F' );
+ − 628 return h - 'A' + 10;
+ − 629 }
+ − 630 }
+ − 631 #endif /* !SQLITE_OMIT_BLOB_LITERAL || SQLITE_HAS_CODEC || SQLITE_TEST */
+ − 632
+ − 633 #if !defined(SQLITE_OMIT_BLOB_LITERAL) || defined(SQLITE_HAS_CODEC)
+ − 634 /*
+ − 635 ** Convert a BLOB literal of the form "x'hhhhhh'" into its binary
+ − 636 ** value. Return a pointer to its binary value. Space to hold the
+ − 637 ** binary value has been obtained from malloc and must be freed by
+ − 638 ** the calling routine.
+ − 639 */
+ − 640 void *sqlite3HexToBlob(sqlite3 *db, const char *z){
+ − 641 char *zBlob;
+ − 642 int i;
+ − 643 int n = strlen(z);
+ − 644 if( n%2 ) return 0;
+ − 645
+ − 646 zBlob = (char *)sqlite3DbMallocRaw(db, n/2);
+ − 647 if( zBlob ){
+ − 648 for(i=0; i<n; i+=2){
+ − 649 zBlob[i/2] = (hexToInt(z[i])<<4) | hexToInt(z[i+1]);
+ − 650 }
+ − 651 }
+ − 652 return zBlob;
+ − 653 }
+ − 654 #endif /* !SQLITE_OMIT_BLOB_LITERAL || SQLITE_HAS_CODEC */
+ − 655
+ − 656
+ − 657 /*
+ − 658 ** Change the sqlite.magic from SQLITE_MAGIC_OPEN to SQLITE_MAGIC_BUSY.
+ − 659 ** Return an error (non-zero) if the magic was not SQLITE_MAGIC_OPEN
+ − 660 ** when this routine is called.
+ − 661 **
+ − 662 ** This routine is called when entering an SQLite API. The SQLITE_MAGIC_OPEN
+ − 663 ** value indicates that the database connection passed into the API is
+ − 664 ** open and is not being used by another thread. By changing the value
+ − 665 ** to SQLITE_MAGIC_BUSY we indicate that the connection is in use.
+ − 666 ** sqlite3SafetyOff() below will change the value back to SQLITE_MAGIC_OPEN
+ − 667 ** when the API exits.
+ − 668 **
+ − 669 ** This routine is a attempt to detect if two threads use the
+ − 670 ** same sqlite* pointer at the same time. There is a race
+ − 671 ** condition so it is possible that the error is not detected.
+ − 672 ** But usually the problem will be seen. The result will be an
+ − 673 ** error which can be used to debug the application that is
+ − 674 ** using SQLite incorrectly.
+ − 675 **
+ − 676 ** Ticket #202: If db->magic is not a valid open value, take care not
+ − 677 ** to modify the db structure at all. It could be that db is a stale
+ − 678 ** pointer. In other words, it could be that there has been a prior
+ − 679 ** call to sqlite3_close(db) and db has been deallocated. And we do
+ − 680 ** not want to write into deallocated memory.
+ − 681 */
+ − 682 int sqlite3SafetyOn(sqlite3 *db){
+ − 683 if( db->magic==SQLITE_MAGIC_OPEN ){
+ − 684 db->magic = SQLITE_MAGIC_BUSY;
+ − 685 return 0;
+ − 686 }else if( db->magic==SQLITE_MAGIC_BUSY ){
+ − 687 db->magic = SQLITE_MAGIC_ERROR;
+ − 688 db->u1.isInterrupted = 1;
+ − 689 }
+ − 690 return 1;
+ − 691 }
+ − 692
+ − 693 /*
+ − 694 ** Change the magic from SQLITE_MAGIC_BUSY to SQLITE_MAGIC_OPEN.
+ − 695 ** Return an error (non-zero) if the magic was not SQLITE_MAGIC_BUSY
+ − 696 ** when this routine is called.
+ − 697 */
+ − 698 int sqlite3SafetyOff(sqlite3 *db){
+ − 699 if( db->magic==SQLITE_MAGIC_BUSY ){
+ − 700 db->magic = SQLITE_MAGIC_OPEN;
+ − 701 return 0;
+ − 702 }else {
+ − 703 db->magic = SQLITE_MAGIC_ERROR;
+ − 704 db->u1.isInterrupted = 1;
+ − 705 return 1;
+ − 706 }
+ − 707 }