Index: src/main.c
==================================================================
--- src/main.c
+++ src/main.c
@@ -1312,11 +1312,11 @@
       case SQLITE_LOCKED:             zName = "SQLITE_LOCKED";            break;
       case SQLITE_LOCKED_SHAREDCACHE: zName = "SQLITE_LOCKED_SHAREDCACHE";break;
       case SQLITE_NOMEM:              zName = "SQLITE_NOMEM";             break;
       case SQLITE_READONLY:           zName = "SQLITE_READONLY";          break;
       case SQLITE_READONLY_RECOVERY:  zName = "SQLITE_READONLY_RECOVERY"; break;
-      case SQLITE_READONLY_CANTLOCK:  zName = "SQLITE_READONLY_CANTLOCK"; break;
+      case SQLITE_READONLY_CANTINIT:  zName = "SQLITE_READONLY_CANTINIT"; break;
       case SQLITE_READONLY_ROLLBACK:  zName = "SQLITE_READONLY_ROLLBACK"; break;
       case SQLITE_READONLY_DBMOVED:   zName = "SQLITE_READONLY_DBMOVED";  break;
       case SQLITE_INTERRUPT:          zName = "SQLITE_INTERRUPT";         break;
       case SQLITE_IOERR:              zName = "SQLITE_IOERR";             break;
       case SQLITE_IOERR_READ:         zName = "SQLITE_IOERR_READ";        break;

Index: src/os_unix.c
==================================================================
--- src/os_unix.c
+++ src/os_unix.c
@@ -4276,11 +4276,11 @@
 ** take it now. Return SQLITE_OK if successful, or an SQLite error
 ** code otherwise.
 **
 ** If the DMS cannot be locked because this is a readonly_shm=1 
 ** connection and no other process already holds a lock, return
-** SQLITE_READONLY_CANTLOCK and set pShmNode->isUnlocked=1.
+** SQLITE_READONLY_CANTINIT and set pShmNode->isUnlocked=1.
 */
 static int unixLockSharedMemory(unixFile *pDbFd, unixShmNode *pShmNode){
   struct flock lock;
   int rc = SQLITE_OK;
 
@@ -4309,11 +4309,11 @@
   if( osFcntl(pShmNode->h, F_GETLK, &lock)!=0 ) {
     rc = SQLITE_IOERR_LOCK;
   }else if( lock.l_type==F_UNLCK ){
     if( pShmNode->isReadonly ){
       pShmNode->isUnlocked = 1;
-      rc = SQLITE_READONLY_CANTLOCK;
+      rc = SQLITE_READONLY_CANTINIT;
     }else{
       rc = unixShmSystemLock(pDbFd, F_WRLCK, UNIX_SHM_DMS, 1);
       if( rc==SQLITE_OK && robust_ftruncate(pShmNode->h, 0) ){
         rc = unixLogError(SQLITE_IOERR_SHMOPEN,"ftruncate",pShmNode->zFilename);
       }
@@ -4448,11 +4448,11 @@
       ** the original owner will not be able to connect.
       */
       robustFchown(pShmNode->h, sStat.st_uid, sStat.st_gid);
 
       rc = unixLockSharedMemory(pDbFd, pShmNode);
-      if( rc!=SQLITE_OK && rc!=SQLITE_READONLY_CANTLOCK ) goto shm_open_err;
+      if( rc!=SQLITE_OK && rc!=SQLITE_READONLY_CANTINIT ) goto shm_open_err;
     }
   }
 
   /* Make the new connection a child of the unixShmNode */
   p->pShmNode = pShmNode;

Index: src/sqlite.h.in
==================================================================
--- src/sqlite.h.in
+++ src/sqlite.h.in
@@ -509,11 +509,11 @@
 #define SQLITE_CANTOPEN_FULLPATH       (SQLITE_CANTOPEN | (3<<8))
 #define SQLITE_CANTOPEN_CONVPATH       (SQLITE_CANTOPEN | (4<<8))
 #define SQLITE_CANTOPEN_DIRTYWAL       (SQLITE_CANTOPEN | (5<<8))
 #define SQLITE_CORRUPT_VTAB            (SQLITE_CORRUPT | (1<<8))
 #define SQLITE_READONLY_RECOVERY       (SQLITE_READONLY | (1<<8))
-#define SQLITE_READONLY_CANTLOCK       (SQLITE_READONLY | (2<<8))
+#define SQLITE_READONLY_CANTINIT       (SQLITE_READONLY | (2<<8))
 #define SQLITE_READONLY_ROLLBACK       (SQLITE_READONLY | (3<<8))
 #define SQLITE_READONLY_DBMOVED        (SQLITE_READONLY | (4<<8))
 #define SQLITE_ABORT_ROLLBACK          (SQLITE_ABORT | (2<<8))
 #define SQLITE_CONSTRAINT_CHECK        (SQLITE_CONSTRAINT | (1<<8))
 #define SQLITE_CONSTRAINT_COMMITHOOK   (SQLITE_CONSTRAINT | (2<<8))

Index: src/wal.c
==================================================================
--- src/wal.c
+++ src/wal.c
@@ -2097,11 +2097,11 @@
   /* Ensure that page 0 of the wal-index (the page that contains the 
   ** wal-index header) is mapped. Return early if an error occurs here.
   */
   assert( pChanged );
   rc = walIndexPage(pWal, 0, &page0);
-  if( rc==SQLITE_READONLY_CANTLOCK ){
+  if( rc==SQLITE_READONLY_CANTINIT ){
     assert( page0==0 && pWal->writeLock==0 );
     pWal->bUnlocked = 1;
     pWal->exclusiveMode = WAL_HEAPMEMORY_MODE;
     *pChanged = 1;
   }else
@@ -2217,11 +2217,11 @@
   ** client is connected at this point, it may have already checkpointed 
   ** the entire wal. In that case it would not be safe to continue with
   ** the unlocked transaction, as the other client may overwrite wal 
   ** frames that this client is still using.  */
   rc = sqlite3OsShmMap(pWal->pDbFd, 0, WALINDEX_PGSZ, 0, &pDummy);
-  if( rc!=SQLITE_READONLY_CANTLOCK ){
+  if( rc!=SQLITE_READONLY_CANTINIT ){
     assert( rc!=SQLITE_OK );
     rc = (rc==SQLITE_READONLY ? WAL_RETRY : rc);
     goto begin_unlocked_out;
   }
 
@@ -2507,11 +2507,11 @@
       }
     }
   }
   if( mxI==0 ){
     assert( rc==SQLITE_BUSY || (pWal->readOnly & WAL_SHM_RDONLY)!=0 );
-    return rc==SQLITE_BUSY ? WAL_RETRY : SQLITE_READONLY_CANTLOCK;
+    return rc==SQLITE_BUSY ? WAL_RETRY : SQLITE_READONLY_CANTINIT;
   }
 
   rc = walLockShared(pWal, WAL_READ_LOCK(mxI));
   if( rc ){
     return rc==SQLITE_BUSY ? WAL_RETRY : rc;