Annotation of embedaddon/sqlite3/src/util.c, revision 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>