/ Check-in [dc3c0b8b28]
Login

Many hyperlinks are disabled.
Use anonymous login to enable hyperlinks.

Overview
Comment:Merge recent enhancements from trunk.
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | apple-osx
Files: files | file ages | folders
SHA3-256: dc3c0b8b2815c0658bc4ca7c045102d627229dedf098801a554c06eb6dbe97b2
User & Date: drh 2019-03-26 12:37:09
Context
2019-04-02
00:34
Merge enhancements from trunk. check-in: 0b35aebbb3 user: drh tags: apple-osx
2019-03-26
12:37
Merge recent enhancements from trunk. check-in: dc3c0b8b28 user: drh tags: apple-osx
2019-03-25
22:05
Fix an obsolete comment in the CLI. No code changes. check-in: fade103cba user: drh tags: trunk
2019-03-19
20:48
Merge recent enhancements from trunk. check-in: 000f4398db user: drh tags: apple-osx
Changes
Hide Diffs Side-by-Side Diffs Ignore Whitespace Patch

Changes to configure.

   859    859   pdfdir
   860    860   dvidir
   861    861   htmldir
   862    862   infodir
   863    863   docdir
   864    864   oldincludedir
   865    865   includedir
          866  +runstatedir
   866    867   localstatedir
   867    868   sharedstatedir
   868    869   sysconfdir
   869    870   datadir
   870    871   datarootdir
   871    872   libexecdir
   872    873   sbindir
................................................................................
   960    961   sbindir='${exec_prefix}/sbin'
   961    962   libexecdir='${exec_prefix}/libexec'
   962    963   datarootdir='${prefix}/share'
   963    964   datadir='${datarootdir}'
   964    965   sysconfdir='${prefix}/etc'
   965    966   sharedstatedir='${prefix}/com'
   966    967   localstatedir='${prefix}/var'
          968  +runstatedir='${localstatedir}/run'
   967    969   includedir='${prefix}/include'
   968    970   oldincludedir='/usr/include'
   969    971   docdir='${datarootdir}/doc/${PACKAGE_TARNAME}'
   970    972   infodir='${datarootdir}/info'
   971    973   htmldir='${docdir}'
   972    974   dvidir='${docdir}'
   973    975   pdfdir='${docdir}'
................................................................................
  1211   1213       ac_prev=psdir ;;
  1212   1214     -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*)
  1213   1215       psdir=$ac_optarg ;;
  1214   1216   
  1215   1217     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
  1216   1218     | -silent | --silent | --silen | --sile | --sil)
  1217   1219       silent=yes ;;
         1220  +
         1221  +  -runstatedir | --runstatedir | --runstatedi | --runstated \
         1222  +  | --runstate | --runstat | --runsta | --runst | --runs \
         1223  +  | --run | --ru | --r)
         1224  +    ac_prev=runstatedir ;;
         1225  +  -runstatedir=* | --runstatedir=* | --runstatedi=* | --runstated=* \
         1226  +  | --runstate=* | --runstat=* | --runsta=* | --runst=* | --runs=* \
         1227  +  | --run=* | --ru=* | --r=*)
         1228  +    runstatedir=$ac_optarg ;;
  1218   1229   
  1219   1230     -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
  1220   1231       ac_prev=sbindir ;;
  1221   1232     -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
  1222   1233     | --sbi=* | --sb=*)
  1223   1234       sbindir=$ac_optarg ;;
  1224   1235   
................................................................................
  1349   1360     esac
  1350   1361   fi
  1351   1362   
  1352   1363   # Check all directory arguments for consistency.
  1353   1364   for ac_var in	exec_prefix prefix bindir sbindir libexecdir datarootdir \
  1354   1365   		datadir sysconfdir sharedstatedir localstatedir includedir \
  1355   1366   		oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
  1356         -		libdir localedir mandir
         1367  +		libdir localedir mandir runstatedir
  1357   1368   do
  1358   1369     eval ac_val=\$$ac_var
  1359   1370     # Remove trailing slashes.
  1360   1371     case $ac_val in
  1361   1372       */ )
  1362   1373         ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'`
  1363   1374         eval $ac_var=\$ac_val;;
................................................................................
  1502   1513   Fine tuning of the installation directories:
  1503   1514     --bindir=DIR            user executables [EPREFIX/bin]
  1504   1515     --sbindir=DIR           system admin executables [EPREFIX/sbin]
  1505   1516     --libexecdir=DIR        program executables [EPREFIX/libexec]
  1506   1517     --sysconfdir=DIR        read-only single-machine data [PREFIX/etc]
  1507   1518     --sharedstatedir=DIR    modifiable architecture-independent data [PREFIX/com]
  1508   1519     --localstatedir=DIR     modifiable single-machine data [PREFIX/var]
         1520  +  --runstatedir=DIR       modifiable per-process data [LOCALSTATEDIR/run]
  1509   1521     --libdir=DIR            object code libraries [EPREFIX/lib]
  1510   1522     --includedir=DIR        C header files [PREFIX/include]
  1511   1523     --oldincludedir=DIR     C header files for non-gcc [/usr/include]
  1512   1524     --datarootdir=DIR       read-only arch.-independent data root [PREFIX/share]
  1513   1525     --datadir=DIR           read-only architecture-independent data [DATAROOTDIR]
  1514   1526     --infodir=DIR           info documentation [DATAROOTDIR/info]
  1515   1527     --localedir=DIR         locale-dependent data [DATAROOTDIR/locale]
................................................................................
  3930   3942   { $as_echo "$as_me:${as_lineno-$LINENO}: checking the name lister ($NM) interface" >&5
  3931   3943   $as_echo_n "checking the name lister ($NM) interface... " >&6; }
  3932   3944   if ${lt_cv_nm_interface+:} false; then :
  3933   3945     $as_echo_n "(cached) " >&6
  3934   3946   else
  3935   3947     lt_cv_nm_interface="BSD nm"
  3936   3948     echo "int some_variable = 0;" > conftest.$ac_ext
  3937         -  (eval echo "\"\$as_me:3937: $ac_compile\"" >&5)
         3949  +  (eval echo "\"\$as_me:3949: $ac_compile\"" >&5)
  3938   3950     (eval "$ac_compile" 2>conftest.err)
  3939   3951     cat conftest.err >&5
  3940         -  (eval echo "\"\$as_me:3940: $NM \\\"conftest.$ac_objext\\\"\"" >&5)
         3952  +  (eval echo "\"\$as_me:3952: $NM \\\"conftest.$ac_objext\\\"\"" >&5)
  3941   3953     (eval "$NM \"conftest.$ac_objext\"" 2>conftest.err > conftest.out)
  3942   3954     cat conftest.err >&5
  3943         -  (eval echo "\"\$as_me:3943: output\"" >&5)
         3955  +  (eval echo "\"\$as_me:3955: output\"" >&5)
  3944   3956     cat conftest.out >&5
  3945   3957     if $GREP 'External.*some_variable' conftest.out > /dev/null; then
  3946   3958       lt_cv_nm_interface="MS dumpbin"
  3947   3959     fi
  3948   3960     rm -f conftest*
  3949   3961   fi
  3950   3962   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_nm_interface" >&5
................................................................................
  5142   5154   	;;
  5143   5155       esac
  5144   5156     fi
  5145   5157     rm -rf conftest*
  5146   5158     ;;
  5147   5159   *-*-irix6*)
  5148   5160     # Find out which ABI we are using.
  5149         -  echo '#line 5149 "configure"' > conftest.$ac_ext
         5161  +  echo '#line 5161 "configure"' > conftest.$ac_ext
  5150   5162     if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
  5151   5163     (eval $ac_compile) 2>&5
  5152   5164     ac_status=$?
  5153   5165     $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  5154   5166     test $ac_status = 0; }; then
  5155   5167       if test "$lt_cv_prog_gnu_ld" = yes; then
  5156   5168         case `/usr/bin/file conftest.$ac_objext` in
................................................................................
  6667   6679      # Note that $ac_compile itself does not contain backslashes and begins
  6668   6680      # with a dollar sign (not a hyphen), so the echo should work correctly.
  6669   6681      # The option is referenced via a variable to avoid confusing sed.
  6670   6682      lt_compile=`echo "$ac_compile" | $SED \
  6671   6683      -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
  6672   6684      -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
  6673   6685      -e 's:$: $lt_compiler_flag:'`
  6674         -   (eval echo "\"\$as_me:6674: $lt_compile\"" >&5)
         6686  +   (eval echo "\"\$as_me:6686: $lt_compile\"" >&5)
  6675   6687      (eval "$lt_compile" 2>conftest.err)
  6676   6688      ac_status=$?
  6677   6689      cat conftest.err >&5
  6678         -   echo "$as_me:6678: \$? = $ac_status" >&5
         6690  +   echo "$as_me:6690: \$? = $ac_status" >&5
  6679   6691      if (exit $ac_status) && test -s "$ac_outfile"; then
  6680   6692        # The compiler can only warn and ignore the option if not recognized
  6681   6693        # So say no if there are warnings other than the usual output.
  6682   6694        $ECHO "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' >conftest.exp
  6683   6695        $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
  6684   6696        if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then
  6685   6697          lt_cv_prog_compiler_rtti_exceptions=yes
................................................................................
  7006   7018      # Note that $ac_compile itself does not contain backslashes and begins
  7007   7019      # with a dollar sign (not a hyphen), so the echo should work correctly.
  7008   7020      # The option is referenced via a variable to avoid confusing sed.
  7009   7021      lt_compile=`echo "$ac_compile" | $SED \
  7010   7022      -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
  7011   7023      -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
  7012   7024      -e 's:$: $lt_compiler_flag:'`
  7013         -   (eval echo "\"\$as_me:7013: $lt_compile\"" >&5)
         7025  +   (eval echo "\"\$as_me:7025: $lt_compile\"" >&5)
  7014   7026      (eval "$lt_compile" 2>conftest.err)
  7015   7027      ac_status=$?
  7016   7028      cat conftest.err >&5
  7017         -   echo "$as_me:7017: \$? = $ac_status" >&5
         7029  +   echo "$as_me:7029: \$? = $ac_status" >&5
  7018   7030      if (exit $ac_status) && test -s "$ac_outfile"; then
  7019   7031        # The compiler can only warn and ignore the option if not recognized
  7020   7032        # So say no if there are warnings other than the usual output.
  7021   7033        $ECHO "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' >conftest.exp
  7022   7034        $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
  7023   7035        if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then
  7024   7036          lt_cv_prog_compiler_pic_works=yes
................................................................................
  7111   7123      # (2) before a word containing "conftest.", or (3) at the end.
  7112   7124      # Note that $ac_compile itself does not contain backslashes and begins
  7113   7125      # with a dollar sign (not a hyphen), so the echo should work correctly.
  7114   7126      lt_compile=`echo "$ac_compile" | $SED \
  7115   7127      -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
  7116   7128      -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
  7117   7129      -e 's:$: $lt_compiler_flag:'`
  7118         -   (eval echo "\"\$as_me:7118: $lt_compile\"" >&5)
         7130  +   (eval echo "\"\$as_me:7130: $lt_compile\"" >&5)
  7119   7131      (eval "$lt_compile" 2>out/conftest.err)
  7120   7132      ac_status=$?
  7121   7133      cat out/conftest.err >&5
  7122         -   echo "$as_me:7122: \$? = $ac_status" >&5
         7134  +   echo "$as_me:7134: \$? = $ac_status" >&5
  7123   7135      if (exit $ac_status) && test -s out/conftest2.$ac_objext
  7124   7136      then
  7125   7137        # The compiler can only warn and ignore the option if not recognized
  7126   7138        # So say no if there are warnings
  7127   7139        $ECHO "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' > out/conftest.exp
  7128   7140        $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2
  7129   7141        if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then
................................................................................
  7166   7178      # (2) before a word containing "conftest.", or (3) at the end.
  7167   7179      # Note that $ac_compile itself does not contain backslashes and begins
  7168   7180      # with a dollar sign (not a hyphen), so the echo should work correctly.
  7169   7181      lt_compile=`echo "$ac_compile" | $SED \
  7170   7182      -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
  7171   7183      -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
  7172   7184      -e 's:$: $lt_compiler_flag:'`
  7173         -   (eval echo "\"\$as_me:7173: $lt_compile\"" >&5)
         7185  +   (eval echo "\"\$as_me:7185: $lt_compile\"" >&5)
  7174   7186      (eval "$lt_compile" 2>out/conftest.err)
  7175   7187      ac_status=$?
  7176   7188      cat out/conftest.err >&5
  7177         -   echo "$as_me:7177: \$? = $ac_status" >&5
         7189  +   echo "$as_me:7189: \$? = $ac_status" >&5
  7178   7190      if (exit $ac_status) && test -s out/conftest2.$ac_objext
  7179   7191      then
  7180   7192        # The compiler can only warn and ignore the option if not recognized
  7181   7193        # So say no if there are warnings
  7182   7194        $ECHO "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' > out/conftest.exp
  7183   7195        $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2
  7184   7196        if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then
