Index: src/alter.c
==================================================================
--- src/alter.c
+++ src/alter.c
@@ -10,11 +10,11 @@
 **
 *************************************************************************
 ** This file contains C code routines that used to generate VDBE code
 ** that implements the ALTER TABLE command.
 **
-** $Id: alter.c,v 1.10 2005/12/06 12:52:59 danielk1977 Exp $
+** $Id: alter.c,v 1.11 2005/12/09 20:02:05 drh Exp $
 */
 #include "sqliteInt.h"
 #include <ctype.h>
 
 /*
@@ -45,11 +45,11 @@
   unsigned char const *zSql = sqlite3_value_text(argv[0]);
   unsigned char const *zTableName = sqlite3_value_text(argv[1]);
 
   int token;
   Token tname;
-  char const *zCsr = zSql;
+  unsigned char const *zCsr = zSql;
   int len = 0;
   char *zRet;
 
   /* The principle used to locate the table name in the CREATE TABLE 
   ** statement is that the table name is the first token that is immediatedly
@@ -94,11 +94,11 @@
   unsigned char const *zTableName = sqlite3_value_text(argv[1]);
 
   int token;
   Token tname;
   int dist = 3;
-  char const *zCsr = zSql;
+  unsigned char const *zCsr = zSql;
   int len = 0;
   char *zRet;
 
   /* The principle used to locate the table name in the CREATE TRIGGER 
   ** statement is that the table name is the first token that is immediatedly
@@ -440,11 +440,11 @@
     }
     sqlite3ValueFree(pVal);
   }
 
   /* Modify the CREATE TABLE statement. */
