开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > 查看源码
util.c
资源名称：sql_for_ali.rar　[点击查看]
上传用户：sunhongbo
上传日期：2022-01-25
资源大小：3010k
文件大小：21k
源码类别：

数据库系统

开发平台：

C/C++

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.222 2008/04/16 00:49:12 drh Exp $
  18. */
  19. #include "sqliteInt.h"
  20. #include <stdarg.h>
  21. #include <ctype.h>
  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. }
  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. }
  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. }
  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. }
  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
  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. }
  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. }
  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. }
  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. }
  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. }
  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. }
  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.   }
  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. }
  446. /*
  447. ** The variable-length integer encoding is as follows:
  448. **
  449. ** KEY:
  450. **         A = 0xxxxxxx    7 bits of data and one flag bit
  451. **         B = 1xxxxxxx    7 bits of data and one flag bit
  452. **         C = xxxxxxxx    8 bits of data
  453. **
  454. **  7 bits - A
  455. ** 14 bits - BA
  456. ** 21 bits - BBA
  457. ** 28 bits - BBBA
  458. ** 35 bits - BBBBA
  459. ** 42 bits - BBBBBA
  460. ** 49 bits - BBBBBBA
  461. ** 56 bits - BBBBBBBA
  462. ** 64 bits - BBBBBBBBC
  463. */
  465. /*
  466. ** Write a 64-bit variable-length integer to memory starting at p[0].
  467. ** The length of data write will be between 1 and 9 bytes.  The number
  468. ** of bytes written is returned.
  469. **
  470. ** A variable-length integer consists of the lower 7 bits of each byte
  471. ** for all bytes that have the 8th bit set and one byte with the 8th
  472. ** bit clear.  Except, if we get to the 9th byte, it stores the full
  473. ** 8 bits and is the last byte.
  474. */
  475. int sqlite3PutVarint(unsigned char *p, u64 v){
  476.   int i, j, n;
  477.   u8 buf[10];
  478.   if( v & (((u64)0xff000000)<<32) ){
  479.     p[8] = v;
  480.     v >>= 8;
  481.     for(i=7; i>=0; i--){
  482.       p[i] = (v & 0x7f) | 0x80;
  483.       v >>= 7;
  484.     }
  485.     return 9;
  486.   }    
  487.   n = 0;
  488.   do{
  489.     buf[n++] = (v & 0x7f) | 0x80;
  490.     v >>= 7;
  491.   }while( v!=0 );
  492.   buf[0] &= 0x7f;
  493.   assert( n<=9 );
  494.   for(i=0, j=n-1; j>=0; j--, i++){
  495.     p[i] = buf[j];
  496.   }
  497.   return n;
  498. }
  500. /*
  501. ** This routine is a faster version of sqlite3PutVarint() that only
  502. ** works for 32-bit positive integers and which is optimized for
  503. ** the common case of small integers.
  504. */
  505. int sqlite3PutVarint32(unsigned char *p, u32 v){
  506.   if( (v & ~0x7f)==0 ){
  507.     p[0] = v;
  508.     return 1;
  509.   }else if( (v & ~0x3fff)==0 ){
  510.     p[0] = (v>>7) | 0x80;
  511.     p[1] = v & 0x7f;
  512.     return 2;
  513.   }else{
  514.     return sqlite3PutVarint(p, v);
  515.   }
  516. }
  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. }
  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. }
  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. }
  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. }
  615. #if !defined(SQLITE_OMIT_BLOB_LITERAL) || defined(SQLITE_HAS_CODEC)
  616. /*
  617. ** Translate a single byte of Hex into an integer.
  618. ** This routinen only works if h really is a valid hexadecimal
  619. ** character:  0..9a..fA..F
  620. */
  621. static int hexToInt(int h){
  622.   assert( (h>='0' && h<='9') ||  (h>='a' && h<='f') ||  (h>='A' && h<='F') );
  623. #ifdef SQLITE_ASCII
  624.   h += 9*(1&(h>>6));
  625. #endif
  626. #ifdef SQLITE_EBCDIC
  627.   h += 9*(1&~(h>>4));
  628. #endif
  629.   return h & 0xf;
  630. }
  631. #endif /* !SQLITE_OMIT_BLOB_LITERAL || SQLITE_HAS_CODEC */
  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, int n){
  641.   char *zBlob;
  642.   int i;
  644.   zBlob = (char *)sqlite3DbMallocRaw(db, n/2 + 1);
  645.   n--;
  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.     zBlob[i/2] = 0;
  651.   }
  652.   return zBlob;
  653. }
  654. #endif /* !SQLITE_OMIT_BLOB_LITERAL || SQLITE_HAS_CODEC */
  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. #ifdef SQLITE_DEBUG
  683. int sqlite3SafetyOn(sqlite3 *db){
  684.   if( db->magic==SQLITE_MAGIC_OPEN ){
  685.     db->magic = SQLITE_MAGIC_BUSY;
  686.     assert( sqlite3_mutex_held(db->mutex) );
  687.     return 0;
  688.   }else if( db->magic==SQLITE_MAGIC_BUSY ){
  689.     db->magic = SQLITE_MAGIC_ERROR;
  690.     db->u1.isInterrupted = 1;
  691.   }
  692.   return 1;
  693. }
  694. #endif
  696. /*
  697. ** Change the magic from SQLITE_MAGIC_BUSY to SQLITE_MAGIC_OPEN.
  698. ** Return an error (non-zero) if the magic was not SQLITE_MAGIC_BUSY
  699. ** when this routine is called.
  700. */
  701. #ifdef SQLITE_DEBUG
  702. int sqlite3SafetyOff(sqlite3 *db){
  703.   if( db->magic==SQLITE_MAGIC_BUSY ){
  704.     db->magic = SQLITE_MAGIC_OPEN;
  705.     assert( sqlite3_mutex_held(db->mutex) );
  706.     return 0;
  707.   }else{
  708.     db->magic = SQLITE_MAGIC_ERROR;
  709.     db->u1.isInterrupted = 1;
  710.     return 1;
  711.   }
  712. }
  713. #endif
  715. /*
  716. ** Check to make sure we have a valid db pointer.  This test is not
  717. ** foolproof but it does provide some measure of protection against
  718. ** misuse of the interface such as passing in db pointers that are
  719. ** NULL or which have been previously closed.  If this routine returns
  720. ** 1 it means that the db pointer is valid and 0 if it should not be
  721. ** dereferenced for any reason.  The calling function should invoke
  722. ** SQLITE_MISUSE immediately.
  723. **
  724. ** sqlite3SafetyCheckOk() requires that the db pointer be valid for
  725. ** use.  sqlite3SafetyCheckSickOrOk() allows a db pointer that failed to
  726. ** open properly and is not fit for general use but which can be
  727. ** used as an argument to sqlite3_errmsg() or sqlite3_close().
  728. */
  729. int sqlite3SafetyCheckOk(sqlite3 *db){
  730.   int magic;
  731.   if( db==0 ) return 0;
  732.   magic = db->magic;
  733.   if( magic!=SQLITE_MAGIC_OPEN &&
  734.       magic!=SQLITE_MAGIC_BUSY ) return 0;
  735.   return 1;
  736. }
  737. int sqlite3SafetyCheckSickOrOk(sqlite3 *db){
  738.   int magic;
  739.   if( db==0 ) return 0;
  740.   magic = db->magic;
  741.   if( magic!=SQLITE_MAGIC_SICK &&
  742.       magic!=SQLITE_MAGIC_OPEN &&
  743.       magic!=SQLITE_MAGIC_BUSY ) return 0;
  744.   return 1;
  745. }