................................................................................
  9546   9558   else
  9547   9559     	  if test "$cross_compiling" = yes; then :
  9548   9560     lt_cv_dlopen_self=cross
  9549   9561   else
  9550   9562     lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
  9551   9563     lt_status=$lt_dlunknown
  9552   9564     cat > conftest.$ac_ext <<_LT_EOF
  9553         -#line 9553 "configure"
         9565  +#line 9565 "configure"
  9554   9566   #include "confdefs.h"
  9555   9567   
  9556   9568   #if HAVE_DLFCN_H
  9557   9569   #include <dlfcn.h>
  9558   9570   #endif
  9559   9571   
  9560   9572   #include <stdio.h>
................................................................................
  9642   9654   else
  9643   9655     	  if test "$cross_compiling" = yes; then :
  9644   9656     lt_cv_dlopen_self_static=cross
  9645   9657   else
  9646   9658     lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
  9647   9659     lt_status=$lt_dlunknown
  9648   9660     cat > conftest.$ac_ext <<_LT_EOF
  9649         -#line 9649 "configure"
         9661  +#line 9661 "configure"
  9650   9662   #include "confdefs.h"
  9651   9663   
  9652   9664   #if HAVE_DLFCN_H
  9653   9665   #include <dlfcn.h>
  9654   9666   #endif
  9655   9667   
  9656   9668   #include <stdio.h>
................................................................................
  9991  10003   	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  9992  10004   /* end confdefs.h.  */
  9993  10005   #include <sys/types.h>
  9994  10006    /* Check that off_t can represent 2**63 - 1 correctly.
  9995  10007       We can't simply define LARGE_OFF_T to be 9223372036854775807,
  9996  10008       since some C++ compilers masquerading as C compilers
  9997  10009       incorrectly reject 9223372036854775807.  */
  9998         -#define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
        10010  +#define LARGE_OFF_T ((((off_t) 1 << 31) << 31) - 1 + (((off_t) 1 << 31) << 31))
  9999  10011     int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
 10000  10012   		       && LARGE_OFF_T % 2147483647 == 1)
 10001  10013   		      ? 1 : -1];
 10002  10014   int
 10003  10015   main ()
 10004  10016   {
 10005  10017   
................................................................................
 10037  10049     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 10038  10050   /* end confdefs.h.  */
 10039  10051   #include <sys/types.h>
 10040  10052    /* Check that off_t can represent 2**63 - 1 correctly.
 10041  10053       We can't simply define LARGE_OFF_T to be 9223372036854775807,
 10042  10054       since some C++ compilers masquerading as C compilers
 10043  10055       incorrectly reject 9223372036854775807.  */
 10044         -#define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
        10056  +#define LARGE_OFF_T ((((off_t) 1 << 31) << 31) - 1 + (((off_t) 1 << 31) << 31))
 10045  10057     int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
 10046  10058   		       && LARGE_OFF_T % 2147483647 == 1)
 10047  10059   		      ? 1 : -1];
 10048  10060   int
 10049  10061   main ()
 10050  10062   {
 10051  10063   
................................................................................
 10061  10073   /* end confdefs.h.  */
 10062  10074   #define _FILE_OFFSET_BITS 64
 10063  10075   #include <sys/types.h>
 10064  10076    /* Check that off_t can represent 2**63 - 1 correctly.
 10065  10077       We can't simply define LARGE_OFF_T to be 9223372036854775807,
 10066  10078       since some C++ compilers masquerading as C compilers
 10067  10079       incorrectly reject 9223372036854775807.  */
 10068         -#define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
        10080  +#define LARGE_OFF_T ((((off_t) 1 << 31) << 31) - 1 + (((off_t) 1 << 31) << 31))
 10069  10081     int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
 10070  10082   		       && LARGE_OFF_T % 2147483647 == 1)
 10071  10083   		      ? 1 : -1];
 10072  10084   int
 10073  10085   main ()
 10074  10086   {
 10075  10087   
................................................................................
 10106  10118     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 10107  10119   /* end confdefs.h.  */
 10108  10120   #include <sys/types.h>
 10109  10121    /* Check that off_t can represent 2**63 - 1 correctly.
 10110  10122       We can't simply define LARGE_OFF_T to be 9223372036854775807,
 10111  10123       since some C++ compilers masquerading as C compilers
 10112  10124       incorrectly reject 9223372036854775807.  */
 10113         -#define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
        10125  +#define LARGE_OFF_T ((((off_t) 1 << 31) << 31) - 1 + (((off_t) 1 << 31) << 31))
 10114  10126     int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
 10115  10127   		       && LARGE_OFF_T % 2147483647 == 1)
 10116  10128   		      ? 1 : -1];
 10117  10129   int
 10118  10130   main ()
 10119  10131   {
 10120  10132   
................................................................................
 10130  10142   /* end confdefs.h.  */
 10131  10143   #define _LARGE_FILES 1
 10132  10144   #include <sys/types.h>
 10133  10145    /* Check that off_t can represent 2**63 - 1 correctly.
 10134  10146       We can't simply define LARGE_OFF_T to be 9223372036854775807,
 10135  10147       since some C++ compilers masquerading as C compilers
 10136  10148       incorrectly reject 9223372036854775807.  */
 10137         -#define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
        10149  +#define LARGE_OFF_T ((((off_t) 1 << 31) << 31) - 1 + (((off_t) 1 << 31) << 31))
 10138  10150     int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
 10139  10151   		       && LARGE_OFF_T % 2147483647 == 1)
 10140  10152   		      ? 1 : -1];
 10141  10153   int
 10142  10154   main ()
 10143  10155   {
 10144  10156   

Changes to ext/fts3/fts3_term.c.

    94     94   
    95     95     rc = sqlite3_declare_vtab(db, FTS3_TERMS_SCHEMA);
    96     96     if( rc!=SQLITE_OK ) return rc;
    97     97   
    98     98     nByte = sizeof(Fts3termTable) + sizeof(Fts3Table) + nDb + nFts3 + 2;
    99     99     p = (Fts3termTable *)sqlite3_malloc64(nByte);
   100    100     if( !p ) return SQLITE_NOMEM;
   101         -  memset(p, 0, nByte);
          101  +  memset(p, 0, (size_t)nByte);
   102    102   
   103    103     p->pFts3Tab = (Fts3Table *)&p[1];
   104    104     p->pFts3Tab->zDb = (char *)&p->pFts3Tab[1];
   105    105     p->pFts3Tab->zName = &p->pFts3Tab->zDb[nDb+1];
   106    106     p->pFts3Tab->db = db;
   107    107     p->pFts3Tab->nIndex = iIndex+1;
   108    108     p->iIndex = iIndex;

Changes to ext/fts3/unicode/mkunicode.tcl.

   734    734       void sqlite3Fts5UnicodeAscii(u8 *aArray, u8 *aAscii){
   735    735         int i = 0;
   736    736         int iTbl = 0;
   737    737         while( i<128 ){
   738    738           int bToken = aArray[ aFts5UnicodeData[iTbl] & 0x1F ];
   739    739           int n = (aFts5UnicodeData[iTbl] >> 5) + i;
   740    740           for(; i<128 && i<n; i++){
   741         -          aAscii[i] = bToken;
          741  +          aAscii[i] = (u8)bToken;
   742    742           }
   743    743           iTbl++;
   744    744         }
   745    745       }
   746    746     }]
   747    747   }
   748    748   

Changes to ext/fts5/fts5_aux.c.

   349    349     }
   350    350   
   351    351     *pnScore = nScore;
   352    352     if( piPos ){
   353    353       sqlite3_int64 iAdj = iFirst - (nToken - (iLast-iFirst)) / 2;
   354    354       if( (iAdj+nToken)>nDocsize ) iAdj = nDocsize - nToken;
   355    355       if( iAdj<0 ) iAdj = 0;
   356         -    *piPos = iAdj;
          356  +    *piPos = (int)iAdj;
   357    357     }
   358    358   
   359    359     return rc;
   360    360   }
   361    361   
   362    362   /*
   363    363   ** Return the value in pVal interpreted as utf-8 text. Except, if pVal 
................................................................................
   577    577       /* Allocate the Fts5Bm25Data object */
   578    578       nPhrase = pApi->xPhraseCount(pFts);
   579    579       nByte = sizeof(Fts5Bm25Data) + nPhrase*2*sizeof(double);
   580    580       p = (Fts5Bm25Data*)sqlite3_malloc64(nByte);
   581    581       if( p==0 ){
   582    582         rc = SQLITE_NOMEM;
   583    583       }else{
   584         -      memset(p, 0, nByte);
          584  +      memset(p, 0, (size_t)nByte);
   585    585         p->nPhrase = nPhrase;
   586    586         p->aIDF = (double*)&p[1];
   587    587         p->aFreq = &p->aIDF[nPhrase];
   588    588       }
   589    589   
   590    590       /* Calculate the average document length for this FTS5 table */
   591    591       if( rc==SQLITE_OK ) rc = pApi->xRowCount(pFts, &nRow);

Changes to ext/fts5/fts5_buffer.c.

    23     23         nNew = nNew * 2;
    24     24       }
    25     25       pNew = sqlite3_realloc64(pBuf->p, nNew);
    26     26       if( pNew==0 ){
    27     27         *pRc = SQLITE_NOMEM;
    28     28         return 1;
    29     29       }else{
    30         -      pBuf->nSpace = nNew;
           30  +      pBuf->nSpace = (int)nNew;
    31     31         pBuf->p = pNew;
    32     32       }
    33     33     }
    34     34     return 0;
    35     35   }
    36     36   
    37     37   
................................................................................
   247    247   void *sqlite3Fts5MallocZero(int *pRc, sqlite3_int64 nByte){
   248    248     void *pRet = 0;
   249    249     if( *pRc==SQLITE_OK ){
   250    250       pRet = sqlite3_malloc64(nByte);
   251    251       if( pRet==0 ){
   252    252         if( nByte>0 ) *pRc = SQLITE_NOMEM;
   253    253       }else{
   254         -      memset(pRet, 0, nByte);
          254  +      memset(pRet, 0, (size_t)nByte);
   255    255       }
   256    256     }
   257    257     return pRet;
   258    258   }
   259    259   
   260    260   /*
   261    261   ** Return a nul-terminated copy of the string indicated by pIn. If nIn

Changes to ext/fts5/fts5_config.c.

   321    321             }
   322    322           }
   323    323           if( p==0 ){
   324    324             *pzErr = sqlite3_mprintf("parse error in tokenize directive");
   325    325             rc = SQLITE_ERROR;
   326    326           }else{
   327    327             rc = sqlite3Fts5GetTokenizer(pGlobal, 
   328         -              (const char**)azArg, nArg, &pConfig->pTok, &pConfig->pTokApi,
          328  +              (const char**)azArg, (int)nArg, &pConfig->pTok, &pConfig->pTokApi,
   329    329                 pzErr
   330    330             );
   331    331           }
   332    332         }
   333    333       }
   334    334   
   335    335       sqlite3_free(azArg);
................................................................................
   431    431     assert( *pRc==SQLITE_OK );
   432    432     *pbQuoted = 0;
   433    433     *pzOut = 0;
   434    434   
   435    435     if( zOut==0 ){
   436    436       *pRc = SQLITE_NOMEM;
   437    437     }else{
   438         -    memcpy(zOut, zIn, nIn+1);
          438  +    memcpy(zOut, zIn, (size_t)(nIn+1));
   439    439       if( fts5_isopenquote(zOut[0]) ){
   440    440         int ii = fts5Dequote(zOut);
   441    441         zRet = &zIn[ii];
   442    442         *pbQuoted = 1;
   443    443       }else{
   444    444         zRet = fts5ConfigSkipBareword(zIn);
   445    445         if( zRet ){

Changes to ext/fts5/fts5_expr.c.

  1483   1483       if( pNear==0 ){
  1484   1484         sqlite3_int64 nByte;
  1485   1485         nByte = sizeof(Fts5ExprNearset) + SZALLOC * sizeof(Fts5ExprPhrase*);
  1486   1486         pRet = sqlite3_malloc64(nByte);
  1487   1487         if( pRet==0 ){
  1488   1488           pParse->rc = SQLITE_NOMEM;
  1489   1489         }else{
  1490         -        memset(pRet, 0, nByte);
         1490  +        memset(pRet, 0, (size_t)nByte);
  1491   1491         }
  1492   1492       }else if( (pNear->nPhrase % SZALLOC)==0 ){
  1493   1493         int nNew = pNear->nPhrase + SZALLOC;
  1494   1494         sqlite3_int64 nByte;
  1495   1495   
  1496   1496         nByte = sizeof(Fts5ExprNearset) + nNew * sizeof(Fts5ExprPhrase*);
  1497   1497         pRet = (Fts5ExprNearset*)sqlite3_realloc64(pNear, nByte);
................................................................................
  1559   1559     if( pPhrase && pPhrase->nTerm>0 && (tflags & FTS5_TOKEN_COLOCATED) ){
  1560   1560       Fts5ExprTerm *pSyn;
  1561   1561       sqlite3_int64 nByte = sizeof(Fts5ExprTerm) + sizeof(Fts5Buffer) + nToken+1;
  1562   1562       pSyn = (Fts5ExprTerm*)sqlite3_malloc64(nByte);
  1563   1563       if( pSyn==0 ){
  1564   1564         rc = SQLITE_NOMEM;
  1565   1565       }else{
  1566         -      memset(pSyn, 0, nByte);
         1566  +      memset(pSyn, 0, (size_t)nByte);
  1567   1567         pSyn->zTerm = ((char*)pSyn) + sizeof(Fts5ExprTerm) + sizeof(Fts5Buffer);
  1568   1568         memcpy(pSyn->zTerm, pToken, nToken);
  1569   1569         pSyn->pSynonym = pPhrase->aTerm[pPhrase->nTerm-1].pSynonym;
  1570   1570         pPhrase->aTerm[pPhrase->nTerm-1].pSynonym = pSyn;
  1571   1571       }
  1572   1572     }else{
  1573   1573       Fts5ExprTerm *pTerm;
................................................................................
  1719   1719       Fts5Colset *pColsetOrig = pOrig->pNode->pNear->pColset;
  1720   1720       if( pColsetOrig ){
  1721   1721         sqlite3_int64 nByte;
  1722   1722         Fts5Colset *pColset;
  1723   1723         nByte = sizeof(Fts5Colset) + (pColsetOrig->nCol-1) * sizeof(int);
  1724   1724         pColset = (Fts5Colset*)sqlite3Fts5MallocZero(&rc, nByte);
  1725   1725         if( pColset ){ 
  1726         -        memcpy(pColset, pColsetOrig, nByte);
         1726  +        memcpy(pColset, pColsetOrig, (size_t)nByte);
  1727   1727         }
  1728   1728         pNew->pRoot->pNear->pColset = pColset;
  1729   1729       }
  1730   1730     }
  1731   1731   
  1732   1732     if( pOrig->nTerm ){
  1733   1733       int i;                          /* Used to iterate through phrase terms */