-  zCol = sqliteStrNDup(pColDef->z, pColDef->n);
+  zCol = sqliteStrNDup((char*)pColDef->z, pColDef->n);
   if( zCol ){
     char *zEnd = &zCol[pColDef->n-1];
     while( (zEnd>zCol && *zEnd==';') || isspace(*(unsigned char *)zEnd) ){
       *zEnd-- = '\0';
     }

Index: src/btree.c
==================================================================
--- src/btree.c
+++ src/btree.c
@@ -7,11 +7,11 @@
 **    May you do good and not evil.
 **    May you find forgiveness for yourself and forgive others.
 **    May you share freely, never taking more than you give.
 **
 *************************************************************************
-** $Id: btree.c,v 1.272 2005/11/24 14:34:36 drh Exp $
+** $Id: btree.c,v 1.273 2005/12/09 20:02:05 drh Exp $
 **
 ** This file implements a external (disk-based) database using BTrees.
 ** For a detailed discussion of BTrees, refer to
 **
 **     Donald E. Knuth, THE ART OF COMPUTER PROGRAMMING, Volume 3:
@@ -1533,11 +1533,11 @@
 */
 static void unlockBtreeIfUnused(Btree *pBt){
   if( pBt->inTrans==TRANS_NONE && pBt->pCursor==0 && pBt->pPage1!=0 ){
     if( pBt->pPage1->aData==0 ){
       MemPage *pPage = pBt->pPage1;
-      pPage->aData = &((char*)pPage)[-pBt->pageSize];
+      pPage->aData = &((u8*)pPage)[-pBt->pageSize];
       pPage->pBt = pBt;
       pPage->pgno = 1;
     }
     releasePage(pBt->pPage1);
     pBt->pPage1 = 0;

Index: src/build.c
==================================================================
--- src/build.c
+++ src/build.c
@@ -20,11 +20,11 @@
 **     creating ID lists
 **     BEGIN TRANSACTION
 **     COMMIT
 **     ROLLBACK
 **
-** $Id: build.c,v 1.356 2005/12/06 12:52:59 danielk1977 Exp $
+** $Id: build.c,v 1.357 2005/12/09 20:02:05 drh Exp $
 */
 #include "sqliteInt.h"
 #include <ctype.h>
 
 /*
@@ -507,11 +507,11 @@
 ** is \000 terminated and is persistent.
 */
 char *sqlite3NameFromToken(Token *pName){
   char *zName;
   if( pName ){
-    zName = sqliteStrNDup(pName->z, pName->n);
+    zName = sqliteStrNDup((char*)pName->z, pName->n);
     sqlite3Dequote(zName);
   }else{
     zName = 0;
   }
   return zName;
@@ -2222,12 +2222,12 @@
   /* If pList==0, it means this routine was called to make a primary
   ** key out of the last column added to the table under construction.
   ** So create a fake list to simulate this.
   */
   if( pList==0 ){
-    nullId.z = pTab->aCol[pTab->nCol-1].zName;
-    nullId.n = strlen(nullId.z);
+    nullId.z = (u8*)pTab->aCol[pTab->nCol-1].zName;
+    nullId.n = strlen((char*)nullId.z);
     pList = sqlite3ExprListAppend(0, 0, &nullId);
     if( pList==0 ) goto exit_create_index;
   }
 
   /* 
@@ -2978,11 +2978,11 @@
 
   if( pName1==0 || pName1->z==0 ){
     reindexDatabases(pParse, 0);
     return;
   }else if( pName2==0 || pName2->z==0 ){
-    pColl = sqlite3FindCollSeq(db, db->enc, pName1->z, pName1->n, 0);
+    pColl = sqlite3FindCollSeq(db, db->enc, (char*)pName1->z, pName1->n, 0);
     if( pColl ){
       reindexDatabases(pParse, pColl);
       return;
     }
   }

Index: src/date.c
==================================================================
--- src/date.c
+++ src/date.c
@@ -14,11 +14,11 @@
 **
 ** There is only one exported symbol in this file - the function
 ** sqlite3RegisterDateTimeFunctions() found at the bottom of the file.
 ** All other code has file scope.
 **
-** $Id: date.c,v 1.46 2005/11/30 03:20:31 drh Exp $
+** $Id: date.c,v 1.47 2005/12/09 20:02:05 drh Exp $
 **
 ** NOTES:
 **
 ** SQLite processes all times and dates as Julian Day numbers.  The
 ** dates and times are stored as the number of days since noon
@@ -637,14 +637,14 @@
 */
 static int isDate(int argc, sqlite3_value **argv, DateTime *p){
   int i;
   if( argc==0 ) return 1;
   if( SQLITE_NULL==sqlite3_value_type(argv[0]) || 
-      parseDateOrTime(sqlite3_value_text(argv[0]), p) ) return 1;
+      parseDateOrTime((char*)sqlite3_value_text(argv[0]), p) ) return 1;
   for(i=1; i<argc; i++){
     if( SQLITE_NULL==sqlite3_value_type(argv[i]) || 
-        parseModifier(sqlite3_value_text(argv[i]), p) ) return 1;
+        parseModifier((char*)sqlite3_value_text(argv[i]), p) ) return 1;
   }
   return 0;
 }
 
 
@@ -753,11 +753,11 @@
   sqlite3_value **argv
 ){
   DateTime x;
   int n, i, j;
   char *z;
-  const char *zFmt = sqlite3_value_text(argv[0]);
+  const char *zFmt = (const char*)sqlite3_value_text(argv[0]);
   char zBuf[100];
   if( zFmt==0 || isDate(argc-1, argv+1, &x) ) return;
   for(i=0, n=1; zFmt[i]; i++, n++){
     if( zFmt[i]=='%' ){
       switch( zFmt[i+1] ){

Index: src/expr.c
==================================================================
--- src/expr.c
+++ src/expr.c
@@ -10,11 +10,11 @@
 **
 *************************************************************************
 ** This file contains routines used for analyzing expressions and
 ** for generating VDBE code that evaluates expressions in SQLite.
 **
-** $Id: expr.c,v 1.241 2005/12/06 12:52:59 danielk1977 Exp $
+** $Id: expr.c,v 1.242 2005/12/09 20:02:05 drh Exp $
 */
 #include "sqliteInt.h"
 #include <ctype.h>
 
 /*
@@ -233,11 +233,11 @@
   if( v==0 ) return 0;
   p = sqlite3Expr(TK_REGISTER, 0, 0, pToken);
   if( p==0 ){
     return 0;  /* Malloc failed */
   }
-  depth = atoi(&pToken->z[1]);
+  depth = atoi((char*)&pToken->z[1]);
   p->iTable = pParse->nMem++;
   sqlite3VdbeAddOp(v, OP_Dup, depth, 0);
   sqlite3VdbeAddOp(v, OP_MemStore, p->iTable, 1);
   return p;
 }
@@ -325,11 +325,11 @@
     pExpr->iTable = ++pParse->nVar;
   }else if( pToken->z[0]=='?' ){
     /* Wildcard of the form "?nnn".  Convert "nnn" to an integer and
     ** use it as the variable number */
     int i;
-    pExpr->iTable = i = atoi(&pToken->z[1]);
+    pExpr->iTable = i = atoi((char*)&pToken->z[1]);
     if( i<1 || i>SQLITE_MAX_VARIABLE_NUMBER ){
       sqlite3ErrorMsg(pParse, "variable number must be between ?1 and ?%d",
           SQLITE_MAX_VARIABLE_NUMBER);
     }
     if( i>pParse->nVar ){
@@ -413,11 +413,11 @@
   if( p==0 ) return 0;
   pNew = sqliteMallocRaw( sizeof(*p) );
   if( pNew==0 ) return 0;
   memcpy(pNew, p, sizeof(*pNew));
   if( p->token.z!=0 ){
-    pNew->token.z = sqliteStrNDup(p->token.z, p->token.n);
+    pNew->token.z = (u8*)sqliteStrNDup((char*)p->token.z, p->token.n);
     pNew->token.dyn = 1;
   }else{
     assert( pNew->token.z==0 );
   }
   pNew->span.z = 0;
@@ -430,11 +430,11 @@
 }
 void sqlite3TokenCopy(Token *pTo, Token *pFrom){
   if( pTo->dyn ) sqliteFree((char*)pTo->z);
   if( pFrom->z ){
     pTo->n = pFrom->n;
-    pTo->z = sqliteStrNDup(pFrom->z, pFrom->n);
+    pTo->z = (u8*)sqliteStrNDup((char*)pFrom->z, pFrom->n);
     pTo->dyn = 1;
   }else{
     pTo->z = 0;
   }
 }
@@ -750,11 +750,11 @@
 ** to fit in a signed 32-bit integer, return 0 and leave *pValue unchanged.
 */
 int sqlite3ExprIsInteger(Expr *p, int *pValue){
   switch( p->op ){
     case TK_INTEGER: {
-      if( sqlite3GetInt32(p->token.z, pValue) ){
+      if( sqlite3GetInt32((char*)p->token.z, pValue) ){
         return 1;
       }
       break;
     }
     case TK_UPLUS: {
@@ -1148,11 +1148,11 @@
       int nId;                    /* Number of characters in function name */
       const char *zId;            /* The function name. */
       FuncDef *pDef;              /* Information about the function */
       int enc = pParse->db->enc;  /* The database encoding */
 
-      zId = pExpr->token.z;
+      zId = (char*)pExpr->token.z;
       nId = pExpr->token.n;
       pDef = sqlite3FindFunction(pParse->db, zId, nId, n, enc, 0);
       if( pDef==0 ){
         pDef = sqlite3FindFunction(pParse->db, zId, nId, -1, enc, 0);
         if( pDef==0 ){
@@ -1400,11 +1400,11 @@
     case TK_SELECT: {
       /* This has to be a scalar SELECT.  Generate code to put the
       ** value of this select in a memory cell and record the number
       ** of the memory cell in iColumn.
       */
-      static const Token one = { "1", 0, 1 };
+      static const Token one = { (u8*)"1", 0, 1 };
       Select *pSel;
       int iMem;
       int sop;
 
       pExpr->iColumn = iMem = pParse->nMem++;
@@ -1501,19 +1501,19 @@
         sqlite3VdbeAddOp(v, OP_Rowid, pExpr->iTable, 0);
       }
       break;
     }
     case TK_INTEGER: {
-      codeInteger(v, pExpr->token.z, pExpr->token.n);
+      codeInteger(v, (char*)pExpr->token.z, pExpr->token.n);
       break;
     }
     case TK_FLOAT:
     case TK_STRING: {
       assert( TK_FLOAT==OP_Real );
       assert( TK_STRING==OP_String8 );
       sqlite3DequoteExpr(pExpr);
-      sqlite3VdbeOp3(v, op, 0, 0, pExpr->token.z, pExpr->token.n);
+      sqlite3VdbeOp3(v, op, 0, 0, (char*)pExpr->token.z, pExpr->token.n);
       break;
     }
     case TK_NULL: {
       sqlite3VdbeAddOp(v, OP_Null, 0, 0);
       break;
@@ -1522,11 +1522,11 @@
     case TK_BLOB: {
       int n;
       const char *z;
       assert( TK_BLOB==OP_HexBlob );
       n = pExpr->token.n - 3;
-      z = pExpr->token.z + 2;
+      z = (char*)pExpr->token.z + 2;
       assert( n>=0 );
       if( n==0 ){
         z = "";
       }
       sqlite3VdbeOp3(v, op, 0, 0, z, n);
@@ -1534,11 +1534,11 @@
     }
 #endif
     case TK_VARIABLE: {
       sqlite3VdbeAddOp(v, OP_Variable, pExpr->iTable, 0);
       if( pExpr->token.n>1 ){
-        sqlite3VdbeChangeP3(v, -1, pExpr->token.z, pExpr->token.n);
+        sqlite3VdbeChangeP3(v, -1, (char*)pExpr->token.z, pExpr->token.n);
       }
       break;
     }
     case TK_REGISTER: {
       sqlite3VdbeAddOp(v, OP_MemLoad, pExpr->iTable, 0);
@@ -1665,11 +1665,11 @@
       const char *zId;
       int constMask = 0;
       int i;
       u8 enc = pParse->db->enc;
       CollSeq *pColl = 0;
-      zId = pExpr->token.z;
+      zId = (char*)pExpr->token.z;
       nId = pExpr->token.n;
       pDef = sqlite3FindFunction(pParse->db, zId, nId, nExpr, enc, 0);
       assert( pDef!=0 );
       nExpr = sqlite3ExprCodeExprList(pParse, pList);
       for(i=0; i<nExpr && i<32; i++){
@@ -1801,11 +1801,11 @@
          assert( pExpr->iColumn==OE_Rollback ||
                  pExpr->iColumn == OE_Abort ||
                  pExpr->iColumn == OE_Fail );
          sqlite3DequoteExpr(pExpr);
          sqlite3VdbeOp3(v, OP_Halt, SQLITE_CONSTRAINT, pExpr->iColumn,
-                        pExpr->token.z, pExpr->token.n);
+                        (char*)pExpr->token.z, pExpr->token.n);
       } else {
          assert( pExpr->iColumn == OE_Ignore );
          sqlite3VdbeAddOp(v, OP_ContextPop, 0, 0);
          sqlite3VdbeAddOp(v, OP_Goto, 0, pParse->trigStack->ignoreJump);
          VdbeComment((v, "# raise(IGNORE)"));
@@ -2104,11 +2104,13 @@
   if( pA->pSelect || pB->pSelect ) return 0;
   if( pA->iTable!=pB->iTable || pA->iColumn!=pB->iColumn ) return 0;
   if( pA->token.z ){
     if( pB->token.z==0 ) return 0;
     if( pB->token.n!=pA->token.n ) return 0;
-    if( sqlite3StrNICmp(pA->token.z, pB->token.z, pB->token.n)!=0 ) return 0;
+    if( sqlite3StrNICmp((char*)pA->token.z,(char*)pB->token.z,pB->token.n)!=0 ){
+      return 0;
+    }
   }
   return 1;
 }
 
 
@@ -2235,11 +2237,11 @@
           if( i>=0 ){
             pItem = &pAggInfo->aFunc[i];
             pItem->pExpr = pExpr;
             pItem->iMem = pParse->nMem++;
             pItem->pFunc = sqlite3FindFunction(pParse->db,
-                   pExpr->token.z, pExpr->token.n,
+                   (char*)pExpr->token.z, pExpr->token.n,
                    pExpr->pList ? pExpr->pList->nExpr : 0, enc, 0);
             if( pExpr->flags & EP_Distinct ){
               pItem->iDistinct = pParse->nTab++;
             }else{
               pItem->iDistinct = -1;

Index: src/func.c
==================================================================
--- src/func.c
+++ src/func.c
@@ -14,11 +14,11 @@
 **
 ** There is only one exported symbol in this file - the function
 ** sqliteRegisterBuildinFunctions() found at the bottom of the file.
 ** All other code has file scope.
 **
-** $Id: func.c,v 1.112 2005/12/06 17:19:11 danielk1977 Exp $
+** $Id: func.c,v 1.113 2005/12/09 20:02:05 drh Exp $
 */
 #include "sqliteInt.h"
 #include <ctype.h>
 /* #include <math.h> */
 #include <stdlib.h>
@@ -99,11 +99,11 @@
     case SQLITE_FLOAT: {
       sqlite3_result_int(context, sqlite3_value_bytes(argv[0]));
       break;
     }
     case SQLITE_TEXT: {
-      const char *z = sqlite3_value_text(argv[0]);
+      const unsigned char *z = sqlite3_value_text(argv[0]);
       for(len=0; *z; z++){ if( (0xc0&*z)!=0x80 ) len++; }
       sqlite3_result_int(context, len);
       break;
     }
     default: {
@@ -144,12 +144,12 @@
 static void substrFunc(
   sqlite3_context *context,
   int argc,
   sqlite3_value **argv
 ){
-  const char *z;
-  const char *z2;
+  const unsigned char *z;
+  const unsigned char *z2;
   int i;
   int p1, p2, len;
 
   assert( argc==3 );
   z = sqlite3_value_text(argv[0]);
@@ -176,11 +176,11 @@
   for(; i<p1+p2 && z[i]; i++){
     if( (z[i]&0xc0)==0x80 ) p2++;
   }
   while( z[i] && (z[i]&0xc0)==0x80 ){ i++; p2++; }
   if( p2<0 ) p2 = 0;
-  sqlite3_result_text(context, &z[p1], p2, SQLITE_TRANSIENT);
+  sqlite3_result_text(context, (char*)&z[p1], p2, SQLITE_TRANSIENT);
 }
 
 /*
 ** Implementation of the round() function
 */
@@ -208,28 +208,28 @@
   unsigned char *z;
   int i;
   if( argc<1 || SQLITE_NULL==sqlite3_value_type(argv[0]) ) return;
   z = sqliteMalloc(sqlite3_value_bytes(argv[0])+1);
   if( z==0 ) return;
-  strcpy(z, sqlite3_value_text(argv[0]));
+  strcpy((char*)z, (char*)sqlite3_value_text(argv[0]));
   for(i=0; z[i]; i++){
     z[i] = toupper(z[i]);
   }
-  sqlite3_result_text(context, z, -1, SQLITE_TRANSIENT);
+  sqlite3_result_text(context, (char*)z, -1, SQLITE_TRANSIENT);
   sqliteFree(z);
 }
 static void lowerFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
   unsigned char *z;
   int i;
   if( argc<1 || SQLITE_NULL==sqlite3_value_type(argv[0]) ) return;
   z = sqliteMalloc(sqlite3_value_bytes(argv[0])+1);
   if( z==0 ) return;
-  strcpy(z, sqlite3_value_text(argv[0]));
+  strcpy((char*)z, (char*)sqlite3_value_text(argv[0]));
   for(i=0; z[i]; i++){
     z[i] = tolower(z[i]);
   }
-  sqlite3_result_text(context, z, -1, SQLITE_TRANSIENT);
+  sqlite3_result_text(context, (char*)z, -1, SQLITE_TRANSIENT);
   sqliteFree(z);
 }
 
 /*
 ** Implementation of the IFNULL(), NVL(), and COALESCE() functions.  
@@ -493,11 +493,11 @@
   if( argc==3 ){
     /* The escape character string must consist of a single UTF-8 character.
     ** Otherwise, return an error.
     */
     const unsigned char *zEsc = sqlite3_value_text(argv[2]);
-    if( sqlite3utf8CharLen(zEsc, -1)!=1 ){
+    if( sqlite3utf8CharLen((char*)zEsc, -1)!=1 ){
       sqlite3_result_error(context, 
           "ESCAPE expression must be a single character", -1);
       return;
     }
     escape = sqlite3ReadUtf8(zEsc);
@@ -590,11 +590,11 @@
       }
       break;
     }
     case SQLITE_TEXT: {
       int i,j,n;
-      const char *zArg = sqlite3_value_text(argv[0]);
+      const unsigned char *zArg = sqlite3_value_text(argv[0]);
       char *z;
 
       for(i=n=0; zArg[i]; i++){ if( zArg[i]=='\'' ) n++; }
       z = sqliteMalloc( i+n+3 );
       if( z==0 ) return;
@@ -690,11 +690,11 @@
   sqlite3Randomness(n, zBuf);
   for(i=0; i<n; i++){
     zBuf[i] = zSrc[zBuf[i]%(sizeof(zSrc)-1)];
   }
   zBuf[n] = 0;
-  sqlite3_result_text(context, zBuf, n, SQLITE_TRANSIENT);
+  sqlite3_result_text(context, (char*)zBuf, n, SQLITE_TRANSIENT);
 }
 #endif /* SQLITE_TEST */
 
 #ifdef SQLITE_TEST
 /*
@@ -774,11 +774,11 @@
 ){
   int i;
   char *zRet = sqliteMalloc(nArg*2);
   if( !zRet ) return;
   for(i=0; i<nArg; i++){
-    char const *z = sqlite3_value_text(argv[i]);
+    char const *z = (char*)sqlite3_value_text(argv[i]);
     if( z ){
       char *zAux = sqlite3_get_auxdata(pCtx, i);
       if( zAux ){
         zRet[i*2] = '1';
         if( strcmp(zAux, z) ){
@@ -805,11 +805,11 @@
 static void test_error(
   sqlite3_context *pCtx, 
   int nArg,
   sqlite3_value **argv
 ){
-  sqlite3_result_error(pCtx, sqlite3_value_text(argv[0]), 0);
+  sqlite3_result_error(pCtx, (char*)sqlite3_value_text(argv[0]), 0);
 }
 #endif /* SQLITE_TEST */
 
 /*
 ** An instance of the following structure holds the context of a
@@ -1098,11 +1098,11 @@
     return 0;
   }
   if( pExpr->pList->nExpr!=2 ){
     return 0;
   }
-  pDef = sqlite3FindFunction(db, pExpr->token.z, pExpr->token.n, 2,
+  pDef = sqlite3FindFunction(db, (char*)pExpr->token.z, pExpr->token.n, 2,
                              SQLITE_UTF8, 0);
   if( pDef==0 || (pDef->flags & SQLITE_FUNC_LIKE)==0 ){
     return 0;
   }
 

Index: src/main.c
==================================================================
--- src/main.c
+++ src/main.c
@@ -12,11 +12,11 @@
 ** Main file for the SQLite library.  The routines in this file
 ** implement the programmer interface to the library.  Routines in
 ** other files are for internal use by SQLite and should not be
 ** accessed by users of the library.
 **
-** $Id: main.c,v 1.306 2005/12/06 13:19:08 drh Exp $
+** $Id: main.c,v 1.307 2005/12/09 20:02:05 drh Exp $
 */
 #include "sqliteInt.h"
 #include "os.h"
 #include <ctype.h>
 
@@ -639,11 +639,11 @@
     return sqlite3ErrStr(SQLITE_NOMEM);
   }
   if( sqlite3SafetyCheck(db) || db->errCode==SQLITE_MISUSE ){
     return sqlite3ErrStr(SQLITE_MISUSE);
   }
-  z = sqlite3_value_text(db->pErr);
+  z = (char*)sqlite3_value_text(db->pErr);
   if( z==0 ){
     z = sqlite3ErrStr(db->errCode);
   }
   return z;
 }

Index: src/os_unix.c
==================================================================
--- src/os_unix.c
+++ src/os_unix.c
@@ -631,11 +631,10 @@
 ** On failure, return SQLITE_CANTOPEN.
 */
 static int unixOpenExclusive(const char *zFilename, OsFile **pId, int delFlag){
   int rc;
   unixFile f;
-  int fd;
 
   assert( 0==*pId );
   if( access(zFilename, 0)==0 ){
     return SQLITE_CANTOPEN;
   }

Index: src/pager.c
==================================================================
--- src/pager.c
+++ src/pager.c
@@ -16,11 +16,11 @@
 ** is separate from the database file.  The pager also implements file
 ** locking to prevent two processes from writing the same database
 ** file simultaneously, or one process from reading the database while
 ** another is writing.
 **
-** @(#) $Id: pager.c,v 1.223 2005/12/06 12:52:59 danielk1977 Exp $
+** @(#) $Id: pager.c,v 1.224 2005/12/09 20:02:05 drh Exp $
 */
 #ifndef SQLITE_OMIT_DISKIO
 #include "sqliteInt.h"
 #include "os.h"
 #include "pager.h"
@@ -948,11 +948,11 @@
 ** FIX ME:  Consider adding every 200th (or so) byte of the data to the
 ** checksum.  That way if a single page spans 3 or more disk sectors and
 ** only the middle sector is corrupt, we will still have a reasonable
 ** chance of failing the checksum and thus detecting the problem.
 */
-static u32 pager_cksum(Pager *pPager, Pgno pgno, const char *aData){
+static u32 pager_cksum(Pager *pPager, Pgno pgno, const u8 *aData){
   u32 cksum = pPager->cksumInit;
   int i = pPager->pageSize-200;
   while( i>0 ){
     cksum += aData[i];
     i -= 200;

Index: src/parse.y
==================================================================
--- src/parse.y
+++ src/parse.y
@@ -12,11 +12,11 @@
 ** This file contains SQLite's grammar for SQL.  Process this file
 ** using the lemon parser generator to generate C code that runs
 ** the parser.  Lemon will also generate a header file containing
 ** numeric codes for all of the tokens.
 **
-** @(#) $Id: parse.y,v 1.186 2005/12/06 17:19:11 danielk1977 Exp $
+** @(#) $Id: parse.y,v 1.187 2005/12/09 20:02:05 drh Exp $
 */
 
 // All token codes are small integers with #defines that begin with "TK_"
 %token_prefix TK_
 
@@ -228,12 +228,12 @@
 }
 %type typename {Token}
 typename(A) ::= ids(X).             {A = X;}
 typename(A) ::= typename(X) ids(Y). {A.z=X.z; A.n=Y.n+(Y.z-X.z);}
 %type signed {int}
-signed(A) ::= plus_num(X).    { A = atoi(X.z); }
-signed(A) ::= minus_num(X).   { A = -atoi(X.z); }
+signed(A) ::= plus_num(X).    { A = atoi((char*)X.z); }
+signed(A) ::= minus_num(X).   { A = -atoi((char*)X.z); }
 
 // "carglist" is a list of additional constraints that come after the
 // column name and column type in a CREATE TABLE statement.
 //
 carglist ::= carglist carg.
@@ -262,11 +262,11 @@
 ccons ::= UNIQUE onconf(R).          {sqlite3CreateIndex(pParse,0,0,0,0,R,0,0);}
 ccons ::= CHECK LP expr(X) RP.       {sqlite3AddCheckConstraint(pParse,X);}
 ccons ::= REFERENCES nm(T) idxlist_opt(TA) refargs(R).
                                 {sqlite3CreateForeignKey(pParse,0,&T,TA,R);}
 ccons ::= defer_subclause(D).   {sqlite3DeferForeignKey(pParse,D);}
-ccons ::= COLLATE id(C).  {sqlite3AddCollateType(pParse, C.z, C.n);}
+ccons ::= COLLATE id(C).  {sqlite3AddCollateType(pParse, (char*)C.z, C.n);}
 
 // The optional AUTOINCREMENT keyword
 %type autoinc {int}
 autoinc(X) ::= .          {X = 0;}
 autoinc(X) ::= AUTOINCR.  {X = 1;}
@@ -851,19 +851,19 @@
 idxlist_opt(A) ::= LP idxlist(X) RP.         {A = X;}
 idxlist(A) ::= idxlist(X) COMMA idxitem(Y) collate(C) sortorder.  {
   Expr *p = 0;
   if( C.n>0 ){
     p = sqlite3Expr(TK_COLUMN, 0, 0, 0);
-    if( p ) p->pColl = sqlite3LocateCollSeq(pParse, C.z, C.n);
+    if( p ) p->pColl = sqlite3LocateCollSeq(pParse, (char*)C.z, C.n);
   }
   A = sqlite3ExprListAppend(X, p, &Y);
 }
 idxlist(A) ::= idxitem(Y) collate(C) sortorder. {
   Expr *p = 0;
   if( C.n>0 ){
     p = sqlite3Expr(TK_COLUMN, 0, 0, 0);
-    if( p ) p->pColl = sqlite3LocateCollSeq(pParse, C.z, C.n);
+    if( p ) p->pColl = sqlite3LocateCollSeq(pParse, (char*)C.z, C.n);
   }
   A = sqlite3ExprListAppend(0, p, &Y);
 }
 idxitem(A) ::= nm(X).              {A = X;}
 

Index: src/pragma.c
==================================================================
--- src/pragma.c
+++ src/pragma.c
@@ -9,11 +9,11 @@
 **    May you share freely, never taking more than you give.
 **
 *************************************************************************
 ** This file contains code used to implement the PRAGMA command.
 **
-** $Id: pragma.c,v 1.106 2005/12/08 18:12:56 drh Exp $
+** $Id: pragma.c,v 1.107 2005/12/09 20:02:05 drh Exp $
 */
 #include "sqliteInt.h"
 #include "os.h"
 #include <ctype.h>
 
@@ -34,11 +34,11 @@
 ** Note that the values returned are one less that the values that
 ** should be passed into sqlite3BtreeSetSafetyLevel().  The is done
 ** to support legacy SQL code.  The safety level used to be boolean
 ** and older scripts may have used numbers 0 for OFF and 1 for ON.
 */
-static int getSafetyLevel(const u8 *z){
+static int getSafetyLevel(const char *z){
                              /* 123456789 123456789 */
   static const char zText[] = "onoffalseyestruefull";
   static const u8 iOffset[] = {0, 1, 2, 4, 9, 12, 16};
   static const u8 iLength[] = {2, 2, 3, 5, 3, 4, 4};
   static const u8 iValue[] =  {1, 0, 0, 0, 1, 1, 2};
@@ -56,11 +56,11 @@
 }
 
 /*
 ** Interpret the given string as a boolean value.
 */
-static int getBoolean(const u8 *z){
+static int getBoolean(const char *z){
   return getSafetyLevel(z)&1;
 }
 
 #ifndef SQLITE_OMIT_PAGER_PRAGMAS
 /*

Index: src/prepare.c
==================================================================
--- src/prepare.c
+++ src/prepare.c
@@ -11,11 +11,11 @@
 *************************************************************************
 ** This file contains the implementation of the sqlite3_prepare()
 ** interface, and routines that contribute to loading the database schema
 ** from disk.
 **
-** $Id: prepare.c,v 1.6 2005/12/09 14:25:08 danielk1977 Exp $
+** $Id: prepare.c,v 1.7 2005/12/09 20:02:05 drh Exp $
 */
 #include "sqliteInt.h"
 #include "os.h"
 #include <ctype.h>
 
@@ -476,11 +476,10 @@
       sqlite3VdbeSetColName(sParse.pVdbe, 4, "p3", P3_STATIC);
     }
   } 
 #endif
 
-prepare_out:
   if( sqlite3SafetyOff(db) ){
     rc = SQLITE_MISUSE;
   }
   if( rc==SQLITE_OK ){
     *ppStmt = (sqlite3_stmt*)sParse.pVdbe;

Index: src/printf.c
==================================================================
--- src/printf.c
+++ src/printf.c
@@ -625,11 +625,11 @@
         break;
       }
       case etTOKEN: {
         Token *pToken = va_arg(ap, Token*);
         if( pToken && pToken->z ){
-          (*func)(arg, pToken->z, pToken->n);
+          (*func)(arg, (char*)pToken->z, pToken->n);
         }
         length = width = 0;
         break;
       }
       case etSRCLIST: {

Index: src/select.c
==================================================================
--- src/select.c
+++ src/select.c
@@ -10,11 +10,11 @@
 **
 *************************************************************************
 ** This file contains C code routines that are called by the parser
 ** to handle SELECT statements in SQLite.
 **
-** $Id: select.c,v 1.281 2005/12/06 12:52:59 danielk1977 Exp $
+** $Id: select.c,v 1.282 2005/12/09 20:02:05 drh Exp $
 */
 #include "sqliteInt.h"
 
 
 /*
@@ -107,11 +107,11 @@
   apAll[2] = pC;
   for(i=0; i<3 && apAll[i]; i++){
     p = apAll[i];
     for(j=0; j<sizeof(keywords)/sizeof(keywords[0]); j++){
       if( p->n==keywords[j].nChar 
-          && sqlite3StrNICmp(p->z, keywords[j].zKeyword, p->n)==0 ){
+          && sqlite3StrNICmp((char*)p->z, keywords[j].zKeyword, p->n)==0 ){
         jointype |= keywords[j].code;
         break;
       }
     }
     if( j>=sizeof(keywords)/sizeof(keywords[0]) ){
@@ -152,11 +152,11 @@
 
 /*
 ** Set the value of a token to a '\000'-terminated string.
 */
 static void setToken(Token *p, const char *z){
-  p->z = z;
+  p->z = (u8*)z;
   p->n = z ? strlen(z) : 0;
   p->dyn = 0;
 }
 
 /*
@@ -630,11 +630,11 @@
   int i;
 
   nExpr = pList->nExpr;
   pInfo = sqliteMalloc( sizeof(*pInfo) + nExpr*(sizeof(CollSeq*)+1) );
   if( pInfo ){
-    pInfo->aSortOrder = (char*)&pInfo->aColl[nExpr];
+    pInfo->aSortOrder = (u8*)&pInfo->aColl[nExpr];
     pInfo->nField = nExpr;
     pInfo->enc = db->enc;
     for(i=0, pItem=pList->a; i<nExpr; i++, pItem++){
       CollSeq *pColl;
       pColl = sqlite3ExprCollSeq(pParse, pItem->pExpr);
@@ -883,11 +883,11 @@
         zCol = "rowid";
       }else{
         zCol = pTab->aCol[iCol].zName;
       }
       if( !shortNames && !fullNames && p->span.z && p->span.z[0] ){
-        sqlite3VdbeSetColName(v, i, p->span.z, p->span.n);
+        sqlite3VdbeSetColName(v, i, (char*)p->span.z, p->span.n);
       }else if( fullNames || (!shortNames && pTabList->nSrc>1) ){
         char *zName = 0;
         char *zTab;
  
         zTab = pTabList->a[j].zAlias;
@@ -896,11 +896,11 @@
         sqlite3VdbeSetColName(v, i, zName, P3_DYNAMIC);
       }else{
         sqlite3VdbeSetColName(v, i, zCol, strlen(zCol));
       }
     }else if( p->span.z && p->span.z[0] ){
-      sqlite3VdbeSetColName(v, i, p->span.z, p->span.n);
+      sqlite3VdbeSetColName(v, i, (char*)p->span.z, p->span.n);
       /* sqlite3VdbeCompressSpace(v, addr); */
     }else{
       char zName[30];
       assert( p->op!=TK_COLUMN || pTabList==0 );
       sprintf(zName, "column%d", i+1);
@@ -2115,11 +2115,11 @@
   substExprList(p->pEList, iParent, pSub->pEList);
   pList = p->pEList;
   for(i=0; i<pList->nExpr; i++){
     Expr *pExpr;
     if( pList->a[i].zName==0 && (pExpr = pList->a[i].pExpr)->span.z!=0 ){
-      pList->a[i].zName = sqliteStrNDup(pExpr->span.z, pExpr->span.n);
+      pList->a[i].zName = sqliteStrNDup((char*)pExpr->span.z, pExpr->span.n);
     }
   }
   if( isAgg ){
     substExprList(p->pGroupBy, iParent, pSub->pEList);
     substExpr(p->pHaving, iParent, pSub->pEList);
@@ -2214,13 +2214,13 @@
   pExpr = pEList->a[0].pExpr;
   if( pExpr->op!=TK_AGG_FUNCTION ) return 0;
   pList = pExpr->pList;
   if( pList==0 || pList->nExpr!=1 ) return 0;
   if( pExpr->token.n!=3 ) return 0;
-  if( sqlite3StrNICmp(pExpr->token.z,"min",3)==0 ){
+  if( sqlite3StrNICmp((char*)pExpr->token.z,"min",3)==0 ){
     seekOp = OP_Rewind;
-  }else if( sqlite3StrNICmp(pExpr->token.z,"max",3)==0 ){
+  }else if( sqlite3StrNICmp((char*)pExpr->token.z,"max",3)==0 ){
     seekOp = OP_Last;
   }else{
     return 0;
   }
   pExpr = pList->a[0].pExpr;

Index: src/sqliteInt.h
==================================================================
--- src/sqliteInt.h
+++ src/sqliteInt.h
@@ -9,11 +9,11 @@
 **    May you share freely, never taking more than you give.
 **
 *************************************************************************
 ** Internal interface definitions for SQLite.
 **
-** @(#) $Id: sqliteInt.h,v 1.432 2005/12/09 14:39:04 danielk1977 Exp $
+** @(#) $Id: sqliteInt.h,v 1.433 2005/12/09 20:02:06 drh Exp $
 */
 #ifndef _SQLITEINT_H_
 #define _SQLITEINT_H_
 
 /*
@@ -1433,11 +1433,11 @@
 void *sqlite3TextToPtr(const char*);
 void sqlite3SetString(char **, ...);
 void sqlite3ErrorMsg(Parse*, const char*, ...);
 void sqlite3Dequote(char*);
 void sqlite3DequoteExpr(Expr*);
-int sqlite3KeywordCode(const char*, int);
+int sqlite3KeywordCode(const unsigned char*, int);
 int sqlite3RunParser(Parse*, const char*, char **);
 void sqlite3FinishCoding(Parse*);
 Expr *sqlite3Expr(int, Expr*, Expr*, const Token*);
 Expr *sqlite3RegisterExpr(Parse*,Token*);
 Expr *sqlite3ExprAnd(Expr*, Expr*);

Index: src/tokenize.c
==================================================================
--- src/tokenize.c
+++ src/tokenize.c
@@ -13,11 +13,11 @@
 **
 ** This file contains C code that splits an SQL input string up into
 ** individual tokens and sends those tokens one-by-one over to the
 ** parser for analysis.
 **
-** $Id: tokenize.c,v 1.109 2005/12/06 12:53:00 danielk1977 Exp $
+** $Id: tokenize.c,v 1.110 2005/12/09 20:02:06 drh Exp $
 */
 #include "sqliteInt.h"
 #include "os.h"
 #include <ctype.h>
 #include <stdlib.h>
@@ -358,11 +358,11 @@
   assert( pParse->nVarExprAlloc==0 );
   assert( pParse->apVarExpr==0 );
   pParse->zTail = pParse->zSql = zSql;
   while( sqlite3Tsd()->mallocFailed==0 && zSql[i]!=0 ){
     assert( i>=0 );
-    pParse->sLastToken.z = &zSql[i];
+    pParse->sLastToken.z = (u8*)&zSql[i];
     assert( pParse->sLastToken.dyn==0 );
     pParse->sLastToken.n = getToken((unsigned char*)&zSql[i],&tokenType);
     i += pParse->sLastToken.n;
     switch( tokenType ){
       case TK_SPACE:

Index: src/trigger.c
==================================================================
--- src/trigger.c
+++ src/trigger.c
@@ -235,11 +235,11 @@
     sqlite3BeginWriteOperation(pParse, 0, pTrig->iDb);
     sqlite3OpenMasterTable(v, pTrig->iDb);
     addr = sqlite3VdbeAddOpList(v, ArraySize(insertTrig), insertTrig);
     sqlite3VdbeChangeP3(v, addr+2, pTrig->name, 0); 
     sqlite3VdbeChangeP3(v, addr+3, pTrig->table, 0); 
-    sqlite3VdbeChangeP3(v, addr+6, pAll->z, pAll->n);
+    sqlite3VdbeChangeP3(v, addr+6, (char*)pAll->z, pAll->n);
     sqlite3ChangeCookie(db, v, pTrig->iDb);
     sqlite3VdbeAddOp(v, OP_Close, 0, 0);
     sqlite3VdbeOp3(v, OP_ParseSchema, pTrig->iDb, 0, 
        sqlite3MPrintf("type='trigger' AND name='%q'", pTrig->name), P3_DYNAMIC);
   }
@@ -276,11 +276,11 @@
 ** copy of all the Expr.token.z strings so that the TriggerStep structure
 ** will be valid even after the sqlite3_exec() call returns.
 */
 static void sqlitePersistTriggerStep(TriggerStep *p){
   if( p->target.z ){
-    p->target.z = sqliteStrNDup(p->target.z, p->target.n);
+    p->target.z = (u8*)sqliteStrNDup((char*)p->target.z, p->target.n);
     p->target.dyn = 1;
   }
   if( p->pSelect ){
     Select *pNew = sqlite3SelectDup(p->pSelect);
     sqlite3SelectDelete(p->pSelect);
@@ -621,12 +621,12 @@
   SrcList *pSrc;       /* SrcList to be returned */
 
   iDb = pStep->pTrig->iDb;
   if( iDb==0 || iDb>=2 ){
     assert( iDb<pParse->db->nDb );
-    sDb.z = pParse->db->aDb[iDb].zName;
-    sDb.n = strlen(sDb.z);
+    sDb.z = (u8*)pParse->db->aDb[iDb].zName;
+    sDb.n = strlen((char*)sDb.z);
     pSrc = sqlite3SrcListAppend(0, &sDb, &pStep->target);
   } else {
     pSrc = sqlite3SrcListAppend(0, &pStep->target, 0);
   }
   return pSrc;

Index: src/utf.c
==================================================================
--- src/utf.c
+++ src/utf.c
@@ -10,11 +10,11 @@
 **
 *************************************************************************
 ** This file contains routines used to translate between UTF-8, 
 ** UTF-16, UTF-16BE, and UTF-16LE.
 **
-** $Id: utf.c,v 1.32 2005/01/28 01:29:08 drh Exp $
+** $Id: utf.c,v 1.33 2005/12/09 20:02:06 drh Exp $
 **
 ** Notes on UTF-8:
 **
 **   Byte-0    Byte-1    Byte-2    Byte-3    Value
 **  0xxxxxxx                                 00000000 00000000 0xxxxxxx
@@ -270,11 +270,11 @@
     rc = sqlite3VdbeMemMakeWriteable(pMem);
     if( rc!=SQLITE_OK ){
       assert( rc==SQLITE_NOMEM );
       return SQLITE_NOMEM;
     }
-    zIn = pMem->z;
+    zIn = (u8*)pMem->z;
     zTerm = &zIn[pMem->n];
     while( zIn<zTerm ){
       temp = *zIn;
       *zIn = *(zIn+1);
       zIn++;
@@ -306,11 +306,11 @@
   **
   ** Variable zOut is set to point at the output buffer. This may be space
   ** obtained from malloc(), or Mem.zShort, if it large enough and not in
   ** use, or the zShort array on the stack (see above).
   */
-  zIn = pMem->z;
+  zIn = (u8*)pMem->z;
   zTerm = &zIn[pMem->n];
   if( len>NBFS ){
     zOut = sqliteMallocRaw(len);
     if( !zOut ) return SQLITE_NOMEM;
   }else{
@@ -358,16 +358,16 @@
   sqlite3VdbeMemRelease(pMem);
   pMem->flags &= ~(MEM_Static|MEM_Dyn|MEM_Ephem|MEM_Short);
   pMem->enc = desiredEnc;
   if( zOut==zShort ){
     memcpy(pMem->zShort, zOut, len);
-    zOut = pMem->zShort;
+    zOut = (u8*)pMem->zShort;
     pMem->flags |= (MEM_Term|MEM_Short);
   }else{
     pMem->flags |= (MEM_Term|MEM_Dyn);
   }
-  pMem->z = zOut;
+  pMem->z = (char*)zOut;
 
 translate_out:
 #if defined(TRANSLATE_TRACE) && defined(SQLITE_DEBUG)
   {
     char zBuf[100];

Index: src/vacuum.c
==================================================================
--- src/vacuum.c
+++ src/vacuum.c
@@ -12,11 +12,11 @@
 ** This file contains code used to implement the VACUUM command.
 **
 ** Most of the code in this file may be omitted by defining the
 ** SQLITE_OMIT_VACUUM macro.
 **
-** $Id: vacuum.c,v 1.52 2005/12/09 14:25:09 danielk1977 Exp $
+** $Id: vacuum.c,v 1.53 2005/12/09 20:02:06 drh Exp $
 */
 #include "sqliteInt.h"
 #include "vdbeInt.h"
 #include "os.h"
 
@@ -57,11 +57,11 @@
 
   rc = sqlite3_prepare(db, zSql, -1, &pStmt, 0);
   if( rc!=SQLITE_OK ) return rc;
 
   while( SQLITE_ROW==sqlite3_step(pStmt) ){
-    rc = execSql(db, sqlite3_column_text(pStmt, 0));
+    rc = execSql(db, (char*)sqlite3_column_text(pStmt, 0));
     if( rc!=SQLITE_OK ){
       sqlite3_finalize(pStmt);
       return rc;
     }
   }

Index: src/vdbe.c
==================================================================
--- src/vdbe.c
+++ src/vdbe.c
@@ -41,11 +41,11 @@
 ** documentation, headers files, or other derived files.  The formatting
 ** of the code in this file is, therefore, important.  See other comments
 ** in this file for details.  If in doubt, do not deviate from existing
 ** commenting and indentation practices when changing or adding code.
 **
-** $Id: vdbe.c,v 1.503 2005/12/09 14:25:09 danielk1977 Exp $
+** $Id: vdbe.c,v 1.504 2005/12/09 20:02:06 drh Exp $
 */
 #include "sqliteInt.h"
 #include "os.h"
 #include <ctype.h>
 #include "vdbeInt.h"
@@ -1883,11 +1883,11 @@
     pCrsr = pC->pCursor;
     if( pC->nullRow ){
       payloadSize = 0;
     }else if( pC->cacheValid ){
       payloadSize = pC->payloadSize;
-      zRec = pC->aRow;
+      zRec = (char*)pC->aRow;
     }else if( pC->isIndex ){
       i64 payloadSize64;
       sqlite3BtreeKeySize(pCrsr, &payloadSize64);
       payloadSize = payloadSize64;
     }else{
@@ -1950,16 +1950,17 @@
       ** save the payload in the pC->aRow cache.  That will save us from
       ** having to make additional calls to fetch the content portion of
       ** the record.
       */
       if( avail>=payloadSize ){
-        zRec = pC->aRow = zData;
+        zRec = zData;
+        pC->aRow = (u8*)zData;
       }else{
         pC->aRow = 0;
       }
     }
-    idx = sqlite3GetVarint32(zData, &szHdr);
+    idx = sqlite3GetVarint32((u8*)zData, &szHdr);
 
 
     /* The KeyFetch() or DataFetch() above are fast and will get the entire
     ** record header in most cases.  But they will fail to get the complete
     ** record header if the record header does not fit on a single page
@@ -1982,11 +1983,11 @@
     offset = szHdr;
     assert( offset>0 );
     i = 0;
     while( idx<szHdr && i<nField && offset<=payloadSize ){
       aOffset[i] = offset;
-      idx += sqlite3GetVarint32(&zData[idx], &aType[i]);
+      idx += sqlite3GetVarint32((u8*)&zData[idx], &aType[i]);
       offset += sqlite3VdbeSerialTypeLen(aType[i]);
       i++;
     }
     Release(&sMem);
     sMem.flags = MEM_Null;
@@ -2036,11 +2037,11 @@
       if( rc!=SQLITE_OK ){
         goto op_column_out;
       }
       zData = sMem.z;
     }
-    sqlite3VdbeSerialGet(zData, aType[p2], pTos);
+    sqlite3VdbeSerialGet((u8*)zData, aType[p2], pTos);
     pTos->enc = db->enc;
   }else{
     if( pOp->p3type==P3_MEM ){
       sqlite3VdbeMemShallowCopy(pTos, (Mem *)(pOp->p3), MEM_Static);
     }else{
@@ -2196,11 +2197,11 @@
     zNewRecord = sqliteMallocRaw(nByte);
     if( !zNewRecord ){
       goto no_mem;
     }
   }else{
-    zNewRecord = zTemp;
+    zNewRecord = (u8*)zTemp;
   }
 
   /* Write the record */
   zCsr = zNewRecord;
   zCsr += sqlite3PutVarint(zCsr, nHdr);
@@ -2230,11 +2231,11 @@
     pTos->z = pTos->zShort;
     memcpy(pTos->zShort, zTemp, nByte);
     pTos->flags = MEM_Blob | MEM_Short;
   }else{
     assert( zNewRecord!=(unsigned char *)zTemp );
-    pTos->z = zNewRecord;
+    pTos->z = (char*)zNewRecord;
     pTos->flags = MEM_Blob | MEM_Dyn;
     pTos->xDel = 0;
   }
   pTos->enc = SQLITE_UTF8;  /* In case the blob is ever converted to text */
 
@@ -2927,11 +2928,11 @@
     */
     Stringify(pNos, db->enc);
     zKey = pNos->z;
     nKey = pNos->n;
 
-    szRowid = sqlite3VdbeIdxRowidLen(nKey, zKey);
+    szRowid = sqlite3VdbeIdxRowidLen(nKey, (u8*)zKey);
     len = nKey-szRowid;
 
     /* Search for an entry in P1 where all but the last four bytes match K.
     ** If there is no such entry, jump immediately to P2.
     */
@@ -2944,11 +2945,11 @@
       if( res ){
         pc = pOp->p2 - 1;
         break;
       }
     }
-    rc = sqlite3VdbeIdxKeyCompare(pCx, len, zKey, &res); 
+    rc = sqlite3VdbeIdxKeyCompare(pCx, len, (u8*)zKey, &res); 
     if( rc!=SQLITE_OK ) goto abort_due_to_error;
     if( res>0 ){
       pc = pOp->p2 - 1;
       break;
     }
@@ -3720,11 +3721,11 @@
     assert( pTos->flags & MEM_Blob );  /* Created using OP_Make*Key */
     Stringify(pTos, db->enc);
     assert( pC->deferredMoveto==0 );
     *pC->pIncrKey = pOp->p3!=0;
     assert( pOp->p3==0 || pOp->opcode!=OP_IdxGT );
-    rc = sqlite3VdbeIdxKeyCompare(pC, pTos->n, pTos->z, &res);
+    rc = sqlite3VdbeIdxKeyCompare(pC, pTos->n, (u8*)pTos->z, &res);
     *pC->pIncrKey = 0;
     if( rc!=SQLITE_OK ){
       break;
     }
     if( pOp->opcode==OP_IdxLT ){
@@ -3758,13 +3759,13 @@
 
   assert( pTos>=p->aStack );
   assert( pTos->flags & MEM_Blob );
   z = pTos->z;
   n = pTos->n;
-  k = sqlite3GetVarint32(z, &serial_type);
+  k = sqlite3GetVarint32((u8*)z, &serial_type);
   for(; k<n && i>0; i--){
-    k += sqlite3GetVarint32(&z[k], &serial_type);
+    k += sqlite3GetVarint32((u8*)&z[k], &serial_type);
     if( serial_type==0 ){   /* Serial type 0 is a NULL */
       pc = pOp->p2-1;
       break;
     }
   }

Index: src/vdbeaux.c
==================================================================
--- src/vdbeaux.c
+++ src/vdbeaux.c
@@ -1778,14 +1778,14 @@
   }
   rc = sqlite3VdbeMemFromBtree(pCur, 0, nCellKey, 1, &m);
   if( rc ){
     return rc;
   }
-  sqlite3GetVarint32(m.z, &szHdr);
-  sqlite3GetVarint32(&m.z[szHdr-1], &typeRowid);
+  sqlite3GetVarint32((u8*)m.z, &szHdr);
+  sqlite3GetVarint32((u8*)&m.z[szHdr-1], &typeRowid);
   lenRowid = sqlite3VdbeSerialTypeLen(typeRowid);
-  sqlite3VdbeSerialGet(&m.z[m.n-lenRowid], typeRowid, &v);
+  sqlite3VdbeSerialGet((u8*)&m.z[m.n-lenRowid], typeRowid, &v);
   *rowid = v.i;
   sqlite3VdbeMemRelease(&m);
   return SQLITE_OK;
 }
 
@@ -1817,11 +1817,11 @@
   }
   rc = sqlite3VdbeMemFromBtree(pC->pCursor, 0, nCellKey, 1, &m);
   if( rc ){
     return rc;
   }
-  lenRowid = sqlite3VdbeIdxRowidLen(m.n, m.z);
+  lenRowid = sqlite3VdbeIdxRowidLen(m.n, (u8*)m.z);
   *res = sqlite3VdbeRecordCompare(pC->pKeyInfo, m.n-lenRowid, m.z, nKey, pKey);
   sqlite3VdbeMemRelease(&m);
   return SQLITE_OK;
 }
 

Index: src/vdbemem.c
==================================================================
--- src/vdbemem.c
+++ src/vdbemem.c
@@ -81,11 +81,11 @@
   pMem->flags |= MEM_Dyn|MEM_Term;
   pMem->xDel = 0;
   memcpy(z, pMem->z, n );
   z[n] = 0;
   z[n+1] = 0;
-  pMem->z = z;
+  pMem->z = (char*)z;
   pMem->flags &= ~(MEM_Ephem|MEM_Static|MEM_Short);
   return SQLITE_OK;
 }
 
 /*
@@ -101,11 +101,11 @@
     return SQLITE_OK;
   }
   assert( (pMem->flags & MEM_Dyn)==0 );
   assert( pMem->flags & (MEM_Str|MEM_Blob) );
   if( (n = pMem->n)+2<sizeof(pMem->zShort) ){
-    z = pMem->zShort;
+    z = (u8*)pMem->zShort;
     pMem->flags |= MEM_Short|MEM_Term;
   }else{
     z = sqliteMallocRaw( n+2 );
     if( z==0 ){
       return SQLITE_NOMEM;
@@ -114,11 +114,11 @@
     pMem->xDel = 0;
   }
   memcpy(z, pMem->z, n );
   z[n] = 0;
   z[n+1] = 0;
-  pMem->z = z;
+  pMem->z = (char*)z;
   pMem->flags &= ~(MEM_Ephem|MEM_Static);
   return SQLITE_OK;
 }
 
 /*
@@ -170,11 +170,11 @@
 ** user and the later is an internal programming error.
 */
 int sqlite3VdbeMemStringify(Mem *pMem, int enc){
   int rc = SQLITE_OK;
   int fg = pMem->flags;
-  u8 *z = pMem->zShort;
+  char *z = pMem->zShort;
 
   assert( !(fg&(MEM_Str|MEM_Blob)) );
   assert( fg&(MEM_Int|MEM_Real) );
 
   /* For a Real or Integer, use sqlite3_snprintf() to produce the UTF-8
@@ -797,11 +797,11 @@
     return SQLITE_OK;
   }
   op = pExpr->op;
 
   if( op==TK_STRING || op==TK_FLOAT || op==TK_INTEGER ){
-    zVal = sqliteStrNDup(pExpr->token.z, pExpr->token.n);
+    zVal = sqliteStrNDup((char*)pExpr->token.z, pExpr->token.n);
     pVal = sqlite3ValueNew();
     if( !zVal || !pVal ) goto no_mem;
     sqlite3Dequote(zVal);
     sqlite3ValueSetStr(pVal, -1, zVal, SQLITE_UTF8, sqlite3FreeX);
     if( (op==TK_INTEGER || op==TK_FLOAT ) && affinity==SQLITE_AFF_NONE ){
@@ -817,11 +817,11 @@
   }
 #ifndef SQLITE_OMIT_BLOB_LITERAL
   else if( op==TK_BLOB ){
     int nVal;
     pVal = sqlite3ValueNew();
-    zVal = sqliteStrNDup(pExpr->token.z+1, pExpr->token.n-1);
+    zVal = sqliteStrNDup((char*)pExpr->token.z+1, pExpr->token.n-1);
     if( !zVal || !pVal ) goto no_mem;
     sqlite3Dequote(zVal);
     nVal = strlen(zVal)/2;
     sqlite3VdbeMemSetStr(pVal, sqlite3HexToBlob(zVal), nVal, 0, sqlite3FreeX);
     sqliteFree(zVal);

Index: tool/mkkeywordhash.c
==================================================================
--- tool/mkkeywordhash.c
+++ tool/mkkeywordhash.c
@@ -493,11 +493,11 @@
   printf("      return aCode[i];\n");
   printf("    }\n");
   printf("  }\n");
   printf("  return TK_ID;\n");
   printf("}\n");
-  printf("int sqlite3KeywordCode(const char *z, int n){\n");
-  printf("  return keywordCode(z, n);\n");
+  printf("int sqlite3KeywordCode(const unsigned char *z, int n){\n");
+  printf("  return keywordCode((char*)z, n);\n");
   printf("}\n");
 
   return 0;
 }