................................................................................
  1936   1936   */
  1937   1937   static Fts5Colset *fts5CloneColset(int *pRc, Fts5Colset *pOrig){
  1938   1938     Fts5Colset *pRet;
  1939   1939     if( pOrig ){
  1940   1940       sqlite3_int64 nByte = sizeof(Fts5Colset) + (pOrig->nCol-1) * sizeof(int);
  1941   1941       pRet = (Fts5Colset*)sqlite3Fts5MallocZero(pRc, nByte);
  1942   1942       if( pRet ){ 
  1943         -      memcpy(pRet, pOrig, nByte);
         1943  +      memcpy(pRet, pOrig, (size_t)nByte);
  1944   1944       }
  1945   1945     }else{
  1946   1946       pRet = 0;
  1947   1947     }
  1948   1948     return pRet;
  1949   1949   }
  1950   1950   

Changes to ext/fts5/fts5_hash.c.

    99     99       nByte = sizeof(Fts5HashEntry*) * pNew->nSlot;
   100    100       pNew->aSlot = (Fts5HashEntry**)sqlite3_malloc64(nByte);
   101    101       if( pNew->aSlot==0 ){
   102    102         sqlite3_free(pNew);
   103    103         *ppNew = 0;
   104    104         rc = SQLITE_NOMEM;
   105    105       }else{
   106         -      memset(pNew->aSlot, 0, nByte);
          106  +      memset(pNew->aSlot, 0, (size_t)nByte);
   107    107       }
   108    108     }
   109    109     return rc;
   110    110   }
   111    111   
   112    112   /*
   113    113   ** Free a hash table object.
................................................................................
   280    280         iHash = fts5HashKey2(pHash->nSlot, (u8)bByte, (const u8*)pToken, nToken);
   281    281       }
   282    282   
   283    283       /* Allocate new Fts5HashEntry and add it to the hash table. */
   284    284       p = (Fts5HashEntry*)sqlite3_malloc64(nByte);
   285    285       if( !p ) return SQLITE_NOMEM;
   286    286       memset(p, 0, sizeof(Fts5HashEntry));
   287         -    p->nAlloc = nByte;
          287  +    p->nAlloc = (int)nByte;
   288    288       zKey = fts5EntryKey(p);
   289    289       zKey[0] = bByte;
   290    290       memcpy(&zKey[1], pToken, nToken);
   291    291       assert( iHash==fts5HashKey(pHash->nSlot, (u8*)zKey, nToken+1) );
   292    292       p->nKey = nToken;
   293    293       zKey[nToken+1] = '\0';
   294    294       p->nData = nToken+1 + 1 + sizeof(Fts5HashEntry);

Changes to ext/fts5/fts5_main.c.

   629    629   
   630    630     rc = fts5NewTransaction(pTab);
   631    631     if( rc==SQLITE_OK ){
   632    632       nByte = sizeof(Fts5Cursor) + pConfig->nCol * sizeof(int);
   633    633       pCsr = (Fts5Cursor*)sqlite3_malloc64(nByte);
   634    634       if( pCsr ){
   635    635         Fts5Global *pGlobal = pTab->pGlobal;
   636         -      memset(pCsr, 0, nByte);
          636  +      memset(pCsr, 0, (size_t)nByte);
   637    637         pCsr->aColumnSize = (int*)&pCsr[1];
   638    638         pCsr->pNext = pGlobal->pCsr;
   639    639         pGlobal->pCsr = pCsr;
   640    640         pCsr->iCsrId = ++pGlobal->iNextId;
   641    641       }else{
   642    642         rc = SQLITE_NOMEM;
   643    643       }
................................................................................
   910    910     const char *zRank = pCsr->zRank;
   911    911     const char *zRankArgs = pCsr->zRankArgs;
   912    912     
   913    913     nPhrase = sqlite3Fts5ExprPhraseCount(pCsr->pExpr);
   914    914     nByte = sizeof(Fts5Sorter) + sizeof(int) * (nPhrase-1);
   915    915     pSorter = (Fts5Sorter*)sqlite3_malloc64(nByte);
   916    916     if( pSorter==0 ) return SQLITE_NOMEM;
   917         -  memset(pSorter, 0, nByte);
          917  +  memset(pSorter, 0, (size_t)nByte);
   918    918     pSorter->nIdx = nPhrase;
   919    919   
   920    920     /* TODO: It would be better to have some system for reusing statement
   921    921     ** handles here, rather than preparing a new one for each query. But that
   922    922     ** is not possible as SQLite reference counts the virtual table objects.
   923    923     ** And since the statement required here reads from this very virtual 
   924    924     ** table, saving it creates a circular reference.

Changes to ext/fts5/fts5_storage.c.

   285    285     sqlite3_int64 nByte;            /* Bytes of space to allocate */
   286    286   
   287    287     nByte = sizeof(Fts5Storage)               /* Fts5Storage object */
   288    288           + pConfig->nCol * sizeof(i64);      /* Fts5Storage.aTotalSize[] */
   289    289     *pp = p = (Fts5Storage*)sqlite3_malloc64(nByte);
   290    290     if( !p ) return SQLITE_NOMEM;
   291    291   
   292         -  memset(p, 0, nByte);
          292  +  memset(p, 0, (size_t)nByte);
   293    293     p->aTotalSize = (i64*)&p[1];
   294    294     p->pConfig = pConfig;
   295    295     p->pIndex = pIndex;
   296    296   
   297    297     if( bCreate ){
   298    298       if( pConfig->eContent==FTS5_CONTENT_NORMAL ){
   299    299         int nDefn = 32 + pConfig->nCol*10;

Changes to ext/fts5/fts5_unicode2.c.

   765    765   void sqlite3Fts5UnicodeAscii(u8 *aArray, u8 *aAscii){
   766    766     int i = 0;
   767    767     int iTbl = 0;
   768    768     while( i<128 ){
   769    769       int bToken = aArray[ aFts5UnicodeData[iTbl] & 0x1F ];
   770    770       int n = (aFts5UnicodeData[iTbl] >> 5) + i;
   771    771       for(; i<128 && i<n; i++){
   772         -      aAscii[i] = bToken;
          772  +      aAscii[i] = (u8)bToken;
   773    773       }
   774    774       iTbl++;
   775    775     }
   776    776   }

Changes to ext/misc/amatch.c.

   743    743   
   744    744     nIn = strlen(zIn);
   745    745     zOut = sqlite3_malloc64(nIn+1);
   746    746     if( zOut ){
   747    747       char q = zIn[0];              /* Quote character (if any ) */
   748    748   
   749    749       if( q!='[' && q!= '\'' && q!='"' && q!='`' ){
   750         -      memcpy(zOut, zIn, nIn+1);
          750  +      memcpy(zOut, zIn, (size_t)(nIn+1));
   751    751       }else{
   752    752         int iOut = 0;               /* Index of next byte to write to output */
   753    753         int iIn;                    /* Index of next byte to read from input */
   754    754   
   755    755         if( q=='[' ) q = ']';
   756    756         for(iIn=1; iIn<nIn; iIn++){
   757    757           if( zIn[iIn]==q ) iIn++;

Changes to ext/misc/closure.c.

   427    427   
   428    428     nIn = strlen(zIn);
   429    429     zOut = sqlite3_malloc64(nIn+1);
   430    430     if( zOut ){
   431    431       char q = zIn[0];              /* Quote character (if any ) */
   432    432   
   433    433       if( q!='[' && q!= '\'' && q!='"' && q!='`' ){
   434         -      memcpy(zOut, zIn, nIn+1);
          434  +      memcpy(zOut, zIn, (size_t)(nIn+1));
   435    435       }else{
   436    436         int iOut = 0;               /* Index of next byte to write to output */
   437    437         int iIn;                    /* Index of next byte to read from input */
   438    438   
   439    439         if( q=='[' ) q = ']';
   440    440         for(iIn=1; iIn<nIn; iIn++){
   441    441           if( zIn[iIn]==q ) iIn++;

Changes to ext/misc/fileio.c.

   154    154     }
   155    155     pBuf = sqlite3_malloc64( nIn ? nIn : 1 );
   156    156     if( pBuf==0 ){
   157    157       sqlite3_result_error_nomem(ctx);
   158    158       fclose(in);
   159    159       return;
   160    160     }
   161         -  if( nIn==fread(pBuf, 1, nIn, in) ){
          161  +  if( nIn==fread(pBuf, 1, (size_t)nIn, in) ){
   162    162       sqlite3_result_blob64(ctx, pBuf, nIn, sqlite3_free);
   163    163     }else{
   164    164       sqlite3_result_error_code(ctx, SQLITE_IOERR);
   165    165       sqlite3_free(pBuf);
   166    166     }
   167    167     fclose(in);
   168    168   }
................................................................................
   289    289   #endif
   290    290   }
   291    291   
   292    292   /*
   293    293   ** Argument zFile is the name of a file that will be created and/or written
   294    294   ** by SQL function writefile(). This function ensures that the directory
   295    295   ** zFile will be written to exists, creating it if required. The permissions
   296         -** for any path components created by this function are set to (mode&0777).
          296  +** for any path components created by this function are set in accordance
          297  +** with the current umask.
   297    298   **
   298    299   ** If an OOM condition is encountered, SQLITE_NOMEM is returned. Otherwise,
   299    300   ** SQLITE_OK is returned if the directory is successfully created, or
   300    301   ** SQLITE_ERROR otherwise.
   301    302   */
   302    303   static int makeDirectory(
   303         -  const char *zFile,
   304         -  mode_t mode
          304  +  const char *zFile
   305    305   ){
   306    306     char *zCopy = sqlite3_mprintf("%s", zFile);
   307    307     int rc = SQLITE_OK;
   308    308   
   309    309     if( zCopy==0 ){
   310    310       rc = SQLITE_NOMEM;
   311    311     }else{
................................................................................
   318    318   
   319    319         for(; zCopy[i]!='/' && i<nCopy; i++);
   320    320         if( i==nCopy ) break;
   321    321         zCopy[i] = '\0';
   322    322   
   323    323         rc2 = fileStat(zCopy, &sStat);
   324    324         if( rc2!=0 ){
   325         -        if( mkdir(zCopy, mode & 0777) ) rc = SQLITE_ERROR;
          325  +        if( mkdir(zCopy, 0777) ) rc = SQLITE_ERROR;
   326    326         }else{
   327    327           if( !S_ISDIR(sStat.st_mode) ) rc = SQLITE_ERROR;
   328    328         }
   329    329         zCopy[i] = '/';
   330    330         i++;
   331    331       }
   332    332   
................................................................................
   476    476     }
   477    477     if( argc==4 ){
   478    478       mtime = sqlite3_value_int64(argv[3]);
   479    479     }
   480    480   
   481    481     res = writeFile(context, zFile, argv[1], mode, mtime);
   482    482     if( res==1 && errno==ENOENT ){
   483         -    if( makeDirectory(zFile, mode)==SQLITE_OK ){
          483  +    if( makeDirectory(zFile)==SQLITE_OK ){
   484    484         res = writeFile(context, zFile, argv[1], mode, mtime);
   485    485       }
   486    486     }
   487    487   
   488    488     if( argc>2 && res!=0 ){
   489    489       if( S_ISLNK(mode) ){
   490    490         ctxErrorMsg(context, "failed to create symlink: %s", zFile);

Changes to ext/misc/fuzzer.c.

   452    452   
   453    453     nIn = strlen(zIn);
   454    454     zOut = sqlite3_malloc64(nIn+1);
   455    455     if( zOut ){
   456    456       char q = zIn[0];              /* Quote character (if any ) */
   457    457   
   458    458       if( q!='[' && q!= '\'' && q!='"' && q!='`' ){
   459         -      memcpy(zOut, zIn, nIn+1);
          459  +      memcpy(zOut, zIn, (size_t)(nIn+1));
   460    460       }else{
   461    461         int iOut = 0;               /* Index of next byte to write to output */
   462    462         int iIn;                    /* Index of next byte to read from input */
   463    463   
   464    464         if( q=='[' ) q = ']';
   465    465         for(iIn=1; iIn<nIn; iIn++){
   466    466           if( zIn[iIn]==q ) iIn++;
................................................................................
   520    520       if( pNew==0 ){
   521    521         rc = SQLITE_NOMEM;
   522    522       }else{
   523    523         char *zTab;                 /* Dequoted name of fuzzer data table */
   524    524   
   525    525         memset(pNew, 0, sizeof(*pNew));
   526    526         pNew->zClassName = (char*)&pNew[1];
   527         -      memcpy(pNew->zClassName, zModule, nModule+1);
          527  +      memcpy(pNew->zClassName, zModule, (size_t)(nModule+1));
   528    528   
   529    529         zTab = fuzzerDequote(argv[3]);
   530    530         if( zTab==0 ){
   531    531           rc = SQLITE_NOMEM;
   532    532         }else{
   533    533           rc = fuzzerLoadRules(db, pNew, zDb, zTab, pzErr);
   534    534           sqlite3_free(zTab);

Changes to ext/misc/unionvtab.c.

   252    252   */
   253    253   static void *unionMalloc(int *pRc, sqlite3_int64 nByte){
   254    254     void *pRet;
   255    255     assert( nByte>0 );
   256    256     if( *pRc==SQLITE_OK ){
   257    257       pRet = sqlite3_malloc64(nByte);
   258    258       if( pRet ){
   259         -      memset(pRet, 0, nByte);
          259  +      memset(pRet, 0, (size_t)nByte);
   260    260       }else{
   261    261         *pRc = SQLITE_NOMEM;
   262    262       }
   263    263     }else{
   264    264       pRet = 0;
   265    265     }
   266    266     return pRet;
................................................................................
   275    275   */
   276    276   static char *unionStrdup(int *pRc, const char *zIn){
   277    277     char *zRet = 0;
   278    278     if( zIn ){
   279    279       sqlite3_int64 nByte = strlen(zIn) + 1;
   280    280       zRet = unionMalloc(pRc, nByte);
   281    281       if( zRet ){
   282         -      memcpy(zRet, zIn, nByte);
          282  +      memcpy(zRet, zIn, (size_t)nByte);
   283    283       }
   284    284     }
   285    285     return zRet;
   286    286   }
   287    287   
   288    288   /*
   289    289   ** If the first character of the string passed as the only argument to this

Changes to ext/rtree/rtree.c.

  3752   3752   **
  3753   3753   ** The human readable string takes the form of a Tcl list with one
  3754   3754   ** entry for each cell in the r-tree node. Each entry is itself a
  3755   3755   ** list, containing the 8-byte rowid/pageno followed by the 
  3756   3756   ** <num-dimension>*2 coordinates.
  3757   3757   */
  3758   3758   static void rtreenode(sqlite3_context *ctx, int nArg, sqlite3_value **apArg){
  3759         -  char *zText = 0;
  3760   3759     RtreeNode node;
  3761   3760     Rtree tree;
  3762   3761     int ii;
         3762  +  int nData;
         3763  +  int errCode;
         3764  +  sqlite3_str *pOut;
  3763   3765   
  3764   3766     UNUSED_PARAMETER(nArg);
  3765   3767     memset(&node, 0, sizeof(RtreeNode));
  3766   3768     memset(&tree, 0, sizeof(Rtree));
  3767   3769     tree.nDim = (u8)sqlite3_value_int(apArg[0]);
         3770  +  if( tree.nDim<1 || tree.nDim>5 ) return;
  3768   3771     tree.nDim2 = tree.nDim*2;
  3769   3772     tree.nBytesPerCell = 8 + 8 * tree.nDim;
  3770   3773     node.zData = (u8 *)sqlite3_value_blob(apArg[1]);
         3774  +  nData = sqlite3_value_bytes(apArg[1]);
         3775  +  if( nData<4 ) return;
         3776  +  if( nData<NCELL(&node)*tree.nBytesPerCell ) return;
  3771   3777   
         3778  +  pOut = sqlite3_str_new(0);
  3772   3779     for(ii=0; ii<NCELL(&node); ii++){
  3773         -    char zCell[512];
  3774         -    int nCell = 0;
  3775   3780       RtreeCell cell;
  3776   3781       int jj;
  3777   3782   
  3778   3783       nodeGetCell(&tree, &node, ii, &cell);
  3779         -    sqlite3_snprintf(512-nCell,&zCell[nCell],"%lld", cell.iRowid);
  3780         -    nCell = (int)strlen(zCell);
         3784  +    if( ii>0 ) sqlite3_str_append(pOut, " ", 1);
         3785  +    sqlite3_str_appendf(pOut, "{%lld", cell.iRowid);
  3781   3786       for(jj=0; jj<tree.nDim2; jj++){
  3782   3787   #ifndef SQLITE_RTREE_INT_ONLY
  3783         -      sqlite3_snprintf(512-nCell,&zCell[nCell], " %g",
  3784         -                       (double)cell.aCoord[jj].f);
         3788  +      sqlite3_str_appendf(pOut, " %g", (double)cell.aCoord[jj].f);
  3785   3789   #else
  3786         -      sqlite3_snprintf(512-nCell,&zCell[nCell], " %d",
  3787         -                       cell.aCoord[jj].i);
         3790  +      sqlite3_str_appendf(pOut, " %d", cell.aCoord[jj].i);
  3788   3791   #endif
  3789         -      nCell = (int)strlen(zCell);
  3790   3792       }
  3791         -
  3792         -    if( zText ){
  3793         -      char *zTextNew = sqlite3_mprintf("%s {%s}", zText, zCell);
  3794         -      sqlite3_free(zText);
  3795         -      zText = zTextNew;
  3796         -    }else{
  3797         -      zText = sqlite3_mprintf("{%s}", zCell);
  3798         -    }
         3793  +    sqlite3_str_append(pOut, "}", 1);
  3799   3794     }
  3800         -  
  3801         -  sqlite3_result_text(ctx, zText, -1, sqlite3_free);
         3795  +  errCode = sqlite3_str_errcode(pOut);
         3796  +  sqlite3_result_text(ctx, sqlite3_str_finish(pOut), -1, sqlite3_free);
         3797  +  sqlite3_result_error_code(ctx, errCode);
  3802   3798   }
  3803   3799   
  3804   3800   /* This routine implements an SQL function that returns the "depth" parameter
  3805   3801   ** from the front of a blob that is an r-tree node.  For example:
  3806   3802   **
  3807   3803   **     SELECT rtreedepth(data) FROM rt_node WHERE nodeno=1;
  3808   3804   **

Changes to ext/session/changeset.c.

    51     51     }
    52     52     fseek(f, 0, SEEK_END);
    53     53     sz = ftell(f);
    54     54     rewind(f);
    55     55     pBuf = sqlite3_malloc64( sz ? sz : 1 );
    56     56     if( pBuf==0 ){
    57     57       fprintf(stderr, "cannot allocate %d to hold content of \"%s\"\n",
    58         -            sz, zFilename);
           58  +            (int)sz, zFilename);
    59     59       exit(1);
    60     60     }
    61     61     if( sz>0 ){
    62         -    if( fread(pBuf, sz, 1, f)!=1 ){
    63         -      fprintf(stderr, "cannot read all %d bytes of \"%s\"\n", sz, zFilename);
           62  +    if( fread(pBuf, (size_t)sz, 1, f)!=1 ){
           63  +      fprintf(stderr, "cannot read all %d bytes of \"%s\"\n",
           64  +              (int)sz, zFilename);
    64     65         exit(1);
    65     66       }
    66     67       fclose(f);
    67     68     }
    68         -  *pSz = sz;
           69  +  *pSz = (int)sz;
    69     70     *ppBuf = pBuf;
    70     71   }
    71     72   
    72     73   /* Array for converting from half-bytes (nybbles) into ASCII hex
    73     74   ** digits. */
    74     75   static const char hexdigits[] = {
    75     76     '0', '1', '2', '3', '4', '5', '6', '7',

Changes to src/btree.c.

  1457   1457           }
  1458   1458           if( iFree2 ){
  1459   1459             if( iFree+sz>iFree2 ) return SQLITE_CORRUPT_PAGE(pPage);
  1460   1460             sz2 = get2byte(&data[iFree2+2]);
  1461   1461             if( iFree2+sz2 > usableSize ) return SQLITE_CORRUPT_PAGE(pPage);
  1462   1462             memmove(&data[iFree+sz+sz2], &data[iFree+sz], iFree2-(iFree+sz));
  1463   1463             sz += sz2;
         1464  +        }else if( iFree+sz>usableSize ){
         1465  +          return SQLITE_CORRUPT_PAGE(pPage);
  1464   1466           }
         1467  +
  1465   1468           cbrk = top+sz;
  1466   1469           assert( cbrk+(iFree-top) <= usableSize );
  1467   1470           memmove(&data[cbrk], &data[top], iFree-top);
  1468   1471           for(pAddr=&data[cellOffset]; pAddr<pEnd; pAddr+=2){
  1469   1472             pc = get2byte(pAddr);
  1470   1473             if( pc<iFree ){ put2byte(pAddr, pc+sz); }
  1471   1474             else if( pc<iFree2 ){ put2byte(pAddr, pc+sz2); }
................................................................................
  2015   2018     }
  2016   2019     testcase( pPage->nCell==MX_CELL(pBt) );
  2017   2020     /* EVIDENCE-OF: R-24089-57979 If a page contains no cells (which is only
  2018   2021     ** possible for a root page of a table that contains no rows) then the
  2019   2022     ** offset to the cell content area will equal the page size minus the
  2020   2023     ** bytes of reserved space. */
  2021   2024     assert( pPage->nCell>0
  2022         -       || get2byteNotZero(&data[5])==pBt->usableSize
         2025  +       || get2byteNotZero(&data[5])==(int)pBt->usableSize
  2023   2026          || CORRUPT_DB );
  2024   2027     pPage->nFree = -1;  /* Indicate that this value is yet uncomputed */
  2025   2028     pPage->isInit = 1;
  2026   2029     if( pBt->db->flags & SQLITE_CellSizeCk ){
  2027   2030       return btreeCellSizeCheck(pPage);
  2028   2031     }
  2029   2032     return SQLITE_OK;
................................................................................
  6192   6195     int rc;                             /* Return Code */
  6193   6196     int nFree;                          /* Initial number of pages on free-list */
  6194   6197   
  6195   6198     assert( sqlite3_mutex_held(pBt->mutex) );
  6196   6199     assert( CORRUPT_DB || iPage>1 );
  6197   6200     assert( !pMemPage || pMemPage->pgno==iPage );
  6198   6201   
  6199         -  if( iPage<2 ) return SQLITE_CORRUPT_BKPT;
         6202  +  if( iPage<2 || iPage>pBt->nPage ){
         6203  +    return SQLITE_CORRUPT_BKPT;
         6204  +  }
  6200   6205     if( pMemPage ){
  6201   6206       pPage = pMemPage;
  6202   6207       sqlite3PagerRef(pPage->pDbPage);
  6203   6208     }else{
  6204   6209       pPage = btreePageLookup(pBt, iPage);
  6205   6210     }
  6206   6211   
................................................................................
  8165   8170       ** by smaller than the child due to the database header, and so all the
  8166   8171       ** free space needs to be up front.
  8167   8172       */
  8168   8173       assert( nNew==1 || CORRUPT_DB );
  8169   8174       rc = defragmentPage(apNew[0], -1);
  8170   8175       testcase( rc!=SQLITE_OK );
  8171   8176       assert( apNew[0]->nFree == 
  8172         -        (get2byte(&apNew[0]->aData[5])-apNew[0]->cellOffset-apNew[0]->nCell*2)
         8177  +        (get2byteNotZero(&apNew[0]->aData[5]) - apNew[0]->cellOffset
         8178  +          - apNew[0]->nCell*2)
  8173   8179         || rc!=SQLITE_OK
  8174   8180       );
  8175   8181       copyNodeContent(apNew[0], pParent, &rc);
  8176   8182       freePage(apNew[0], &rc);
  8177   8183     }else if( ISAUTOVACUUM && !leafCorrection ){
  8178   8184       /* Fix the pointer map entries associated with the right-child of each
  8179   8185       ** sibling page. All other pointer map entries have already been taken

Changes to src/build.c.

  1400   1400     }
  1401   1401     if( nTerm==1
  1402   1402      && pCol
  1403   1403      && sqlite3StrICmp(sqlite3ColumnType(pCol,""), "INTEGER")==0
  1404   1404      && sortOrder!=SQLITE_SO_DESC
  1405   1405     ){
  1406   1406       if( IN_RENAME_OBJECT && pList ){
  1407         -      sqlite3RenameTokenRemap(pParse, &pTab->iPKey, pList->a[0].pExpr);
         1407  +      Expr *pCExpr = sqlite3ExprSkipCollate(pList->a[0].pExpr);
         1408  +      sqlite3RenameTokenRemap(pParse, &pTab->iPKey, pCExpr);
  1408   1409       }
  1409   1410       pTab->iPKey = iCol;
  1410   1411       pTab->keyConf = (u8)onError;
  1411   1412       assert( autoInc==0 || autoInc==1 );
  1412   1413       pTab->tabFlags |= autoInc*TF_Autoincrement;
  1413   1414       if( pList ) pParse->iPkSortOrder = pList->a[0].sortOrder;
  1414   1415     }else if( autoInc ){
................................................................................
  3149   3150     }
  3150   3151     pDb = &db->aDb[iDb];
  3151   3152   
  3152   3153     assert( pTab!=0 );
  3153   3154     assert( pParse->nErr==0 );
  3154   3155     if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0 
  3155   3156          && db->init.busy==0
         3157  +       && pTblName!=0
  3156   3158   #if SQLITE_USER_AUTHENTICATION
  3157   3159          && sqlite3UserAuthTable(pTab->zName)==0
  3158   3160   #endif
  3159   3161   #ifdef SQLITE_ALLOW_SQLITE_MASTER_INDEX
  3160   3162          && sqlite3StrICmp(&pTab->zName[7],"master")!=0
  3161   3163   #endif
  3162         -       && sqlite3StrNICmp(&pTab->zName[7],"altertab_",9)!=0
  3163   3164    ){
  3164   3165       sqlite3ErrorMsg(pParse, "table %s may not be indexed", pTab->zName);
  3165   3166       goto exit_create_index;
  3166   3167     }
  3167   3168   #ifndef SQLITE_OMIT_VIEW
  3168   3169     if( pTab->pSelect ){
  3169   3170       sqlite3ErrorMsg(pParse, "views may not be indexed");

Changes to src/main.c.

   842    842           { SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER, SQLITE_Fts3Tokenizer  },
   843    843           { SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION, SQLITE_LoadExtension  },
   844    844           { SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE,      SQLITE_NoCkptOnClose  },
   845    845           { SQLITE_DBCONFIG_ENABLE_QPSG,           SQLITE_EnableQPSG     },
   846    846           { SQLITE_DBCONFIG_TRIGGER_EQP,           SQLITE_TriggerEQP     },
   847    847           { SQLITE_DBCONFIG_RESET_DATABASE,        SQLITE_ResetDatabase  },
   848    848           { SQLITE_DBCONFIG_DEFENSIVE,             SQLITE_Defensive      },
          849  +        { SQLITE_DBCONFIG_WRITABLE_SCHEMA,       SQLITE_WriteSchema|
          850  +                                                 SQLITE_NoSchemaError  },
   849    851         };
   850    852         unsigned int i;
   851    853         rc = SQLITE_ERROR; /* IMP: R-42790-23372 */
   852    854         for(i=0; i<ArraySize(aFlagOp); i++){
   853    855           if( aFlagOp[i].op==op ){
   854    856             int onoff = va_arg(ap, int);
   855    857             int *pRes = va_arg(ap, int*);

Changes to src/shell.c.in.

  2743   2743     sqlite3SelectTrace = savedSelectTrace;
  2744   2744   #endif
  2745   2745   #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_WHERETRACE)
  2746   2746     sqlite3WhereTrace = savedWhereTrace;
  2747   2747   #endif
  2748   2748   }
  2749   2749   
  2750         -/* Name of the TEMP table that holds bind parameter values */
  2751         -#define BIND_PARAM_TABLE "$Parameters"
  2752         -
  2753   2750   /* Create the TEMP table used to store parameter bindings */
  2754   2751   static void bind_table_init(ShellState *p){
         2752  +  int wrSchema = 0;
         2753  +  sqlite3_db_config(p->db, SQLITE_DBCONFIG_WRITABLE_SCHEMA, -1, &wrSchema);
         2754  +  sqlite3_db_config(p->db, SQLITE_DBCONFIG_WRITABLE_SCHEMA, 1, 0);
  2755   2755     sqlite3_exec(p->db,
  2756         -    "CREATE TABLE IF NOT EXISTS temp.[" BIND_PARAM_TABLE "](\n"
         2756  +    "CREATE TABLE IF NOT EXISTS temp.sqlite_parameters(\n"
  2757   2757       "  key TEXT PRIMARY KEY,\n"
  2758   2758       "  value ANY\n"
  2759   2759       ") WITHOUT ROWID;",
  2760   2760       0, 0, 0);
         2761  +  sqlite3_db_config(p->db, SQLITE_DBCONFIG_WRITABLE_SCHEMA, wrSchema, 0);
  2761   2762   }
  2762   2763   
  2763   2764   /*
  2764   2765   ** Bind parameters on a prepared statement.
  2765   2766   **
  2766   2767   ** Parameter bindings are taken from a TEMP table of the form:
  2767   2768   **
  2768         -**    CREATE TEMP TABLE "$Parameters"(key TEXT PRIMARY KEY, value)
         2769  +**    CREATE TEMP TABLE sqlite_parameters(key TEXT PRIMARY KEY, value)
  2769   2770   **    WITHOUT ROWID;
  2770   2771   **
  2771   2772   ** No bindings occur if this table does not exist.  The special character '$'
  2772   2773   ** is included in the table name to help prevent collisions with actual tables.
  2773   2774   ** The table must be in the TEMP schema.
  2774   2775   */
  2775   2776   static void bind_prepared_stmt(ShellState *pArg, sqlite3_stmt *pStmt){
................................................................................
  2776   2777     int nVar;
  2777   2778     int i;
  2778   2779     int rc;
  2779   2780     sqlite3_stmt *pQ = 0;
  2780   2781   
  2781   2782     nVar = sqlite3_bind_parameter_count(pStmt);
  2782   2783     if( nVar==0 ) return;  /* Nothing to do */
  2783         -  if( sqlite3_table_column_metadata(pArg->db, "TEMP", BIND_PARAM_TABLE,
         2784  +  if( sqlite3_table_column_metadata(pArg->db, "TEMP", "sqlite_parameters",
  2784   2785                                       "key", 0, 0, 0, 0, 0)!=SQLITE_OK ){
  2785   2786       return; /* Parameter table does not exist */
  2786   2787     }
  2787   2788     rc = sqlite3_prepare_v2(pArg->db,
  2788         -          "SELECT value FROM temp.\"" BIND_PARAM_TABLE "\""
         2789  +          "SELECT value FROM temp.sqlite_parameters"
  2789   2790             " WHERE key=?1", -1, &pQ, 0);
  2790   2791     if( rc || pQ==0 ) return;
  2791   2792     for(i=1; i<=nVar; i++){
  2792   2793       char zNum[30];
  2793   2794       const char *zVar = sqlite3_bind_parameter_name(pStmt, i);
  2794   2795       if( zVar==0 ){
  2795   2796         sqlite3_snprintf(sizeof(zNum),zNum,"?%d",i);
................................................................................
  3448   3449   ** start of the description of what that command does.
  3449   3450   */
  3450   3451   static const char *(azHelp[]) = {
  3451   3452   #if defined(SQLITE_HAVE_ZLIB) && !defined(SQLITE_OMIT_VIRTUALTABLE)
  3452   3453     ".archive ...             Manage SQL archives",
  3453   3454     "   Each command must have exactly one of the following options:",
  3454   3455     "     -c, --create               Create a new archive",
  3455         -  "     -u, --update               Update or add files to an existing archive",
         3456  +  "     -u, --update               Add files or update files with changed mtime",
         3457  +  "     -i, --insert               Like -u but always add even if mtime unchanged",
  3456   3458     "     -t, --list                 List contents of archive",
  3457   3459     "     -x, --extract              Extract files from archive",
  3458   3460     "   Optional arguments:",
  3459   3461     "     -v, --verbose              Print each filename as it is processed",
  3460   3462     "     -f FILE, --file FILE       Operate on archive FILE (default is current db)",
  3461   3463     "     -a FILE, --append FILE     Operate on FILE opened using the apndvfs VFS",
  3462   3464     "     -C DIR, --directory DIR    Change to directory DIR to read/extract files",
................................................................................
  4769   4771        { "number of triggers:",
  4770   4772          "SELECT count(*) FROM %s WHERE type='trigger'" },
  4771   4773        { "number of views:",
  4772   4774          "SELECT count(*) FROM %s WHERE type='view'" },
  4773   4775        { "schema size:",
  4774   4776          "SELECT total(length(sql)) FROM %s" },
  4775   4777     };
  4776         -  int i;
         4778  +  int i, rc;
  4777   4779     unsigned iDataVersion;
  4778   4780     char *zSchemaTab;
  4779   4781     char *zDb = nArg>=2 ? azArg[1] : "main";
  4780   4782     sqlite3_stmt *pStmt = 0;
  4781   4783     unsigned char aHdr[100];
  4782   4784     open_db(p, 0);
  4783   4785     if( p->db==0 ) return 1;
  4784         -  sqlite3_prepare_v2(p->db,"SELECT data FROM sqlite_dbpage(?1) WHERE pgno=1",
  4785         -                     -1, &pStmt, 0);
         4786  +  rc = sqlite3_prepare_v2(p->db,
         4787  +             "SELECT data FROM sqlite_dbpage(?1) WHERE pgno=1",
         4788  +             -1, &pStmt, 0);
         4789  +  if( rc ){
         4790  +    if( !sqlite3_compileoption_used("ENABLE_DBPAGE_VTAB") ){
         4791  +      utf8_printf(stderr, "the \".dbinfo\" command requires the "
         4792  +                          "-DSQLITE_ENABLE_DBPAGE_VTAB compile-time options\n");
         4793  +    }else{
         4794  +      utf8_printf(stderr, "error: %s\n", sqlite3_errmsg(p->db));
         4795  +    }
         4796  +    sqlite3_finalize(pStmt);
         4797  +    return 1;
         4798  +  }
  4786   4799     sqlite3_bind_text(pStmt, 1, zDb, -1, SQLITE_STATIC);
  4787   4800     if( sqlite3_step(pStmt)==SQLITE_ROW
  4788   4801      && sqlite3_column_bytes(pStmt,0)>100
  4789   4802     ){
  4790   4803       memcpy(aHdr, sqlite3_column_blob(pStmt,0), 100);
  4791   4804       sqlite3_finalize(pStmt);
  4792   4805     }else{
................................................................................
  5372   5385     return SQLITE_ERROR;
  5373   5386   }
  5374   5387   
  5375   5388   /*
  5376   5389   ** Values for ArCommand.eCmd.
  5377   5390   */
  5378   5391   #define AR_CMD_CREATE       1
  5379         -#define AR_CMD_EXTRACT      2
  5380         -#define AR_CMD_LIST         3
  5381         -#define AR_CMD_UPDATE       4
  5382         -#define AR_CMD_HELP         5
         5392  +#define AR_CMD_UPDATE       2
         5393  +#define AR_CMD_INSERT       3
         5394  +#define AR_CMD_EXTRACT      4
         5395  +#define AR_CMD_LIST         5
         5396  +#define AR_CMD_HELP         6
  5383   5397   
  5384   5398   /*
  5385   5399   ** Other (non-command) switches.
  5386   5400   */
  5387         -#define AR_SWITCH_VERBOSE     6
  5388         -#define AR_SWITCH_FILE        7
  5389         -#define AR_SWITCH_DIRECTORY   8
  5390         -#define AR_SWITCH_APPEND      9
  5391         -#define AR_SWITCH_DRYRUN     10
         5401  +#define AR_SWITCH_VERBOSE     7
         5402  +#define AR_SWITCH_FILE        8
         5403  +#define AR_SWITCH_DIRECTORY   9
         5404  +#define AR_SWITCH_APPEND     10
         5405  +#define AR_SWITCH_DRYRUN     11
  5392   5406   
  5393   5407   static int arProcessSwitch(ArCommand *pAr, int eSwitch, const char *zArg){
  5394   5408     switch( eSwitch ){
  5395   5409       case AR_CMD_CREATE:
  5396   5410       case AR_CMD_EXTRACT:
  5397   5411       case AR_CMD_LIST:
  5398   5412       case AR_CMD_UPDATE:
         5413  +    case AR_CMD_INSERT:
  5399   5414       case AR_CMD_HELP:
  5400   5415         if( pAr->eCmd ){
  5401   5416           return arErrorMsg(pAr, "multiple command options");
  5402   5417         }
  5403   5418         pAr->eCmd = eSwitch;
  5404   5419         break;
  5405   5420   
................................................................................
  5438   5453       const char *zLong;
  5439   5454       char cShort;
  5440   5455       u8 eSwitch;
  5441   5456       u8 bArg;
  5442   5457     } aSwitch[] = {
  5443   5458       { "create",    'c', AR_CMD_CREATE,       0 },
  5444   5459       { "extract",   'x', AR_CMD_EXTRACT,      0 },
         5460  +    { "insert",    'i', AR_CMD_INSERT,       0 },
  5445   5461       { "list",      't', AR_CMD_LIST,         0 },
  5446   5462       { "update",    'u', AR_CMD_UPDATE,       0 },
  5447   5463       { "help",      'h', AR_CMD_HELP,         0 },
  5448   5464       { "verbose",   'v', AR_SWITCH_VERBOSE,   0 },
  5449   5465       { "file",      'f', AR_SWITCH_FILE,      1 },
  5450   5466       { "append",    'a', AR_SWITCH_APPEND,    1 },
  5451   5467       { "directory", 'C', AR_SWITCH_DIRECTORY, 1 },
................................................................................
  5773   5789       }
  5774   5790     }
  5775   5791     return rc;
  5776   5792   }
  5777   5793   
  5778   5794   
  5779   5795   /*
  5780         -** Implementation of .ar "create" and "update" commands.
         5796  +** Implementation of .ar "create", "insert", and "update" commands.
         5797  +**
         5798  +**     create    ->     Create a new SQL archive
         5799  +**     insert    ->     Insert or reinsert all files listed
         5800  +**     update    ->     Insert files that have changed or that were not
         5801  +**                      previously in the archive
  5781   5802   **
  5782   5803   ** Create the "sqlar" table in the database if it does not already exist.
  5783   5804   ** Then add each file in the azFile[] array to the archive. Directories
  5784   5805   ** are added recursively. If argument bVerbose is non-zero, a message is
  5785   5806   ** printed on stdout for each file archived.
  5786   5807   **
  5787   5808   ** The create command is the same as update, except that it drops
  5788         -** any existing "sqlar" table before beginning.
         5809  +** any existing "sqlar" table before beginning.  The "insert" command
         5810  +** always overwrites every file named on the command-line, where as
         5811  +** "update" only overwrites if the size or mtime or mode has changed.
  5789   5812   */
  5790   5813   static int arCreateOrUpdateCommand(
  5791   5814     ArCommand *pAr,                 /* Command arguments and options */
  5792         -  int bUpdate                     /* true for a --create.  false for --update */
         5815  +  int bUpdate,                    /* true for a --create. */
         5816  +  int bOnlyIfChanged              /* Only update if file has changed */
  5793   5817   ){
  5794   5818     const char *zCreate = 
  5795   5819         "CREATE TABLE IF NOT EXISTS sqlar(\n"
  5796   5820         "  name TEXT PRIMARY KEY,  -- name of the file\n"
  5797   5821         "  mode INT,               -- access permissions\n"
  5798   5822         "  mtime INT,              -- last modification time\n"
  5799   5823         "  sz INT,                 -- original file size\n"
................................................................................
  5807   5831        "    mode,\n"
  5808   5832        "    mtime,\n"
  5809   5833        "    CASE substr(lsmode(mode),1,1)\n"
  5810   5834        "      WHEN '-' THEN length(data)\n"
  5811   5835        "      WHEN 'd' THEN 0\n"
  5812   5836        "      ELSE -1 END,\n"
  5813   5837        "    sqlar_compress(data)\n"
  5814         -     "  FROM fsdir(%Q,%Q)\n"
  5815         -     "  WHERE lsmode(mode) NOT LIKE '?%%';",
         5838  +     "  FROM fsdir(%Q,%Q) AS disk\n"
         5839  +     "  WHERE lsmode(mode) NOT LIKE '?%%'%s;"
         5840  +     ,
  5816   5841        "REPLACE INTO %s(name,mode,mtime,data)\n"
  5817   5842        "  SELECT\n"
  5818   5843        "    %s,\n"
  5819   5844        "    mode,\n"
  5820   5845        "    mtime,\n"
  5821   5846        "    data\n"
  5822         -     "  FROM fsdir(%Q,%Q)\n"
  5823         -     "  WHERE lsmode(mode) NOT LIKE '?%%';"
         5847  +     "  FROM fsdir(%Q,%Q) AS disk\n"
         5848  +     "  WHERE lsmode(mode) NOT LIKE '?%%'%s;"
  5824   5849     };
  5825   5850     int i;                          /* For iterating through azFile[] */
  5826   5851     int rc;                         /* Return code */
  5827   5852     const char *zTab = 0;           /* SQL table into which to insert */
  5828   5853     char *zSql;
  5829   5854     char zTemp[50];
         5855  +  char *zExists = 0;
  5830   5856   
  5831   5857     arExecSql(pAr, "PRAGMA page_size=512");
  5832   5858     rc = arExecSql(pAr, "SAVEPOINT ar;");
  5833   5859     if( rc!=SQLITE_OK ) return rc;
  5834   5860     zTemp[0] = 0; 
  5835   5861     if( pAr->bZip ){
  5836   5862       /* Initialize the zipfile virtual table, if necessary */
................................................................................
  5853   5879       zTab = "sqlar";
  5854   5880       if( bUpdate==0 ){
  5855   5881         rc = arExecSql(pAr, zDrop);
  5856   5882         if( rc!=SQLITE_OK ) goto end_ar_transaction;
  5857   5883       }
  5858   5884       rc = arExecSql(pAr, zCreate);
  5859   5885     }
         5886  +  if( bOnlyIfChanged ){
         5887  +    zExists = sqlite3_mprintf(
         5888  +      " AND NOT EXISTS("
         5889  +          "SELECT 1 FROM %s AS mem"
         5890  +          " WHERE mem.name=disk.name"
         5891  +          " AND mem.mtime=disk.mtime"
         5892  +          " AND mem.mode=disk.mode)", zTab);
         5893  +  }else{
         5894  +    zExists = sqlite3_mprintf("");
         5895  +  }
         5896  +  if( zExists==0 ) rc = SQLITE_NOMEM;
  5860   5897     for(i=0; i<pAr->nArg && rc==SQLITE_OK; i++){
  5861   5898       char *zSql2 = sqlite3_mprintf(zInsertFmt[pAr->bZip], zTab,
  5862   5899           pAr->bVerbose ? "shell_putsnl(name)" : "name",
  5863         -        pAr->azArg[i], pAr->zDir);
         5900  +        pAr->azArg[i], pAr->zDir, zExists);
  5864   5901       rc = arExecSql(pAr, zSql2);
  5865   5902       sqlite3_free(zSql2);
  5866   5903     }
  5867   5904   end_ar_transaction:
  5868   5905     if( rc!=SQLITE_OK ){
  5869   5906       sqlite3_exec(pAr->db, "ROLLBACK TO ar; RELEASE ar;", 0, 0, 0);
  5870   5907     }else{
................................................................................
  5871   5908       rc = arExecSql(pAr, "RELEASE ar;");
  5872   5909       if( pAr->bZip && pAr->zFile ){
  5873   5910         zSql = sqlite3_mprintf("DROP TABLE %s", zTemp);
  5874   5911         arExecSql(pAr, zSql);
  5875   5912         sqlite3_free(zSql);
  5876   5913       }
  5877   5914     }
         5915  +  sqlite3_free(zExists);
  5878   5916     return rc;
  5879   5917   }
  5880   5918   
  5881   5919   /*
  5882   5920   ** Implementation of ".ar" dot command.
  5883   5921   */
  5884   5922   static int arDotCommand(
................................................................................
  5909   5947             cmd.zSrcTable = sqlite3_mprintf("zipfile(%Q)", cmd.zFile);
  5910   5948           }
  5911   5949         }
  5912   5950         cmd.bZip = 1;
  5913   5951       }else if( cmd.zFile ){
  5914   5952         int flags;
  5915   5953         if( cmd.bAppend ) eDbType = SHELL_OPEN_APPENDVFS;
  5916         -      if( cmd.eCmd==AR_CMD_CREATE || cmd.eCmd==AR_CMD_UPDATE ){
         5954  +      if( cmd.eCmd==AR_CMD_CREATE || cmd.eCmd==AR_CMD_INSERT 
         5955  +           || cmd.eCmd==AR_CMD_UPDATE ){
  5917   5956           flags = SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE;
  5918   5957         }else{
  5919   5958           flags = SQLITE_OPEN_READONLY;
  5920   5959         }
  5921   5960         cmd.db = 0;
  5922   5961         if( cmd.bDryRun ){
  5923   5962           utf8_printf(pState->out, "-- open database '%s'%s\n", cmd.zFile,
................................................................................
  5946   5985           goto end_ar_command;
  5947   5986         }
  5948   5987         cmd.zSrcTable = sqlite3_mprintf("sqlar");
  5949   5988       }
  5950   5989   
  5951   5990       switch( cmd.eCmd ){
  5952   5991         case AR_CMD_CREATE:
  5953         -        rc = arCreateOrUpdateCommand(&cmd, 0);
         5992  +        rc = arCreateOrUpdateCommand(&cmd, 0, 0);
  5954   5993           break;
  5955   5994   
  5956   5995         case AR_CMD_EXTRACT:
  5957   5996           rc = arExtractCommand(&cmd);
  5958   5997           break;
  5959   5998   
  5960   5999         case AR_CMD_LIST:
................................................................................
  5961   6000           rc = arListCommand(&cmd);
  5962   6001           break;
  5963   6002   
  5964   6003         case AR_CMD_HELP:
  5965   6004           arUsage(pState->out);
  5966   6005           break;
  5967   6006   
         6007  +      case AR_CMD_INSERT:
         6008  +        rc = arCreateOrUpdateCommand(&cmd, 1, 0);
         6009  +        break;
         6010  +
  5968   6011         default:
  5969   6012           assert( cmd.eCmd==AR_CMD_UPDATE );
  5970         -        rc = arCreateOrUpdateCommand(&cmd, 1);
         6013  +        rc = arCreateOrUpdateCommand(&cmd, 1, 1);
  5971   6014           break;
  5972   6015       }
  5973   6016     }
  5974   6017   end_ar_command:
  5975   6018     if( cmd.db!=pState->db ){
  5976   6019       close_db(cmd.db);
  5977   6020     }
................................................................................
  7096   7139       open_db(p,0);
  7097   7140       if( nArg<=1 ) goto parameter_syntax_error;
  7098   7141   
  7099   7142       /* .parameter clear
  7100   7143       ** Clear all bind parameters by dropping the TEMP table that holds them.
  7101   7144       */
  7102   7145       if( nArg==2 && strcmp(azArg[1],"clear")==0 ){
  7103         -      sqlite3_exec(p->db, "DROP TABLE IF EXISTS temp.[" BIND_PARAM_TABLE "];",
         7146  +      int wrSchema = 0;
         7147  +      sqlite3_db_config(p->db, SQLITE_DBCONFIG_WRITABLE_SCHEMA, -1, &wrSchema);
         7148  +      sqlite3_db_config(p->db, SQLITE_DBCONFIG_WRITABLE_SCHEMA, 1, 0);
         7149  +      sqlite3_exec(p->db, "DROP TABLE IF EXISTS temp.sqlite_parameters;",
  7104   7150                      0, 0, 0);
         7151  +      sqlite3_db_config(p->db, SQLITE_DBCONFIG_WRITABLE_SCHEMA, wrSchema, 0);
  7105   7152       }else
  7106   7153   
  7107   7154       /* .parameter list
  7108   7155       ** List all bind parameters.
  7109   7156       */
  7110   7157       if( nArg==2 && strcmp(azArg[1],"list")==0 ){
  7111   7158         sqlite3_stmt *pStmt = 0;
  7112   7159         int rx;
  7113   7160         int len = 0;
  7114   7161         rx = sqlite3_prepare_v2(p->db,
  7115   7162                "SELECT max(length(key)) "
  7116         -             "FROM temp.[" BIND_PARAM_TABLE "];", -1, &pStmt, 0);
         7163  +             "FROM temp.sqlite_parameters;", -1, &pStmt, 0);
  7117   7164         if( rx==SQLITE_OK && sqlite3_step(pStmt)==SQLITE_ROW ){
  7118   7165           len = sqlite3_column_int(pStmt, 0);
  7119   7166           if( len>40 ) len = 40;
  7120   7167         }
  7121   7168         sqlite3_finalize(pStmt);
  7122   7169         pStmt = 0;
  7123   7170         if( len ){
  7124   7171           rx = sqlite3_prepare_v2(p->db,
  7125   7172                "SELECT key, quote(value) "
  7126         -             "FROM temp.[" BIND_PARAM_TABLE "];", -1, &pStmt, 0);
         7173  +             "FROM temp.sqlite_parameters;", -1, &pStmt, 0);
  7127   7174           while( sqlite3_step(pStmt)==SQLITE_ROW ){
  7128   7175             utf8_printf(p->out, "%-*s %s\n", len, sqlite3_column_text(pStmt,0),
  7129   7176                         sqlite3_column_text(pStmt,1));
  7130   7177           }
  7131   7178           sqlite3_finalize(pStmt);
  7132   7179         }
  7133   7180       }else
................................................................................
  7150   7197         int rx;
  7151   7198         char *zSql;
  7152   7199         sqlite3_stmt *pStmt;
  7153   7200         const char *zKey = azArg[2];
  7154   7201         const char *zValue = azArg[3];
  7155   7202         bind_table_init(p);
  7156   7203         zSql = sqlite3_mprintf(
  7157         -                  "REPLACE INTO temp.[" BIND_PARAM_TABLE "](key,value)"
         7204  +                  "REPLACE INTO temp.sqlite_parameters(key,value)"
  7158   7205                     "VALUES(%Q,%s);", zKey, zValue);
  7159   7206         if( zSql==0 ) shell_out_of_memory();
  7160   7207         pStmt = 0;
  7161   7208         rx = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
  7162   7209         sqlite3_free(zSql);
  7163   7210         if( rx!=SQLITE_OK ){
  7164   7211           sqlite3_finalize(pStmt);
  7165   7212           pStmt = 0;
  7166   7213           zSql = sqlite3_mprintf(
  7167         -                   "REPLACE INTO temp.[" BIND_PARAM_TABLE "](key,value)"
         7214  +                   "REPLACE INTO temp.sqlite_parameters(key,value)"
  7168   7215                      "VALUES(%Q,%Q);", zKey, zValue);
  7169   7216           if( zSql==0 ) shell_out_of_memory();
  7170   7217           rx = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
  7171   7218           sqlite3_free(zSql);
  7172   7219           if( rx!=SQLITE_OK ){
  7173   7220             utf8_printf(p->out, "Error: %s\n", sqlite3_errmsg(p->db));
  7174   7221             sqlite3_finalize(pStmt);
................................................................................
  7182   7229   
  7183   7230       /* .parameter unset NAME
  7184   7231       ** Remove the NAME binding from the parameter binding table, if it
  7185   7232       ** exists.
  7186   7233       */
  7187   7234       if( nArg==3 && strcmp(azArg[1],"unset")==0 ){
  7188   7235         char *zSql = sqlite3_mprintf(
  7189         -          "DELETE FROM temp.[" BIND_PARAM_TABLE "] WHERE key=%Q", azArg[2]);
         7236  +          "DELETE FROM temp.sqlite_parameters WHERE key=%Q", azArg[2]);
  7190   7237         if( zSql==0 ) shell_out_of_memory();
  7191   7238         sqlite3_exec(p->db, zSql, 0, 0, 0);
  7192   7239         sqlite3_free(zSql);
  7193   7240       }else
  7194   7241       /* If no command name matches, show a syntax error */
  7195   7242       parameter_syntax_error:
  7196   7243       showHelp(p->out, "parameter");

Changes to src/sqlite.h.in.

  2196   2196   ** features include but are not limited to the following:
  2197   2197   ** <ul>
  2198   2198   ** <li> The [PRAGMA writable_schema=ON] statement.
  2199   2199   ** <li> Writes to the [sqlite_dbpage] virtual table.
  2200   2200   ** <li> Direct writes to [shadow tables].
  2201   2201   ** </ul>
  2202   2202   ** </dd>
         2203  +**
         2204  +** [[SQLITE_DBCONFIG_WRITABLE_SCHEMA]] <dt>SQLITE_DBCONFIG_WRITABLE_SCHEMA</dt>
         2205  +** <dd>The SQLITE_DBCONFIG_WRITABLE_SCHEMA option activates or deactivates the
         2206  +** "writable_schema" flag. This has the same effect and is logically equivalent
         2207  +** to setting [PRAGMA writable_schema=ON] or [PRAGMA writable_schema=OFF].
         2208  +** The first argument to this setting is an integer which is 0 to disable 
         2209  +** the writable_schema, positive to enable writable_schema, or negative to
         2210  +** leave the setting unchanged. The second parameter is a pointer to an
         2211  +** integer into which is written 0 or 1 to indicate whether the writable_schema
         2212  +** is enabled or disabled following this call.
         2213  +** </dd>
  2203   2214   ** </dl>
  2204   2215   */
  2205   2216   #define SQLITE_DBCONFIG_MAINDBNAME            1000 /* const char* */
  2206   2217   #define SQLITE_DBCONFIG_LOOKASIDE             1001 /* void* int int */
  2207   2218   #define SQLITE_DBCONFIG_ENABLE_FKEY           1002 /* int int* */
  2208   2219   #define SQLITE_DBCONFIG_ENABLE_TRIGGER        1003 /* int int* */
  2209   2220   #define SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER 1004 /* int int* */
  2210   2221   #define SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION 1005 /* int int* */
  2211   2222   #define SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE      1006 /* int int* */
  2212   2223   #define SQLITE_DBCONFIG_ENABLE_QPSG           1007 /* int int* */
  2213   2224   #define SQLITE_DBCONFIG_TRIGGER_EQP           1008 /* int int* */
  2214   2225   #define SQLITE_DBCONFIG_RESET_DATABASE        1009 /* int int* */
  2215   2226   #define SQLITE_DBCONFIG_DEFENSIVE             1010 /* int int* */
  2216         -#define SQLITE_DBCONFIG_MAX                   1010 /* Largest DBCONFIG */
         2227  +#define SQLITE_DBCONFIG_WRITABLE_SCHEMA       1011 /* int int* */
         2228  +#define SQLITE_DBCONFIG_MAX                   1011 /* Largest DBCONFIG */
  2217   2229   
  2218   2230   /*
  2219   2231   ** CAPI3REF: Enable Or Disable Extended Result Codes
  2220   2232   ** METHOD: sqlite3
  2221   2233   **
  2222   2234   ** ^The sqlite3_extended_result_codes() routine enables or disables the
  2223   2235   ** [extended result codes] feature of SQLite. ^The extended result

Changes to src/test_fs.c.

   233    233   ** Skip the cursor to the next entry.
   234    234   */
   235    235   static int fsdirNext(sqlite3_vtab_cursor *cur){
   236    236     FsdirCsr *pCsr = (FsdirCsr*)cur;
   237    237   
   238    238     if( pCsr->pDir ){
   239    239       struct DIRENT *pRes = 0;
   240         -#if defined(__MINGW_H)
   241    240       pRes = readdir(pCsr->pDir);
   242    241       if( pRes!=0 ){
   243    242         memcpy(&pCsr->entry, pRes, sizeof(struct DIRENT));
   244    243       }
   245         -#else
   246         -    readdir_r(pCsr->pDir, &pCsr->entry, &pRes);
   247         -#endif
   248    244       if( pRes==0 ){
   249    245         closedir(pCsr->pDir);
   250    246         pCsr->pDir = 0;
   251    247       }
   252    248       pCsr->iRowid++;
   253    249     }
   254    250   

Changes to test/altertab3.test.

   109    109   } {1 {error in trigger tr1: no such table: main.t2}}
   110    110   do_execsql_test 4.2.2 {
   111    111     COMMIT;
   112    112   }
   113    113   do_execsql_test 4.2.3 {
   114    114     SELECT * FROM sqlite_master WHERE type='table' AND name!='t1';
   115    115   } {table t3 t3 3 {CREATE TABLE t3(e, f)}}
          116  +
          117  +#-------------------------------------------------------------------------
          118  +reset_db
          119  +do_execsql_test 5.0 {
          120  +  CREATE TABLE t1 (
          121  +      c1 integer, c2, PRIMARY KEY(c1 collate rtrim),
          122  +      UNIQUE(c2)
          123  +  )
          124  +}
          125  +do_execsql_test 5.1 {
          126  +  ALTER TABLE t1 RENAME c1 TO c3;
          127  +}
          128  +
          129  +#-------------------------------------------------------------------------
          130  +reset_db
          131  +do_execsql_test 6.0 {
          132  +  CREATE TEMPORARY TABLE Table0 (
          133  +    Col0 INTEGER, 
          134  +    PRIMARY KEY(Col0 COLLATE RTRIM), 
          135  +    FOREIGN KEY (Col0) REFERENCES Table0
          136  +  );
          137  +}
          138  +
          139  +do_execsql_test 6.1 {
          140  +  ALTER TABLE Table0 RENAME Col0 TO Col0;
          141  +}
   116    142   
   117    143   finish_test
   118    144   
   119    145   

Changes to test/corruptL.test.

   722    722   |      0: 0d 00 00 00 00 10 00 00 00 00 00 00 00 00 00 00   ................
   723    723   | end crash-8391315d75edff.db
   724    724   }]} {}
   725    725   
   726    726   do_catchsql_test 7.1 {
   727    727     SELECT * FROM sqlite_master;
   728    728   } {1 {malformed database schema (t1x1) - invalid rootpage}}
          729  +
          730  +#-------------------------------------------------------------------------
          731  +reset_db
          732  +do_test 8.0 {
          733  +  sqlite3 db {}
          734  +  db deserialize [decode_hexdb {
          735  +| size 2048 pagesize 512 filename a.db
          736  +| page 1 offset 0
          737  +|      0: 53 51 4c 69 74 65 20 66 6f 72 6d 61 74 20 33 00   SQLite format 3.
          738  +|     16: 02 00 01 01 00 40 20 20 ff ff 00 0c 00 00 00 07   .....@  ........
          739  +|     32: 0b 00 00 00 00 00 00 00 00 00 00 08 9c 00 00 04   ................
          740  +|     48: 00 00 00 e0 09 00 00 01 00 00 00 01 00 00 00 00   ................
          741  +|     64: 00 00 00 00 f2 ff 00 00 00 00 00 00 00 00 00 00   ................
          742  +|     80: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 0c   ................
          743  +|     96: 00 2e 2c 50 0d 00 00 00 06 01 06 00 01 da 01 b0   ..,P............
          744  +|    112: 05 56 01 86 01 2a 01 06 00 00 00 00 00 06 00 00   .V...*..........
          745  +|    128: 00 ff 00 00 ff ff ff e1 00 00 00 00 00 00 00 00   ................
          746  +|    144: 00 00 00 00 00 00 00 00 00 01 00 00 00 00 00 00   ................
          747  +|    160: 00 00 00 00 00 00 00 00 f2 00 00 00 00 00 00 00   ................
          748  +|    176: 00 00 f9 ff ff ff ff ff ff ff 00 00 00 5f 00 fb   ............._..
          749  +|    192: 00 00 00 00 00 00 00 00 00 e1 ff 00 00 00 00 00   ................
          750  +|    208: 00 00 10 00 00 00 00 00 1e 00 00 00 fe 00 00 00   ................
          751  +|    224: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ca 00   ................
          752  +|    240: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 35   ...............5
          753  +|    256: 00 00 00 00 ef ff 22 07 06 17 11 11 01 30 39 38   .............098
          754  +|    272: 62 6c 65 74 38 38 74 04 43 52 45 41 54 45 20 54   blet88t.CREATE T
          755  +|    288: 41 42 4c 45 20 74 34 28 87 29 2a 06 06 17 13 11   ABLE t4(.)*.....
          756  +|    304: 01 3f 69 4f 64 65 78 74 33 78 74 40 05 43 52 45   .?iOdext3xt@.CRE
          757  +|    320: 41 54 45 20 49 6e 44 45 58 20 74 33 78 20 4f 4e   ATE InDEX t3x ON
          758  +|    336: 20 74 33 28 78 29 2e 04 06 17 15 11 01 45 69 6e    t3(x).......Ein
          759  +|    352: 00 04 00 00 34 63 64 74 3d 05 43 52 45 41 54 45   ....4cdt=.CREATE
          760  +|    368: 20 49 4e 44 45 58 20 63 74 64 32 20 4f 4e 20 74    INDEX ctd2 ON t
          761  +|    384: 32 28 0a 0c 44 29 28 05 06 17 11 11 01 3d 74 6c   2(..D)(......=tl
          762  +|    400: 62 61 d4 65 33 74 33 04 43 52 45 41 54 45 20 54   ba.e3t3.CREATE T
          763  +|    416: 41 42 4c 45 20 74 33 28 63 2c 78 2c 65 2c 66 29   ABLE t3(c,x,e,f)
          764  +|    432: 28 02 06 17 11 11 01 3d 74 61 62 6c 65 74 32 74   (......=tablet2t
          765  +|    448: 32 03 43 52 45 41 54 45 20 54 41 42 4c 45 20 74   2.CREATE TABLE t
          766  +|    464: 32 28 63 2c 64 2c 65 2c 66 29 24 01 06 17 11 11   2(c,d,e,f)$.....
          767  +|    480: 01 35 74 60 62 6c 65 74 31 74 31 02 43 52 45 41   .5t`blet1t1.CREA
          768  +|    496: 54 45 20 54 41 42 4c 45 20 74 30 28 61 2c 62 29   TE TABLE t0(a,b)
          769  +| page 2 offset 512
          770  +|      0: 0d 00 ff 11 04 01 cf 80 01 fa 01 09 00 de 01 cf   ................
          771  +|     16: 00 00 00 00 00 00 00 00 00 01 00 00 00 00 00 00   ................
          772  +|     32: 00 00 08 00 00 00 00 00 00 11 00 00 00 00 00 13   ................
          773  +|     48: 00 00 00 00 00 00 00 00 00 00 00 01 00 e0 ff ff   ................
          774  +|     64: ff d2 ff ff ff 00 f8 ff ff ff 00 00 00 00 00 00   ................
          775  +|     80: 00 ff ff 00 00 00 00 00 00 00 00 00 00 00 00 00   ................
          776  +|     96: 00 00 00 00 ff de 00 00 00 00 00 00 00 00 00 00   ................
          777  +|    112: 00 00 00 00 00 00 00 00 00 00 00 00 00 40 00 00   .............@..
          778  +|    128: 2a 00 00 00 00 00 00 00 00 f7 00 00 00 00 00 00   *...............
          779  +|    144: 00 00 00 00 00 21 00 00 00 00 00 00 00 00 00 00   .....!..........
          780  +|    160: 01 64 00 00 00 00 04 80 ff ff ff 00 00 00 00 00   .d..............
          781  +|    176: 00 00 00 00 00 00 00 00 1f 00 00 00 00 00 00 00   ................
          782  +|    192: 00 00 40 00 00 00 00 00 00 00 00 00 00 00 00 00   ..@.............
          783  +|    208: b5 00 00 00 00 00 00 40 00 00 00 00 00 00 00 00   .......@........
          784  +|    224: 00 00 00 f6 00 ee ff ff ff 00 00 00 00 00 00 00   ................
          785  +|    272: f2 00 00 00 00 00 00 00 00 00 f9 ff ff ff ff ff   ................
          786  +|    288: ff ff 00 00 00 5f 00 fb 00 00 00 00 00 00 00 00   ....._..........
          787  +|    320: 1e 00 00 00 fe 00 00 00 00 00 00 00 00 00 00 00   ................
          788  +|    336: 00 00 00 00 00 00 ca 00 00 00 00 00 00 00 ff ec   ................
          789  +|    352: 00 00 00 00 00 00 00 32 00 00 00 00 ef ff 22 07   .......2........
          790  +|    368: 06 17 11 11 01 30 74 61 62 6c 65 74 38 38 74 04   .....0tablet88t.
          791  +|    384: 43 52 45 41 54 45 20 54 41 42 4c 45 20 8c cb d7   CREATE TABLE ...
          792  +|    400: 78 d6 d5 f9 f9 17 13 11 01 3f 69 4f 64 65 78 74   x........?iOdext
          793  +|    416: 33 78 74 33 05 43 52 45 41 54 45 26 49 6e 44 45   3xt3.CREATE&InDE
          794  +|    432: 58 20 74 33 78 00 00 00 00 00 00 00 00 00 00 00   X t3x...........
          795  +|    464: 00 00 00 00 00 13 76 65 6e 65 69 67 68 74 13 03   ......veneight..
          796  +|    480: 03 40 07 07 15 00 54 45 20 49 4e 44 45 58 20 74   .@....TE INDEX t
          797  +|    496: 31 63 64 20 4f 4e 20 74 ce d7 f5 f0 44 09 01 02   1cd ON t....D...
          798  +| page 3 offset 1024
          799  +|      0: 0d 00 00 00 48 01 54 00 01 f6 e2 ec 01 c5 01 aa   ....H.T.........
          800  +|     16: 30 34 28 87 29 32 06 f5 16 13 11 01 8e 61 24 64   04(.)2.......a$d
          801  +|     32: 65 78 74 37 78 1f 33 6d 6d 6d 6d 6d 00 00 04 06   ext7x.3mmmmm....
          802  +|     48: 6d 41 6d 6d 6e 6d 6d 00 00 02 00 6d 6d 6d 6d 6d   mAmmnmm....mmmmm
          803  +|     64: 15 11 01 45 45 45 45 45 45 45 45 45 45 45 45 45   ...EEEEEEEEEEEEE
          804  +|     80: 45 45 45 45 45 45 45 45 45 45 45 00 45 63 74 64   EEEEEEEEEEE.Ectd
          805  +|     96: 34 20 4f 4e 20 61 62 6c 5d 74 38 38 74 04 43 52   4 ON abl]t88t.CR
          806  +|    112: 45 41 54 45 20 54 41 42 4c 45 20 74 34 28 87 29   EATE TABLE t4(.)
          807  +|    128: 2a 06 06 13 13 01 00 00 00 4f 64 6e 78 74 33 44   *........Odnxt3D
          808  +|    144: 74 13 05 43 52 45 41 54 45 20 49 6e 44 45 00 00   t..CREATE InDE..
          809  +|    160: 00 00 00 00 00 00 00 f9 ff ff ff ff ff ff ff 00   ................
          810  +|    176: 00 00 5f 00 fb 00 00 2d 00 00 00 00 00 00 00 00   .._....-........
          811  +|    192: 00 00 00 00 00 00 00 00 00 00 00 00 00 1e 00 00   ................
          812  +|    208: 00 fe 00 00 00 00 17 15 11 01 45 69 6e 64 65 2e   ..........Einde.
          813  +|    224: 5b 38 63 64 74 3d 05 43 52 45 41 54 45 20 49 4e   [8cdt=.CREATE IN
          814  +|    240: 44 45 58 20 63 20 64 32 20 4f 4e 20 74 32 28 0a   DEX c d2 ON t2(.
          815  +|    256: 0c 44 32 05 00 10 00 00 11 11 3d 74 6c 62 61 d4   .D2.......=tlba.
          816  +|    272: 65 33 74 33 04 43 52 45 41 54 45 20 54 41 42 4c   e3t3.CREATE TABL
          817  +|    288: 45 20 74 36 ff ff 7f ff 43 52 45 41 54 45 20 49   E t6....CREATE I
          818  +|    304: 73 71 6c 69 74 65 5f 73 65 71 75 65 6e 63 65 28   sqlite_sequence(
          819  +|    320: 0a 0c 44 29 28 05 06 17 11 11 01 3d 74 6c 62 61   ..D)(......=tlba
          820  +|    336: 20 00 00 00 33 04 43 52 45 41 54 45 20 54 41 42    ...3.CREATE TAB
          821  +|    352: 4c 45 20 74 33 28 63 2c 78 2c 65 2c 66 29 28 02   LE t3(c,x,e,f)(.
          822  +|    368: 06 00 00 7f ff 40 41 54 45 20 49 6e 44 45 58 20   .....@ATE InDEX 
          823  +|    384: 74 33 78 20 4f 4e 20 74 31 28 78 29 2e 04 06 17   t3x ON t1(x)....
          824  +|    400: 15 11 01 45 69 6e 64 65 2e 74 34 63 64 74 3d 05   ...Einde.t4cdt=.
          825  +|    416: 00 00 00 00 00 00 00 00 00 00 00 4d 00 00 00 00   ...........M....
          826  +|    432: 01 00 00 00 00 00 00 05 00 00 10 00 00 00 00 00   ................
          827  +|    448: 00 01 00 00 00 00 01 00 00 00 00 07 40 14 00 00   ............@...
          828  +|    464: 00 00 21 00 40 18 00 00 00 00 00 00 40 1c 00 00   ..!.@.......@...
          829  +|    480: 00 00 ff ff ff 00 00 00 5f 00 fb 00 00 2d 00 00   ........_....-..
          830  +|    496: 00 00 00 1e 00 00 00 fe 00 00 64 00 00 ff fb 02   ..........d.....
          831  +| page 4 offset 1536
          832  +|      0: 0d 00 39 00 00 02 00 00 00 00 00 00 00 00 00 00   ..9.............
          833  +| end a.db
          834  +}]} {}
          835  +
          836  +
          837  +do_catchsql_test 8.1 {
          838  +  INSERT INTO t3 SELECT * FROM t2;
          839  +} {1 {database disk image is malformed}}
   729    840   
   730    841   finish_test

Changes to test/dbfuzz2.c.

    70     70   
    71     71   /* True to activate PRAGMA vdbe_debug=on */
    72     72   static int bVdbeDebug = 0;
    73     73   
    74     74   /* Maximum size of the in-memory database file */
    75     75   static sqlite3_int64 szMax = 104857600;
    76     76   
           77  +/* Progress handler callback data */
           78  +static int nCb = 0;                  /* Number of callbacks seen so far */
           79  +static int mxCb = 250000;            /* Maximum allowed callbacks */
           80  +
    77     81   /***** Copy/paste from ext/misc/memtrace.c ***************************/
    78     82   /* The original memory allocation routines */
    79     83   static sqlite3_mem_methods memtraceBase;
    80     84   static FILE *memtraceOut;
    81     85   
    82     86   /* Methods that trace memory allocations */
    83     87   static void *memtraceMalloc(int n){
................................................................................
   152    156         memset(&memtraceBase, 0, sizeof(memtraceBase));
   153    157       }
   154    158     }
   155    159     memtraceOut = 0;
   156    160     return rc;
   157    161   }
   158    162   /***** End copy/paste from ext/misc/memtrace.c ***************************/
          163  +
          164  +/*
          165  +** Progress handler callback
          166  +**
          167  +** Count the number of callbacks and cause an abort once the limit is
          168  +** reached.
          169  +*/
          170  +static int progress_handler(void *pNotUsed){
          171  +  nCb++;
          172  +  if( nCb<mxCb ) return 0;
          173  +  if( eVerbosity>=1 ){
          174  +    printf("-- Progress limit of %d reached\n", mxCb);
          175  +  }
          176  +  return 1;
          177  +}
   159    178   
   160    179   /* libFuzzer invokes this routine with fuzzed database files (in aData).
   161    180   ** This routine run SQLite against the malformed database to see if it
   162    181   ** can provoke a failure or malfunction.
   163    182   */
   164    183   int LLVMFuzzerTestOneInput(const uint8_t *aData, size_t nByte){
   165    184     unsigned char *a;
................................................................................
   185    204     x = szMax;
   186    205   #ifdef SQLITE_FCNTL_SIZE_LIMIT
   187    206     sqlite3_file_control(db, "main", SQLITE_FCNTL_SIZE_LIMIT, &x);
   188    207   #endif
   189    208     if( bVdbeDebug ){
   190    209       sqlite3_exec(db, "PRAGMA vdbe_debug=ON", 0, 0, 0);
   191    210     }
          211  +  if( mxCb>0 ){
          212  +    sqlite3_progress_handler(db, 10, progress_handler, 0);
          213  +  }
   192    214     for(i=0; i<sizeof(azSql)/sizeof(azSql[0]); i++){
   193    215       if( eVerbosity>=1 ){
   194    216         printf("%s\n", azSql[i]);
   195    217         fflush(stdout);
   196    218       }
   197    219       zErr = 0;
          220  +    nCb = 0;
   198    221       rc = sqlite3_exec(db, azSql[i], 0, 0, &zErr);
   199    222       if( rc && eVerbosity>=1 ){
   200    223         printf("-- rc=%d zErr=%s\n", rc, zErr);
   201    224       }
   202    225       sqlite3_free(zErr);
   203    226     }
   204    227     rc = sqlite3_close(db);
................................................................................
   244    267         if( z[0]=='v' && (n = numberOfVChar(z))>0 ){
   245    268           eVerbosity += n;
   246    269           continue;
   247    270         }
   248    271         if( strcmp(z,"vdbe-debug")==0 ){
   249    272           bVdbeDebug = 1;
   250    273           continue;
          274  +      }
          275  +      if( strcmp(z,"limit")==0 ){
          276  +        if( i+1==argc ){
          277  +          fprintf(stderr, "missing argument to %s\n", argv[i]);
          278  +          exit(1);
          279  +        }
          280  +        mxCb = strtol(argv[++i], 0, 0);
          281  +        continue;
   251    282         }
   252    283         if( strcmp(z,"memtrace")==0 ){
   253    284           sqlite3MemTraceActivate(stdout);
   254    285           continue;
   255    286         }
   256    287         if( strcmp(z,"mem")==0 ){
   257    288           bVdbeDebug = 1;

Changes to test/fuzzcheck.c.

   527    527     if( nIn<4 ) return -1;
   528    528     n = (unsigned int)nIn;
   529    529     a = sqlite3_malloc64( nAlloc );
   530    530     if( a==0 ){
   531    531       fprintf(stderr, "Out of memory!\n");
   532    532       exit(1);
   533    533     }
   534         -  memset(a, 0, nAlloc);
          534  +  memset(a, 0, (size_t)nAlloc);
   535    535     for(i=k=0; i<n; i++){
   536    536       unsigned char c = (unsigned char)zIn[i];
   537    537       if( isxdigit(c) ){
   538    538         k++;
   539    539         if( k & 1 ){
   540    540           b = hexToInt(c)*16;
   541    541         }else{
................................................................................
   564    564             }
   565    565             a = sqlite3_realloc64( a, newSize );
   566    566             if( a==0 ){
   567    567               fprintf(stderr, "Out of memory!\n");
   568    568               exit(1);
   569    569             }
   570    570             assert( newSize > nAlloc );
   571         -          memset(a+nAlloc, 0, newSize - nAlloc);
          571  +          memset(a+nAlloc, 0, (size_t)(newSize - nAlloc));
   572    572             nAlloc = newSize;
   573    573           }
   574    574           if( j>=(unsigned)mx ){
   575    575             mx = (j + 4095)&~4095;
   576    576             if( mx>MX_FILE_SZ ) mx = MX_FILE_SZ;
   577    577           }
   578    578           assert( j<nAlloc );

Changes to test/fuzzdata7.db.

cannot compute difference between binary files