/ Check-in [5471aca0]
Login

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

Overview
Comment:Fix various internal #defines to conform to new C-language naming restrictions, specifically that private-use macros names must not begin with "_".
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | trunk
Files: files | file ages | folders
SHA1: 5471aca0158851d3fb0a2517306917536deb38bb
User & Date: drh 2016-07-09 16:14:45
Context
2016-07-09
16:38
Fix compiler warnings on windows. check-in: 8b22f777 user: drh tags: trunk
16:14
Fix various internal #defines to conform to new C-language naming restrictions, specifically that private-use macros names must not begin with "_". check-in: 5471aca0 user: drh tags: trunk
00:06
Add support for the win32-none VFS. check-in: b5f32a89 user: drh tags: trunk
Changes
Hide Diffs Side-by-Side Diffs Ignore Whitespace Patch

Changes to src/btree.h.

     9      9   **    May you share freely, never taking more than you give.
    10     10   **
    11     11   *************************************************************************
    12     12   ** This header file defines the interface that the sqlite B-Tree file
    13     13   ** subsystem.  See comments in the source code for a detailed description
    14     14   ** of what each interface routine does.
    15     15   */
    16         -#ifndef _BTREE_H_
    17         -#define _BTREE_H_
           16  +#ifndef SQLITE_BTREE_H
           17  +#define SQLITE_BTREE_H
    18     18   
    19     19   /* TODO: This definition is just included so other modules compile. It
    20     20   ** needs to be revisited.
    21     21   */
    22     22   #define SQLITE_N_BTREE_META 16
    23     23   
    24     24   /*
................................................................................
   355    355   
   356    356   # define sqlite3BtreeHoldsMutex(X) 1
   357    357   # define sqlite3BtreeHoldsAllMutexes(X) 1
   358    358   # define sqlite3SchemaMutexHeld(X,Y,Z) 1
   359    359   #endif
   360    360   
   361    361   
   362         -#endif /* _BTREE_H_ */
          362  +#endif /* SQLITE_BTREE_H */

Changes to src/hash.h.

     8      8   **    May you find forgiveness for yourself and forgive others.
     9      9   **    May you share freely, never taking more than you give.
    10     10   **
    11     11   *************************************************************************
    12     12   ** This is the header file for the generic hash-table implementation
    13     13   ** used in SQLite.
    14     14   */
    15         -#ifndef _SQLITE_HASH_H_
    16         -#define _SQLITE_HASH_H_
           15  +#ifndef SQLITE_HASH_H
           16  +#define SQLITE_HASH_H
    17     17   
    18     18   /* Forward declarations of structures. */
    19     19   typedef struct Hash Hash;
    20     20   typedef struct HashElem HashElem;
    21     21   
    22     22   /* A complete hash table is an instance of the following structure.
    23     23   ** The internals of this structure are intended to be opaque -- client
................................................................................
    89     89   /* #define sqliteHashKeysize(E) ((E)->nKey)  // NOT USED */
    90     90   
    91     91   /*
    92     92   ** Number of entries in a hash table
    93     93   */
    94     94   /* #define sqliteHashCount(H)  ((H)->count) // NOT USED */
    95     95   
    96         -#endif /* _SQLITE_HASH_H_ */
           96  +#endif /* SQLITE_HASH_H */

Changes to src/hwtime.h.

     9      9   **    May you share freely, never taking more than you give.
    10     10   **
    11     11   ******************************************************************************
    12     12   **
    13     13   ** This file contains inline asm code for retrieving "high-performance"
    14     14   ** counters for x86 class CPUs.
    15     15   */
    16         -#ifndef _HWTIME_H_
    17         -#define _HWTIME_H_
           16  +#ifndef SQLITE_HWTIME_H
           17  +#define SQLITE_HWTIME_H
    18     18   
    19     19   /*
    20     20   ** The following routine only works on pentium-class (or newer) processors.
    21     21   ** It uses the RDTSC opcode to read the cycle count value out of the
    22     22   ** processor and returns that value.  This can be used for high-res
    23     23   ** profiling.
    24     24   */
................................................................................
    78     78     ** of the debugging and testing utilities, but it should at
    79     79     ** least compile and run.
    80     80     */
    81     81     sqlite_uint64 sqlite3Hwtime(void){ return ((sqlite_uint64)0); }
    82     82   
    83     83   #endif
    84     84   
    85         -#endif /* !defined(_HWTIME_H_) */
           85  +#endif /* !defined(SQLITE_HWTIME_H) */

Changes to src/msvc.h.

     8      8   **    May you find forgiveness for yourself and forgive others.
     9      9   **    May you share freely, never taking more than you give.
    10     10   **
    11     11   ******************************************************************************
    12     12   **
    13     13   ** This file contains code that is specific to MSVC.
    14     14   */
    15         -#ifndef _MSVC_H_
    16         -#define _MSVC_H_
           15  +#ifndef SQLITE_MSVC_H
           16  +#define SQLITE_MSVC_H
    17     17   
    18     18   #if defined(_MSC_VER)
    19     19   #pragma warning(disable : 4054)
    20     20   #pragma warning(disable : 4055)
    21     21   #pragma warning(disable : 4100)
    22     22   #pragma warning(disable : 4127)
    23     23   #pragma warning(disable : 4130)
................................................................................
    29     29   #pragma warning(disable : 4244)
    30     30   #pragma warning(disable : 4305)
    31     31   #pragma warning(disable : 4306)
    32     32   #pragma warning(disable : 4702)
    33     33   #pragma warning(disable : 4706)
    34     34   #endif /* defined(_MSC_VER) */
    35     35   
    36         -#endif /* _MSVC_H_ */
           36  +#endif /* SQLITE_MSVC_H */

Changes to src/os.c.

     9      9   **    May you share freely, never taking more than you give.
    10     10   **
    11     11   ******************************************************************************
    12     12   **
    13     13   ** This file contains OS interface code that is common to all
    14     14   ** architectures.
    15     15   */
    16         -#define _SQLITE_OS_C_ 1
    17     16   #include "sqliteInt.h"
    18         -#undef _SQLITE_OS_C_
    19     17   
    20     18   /*
    21     19   ** If we compile with the SQLITE_TEST macro set, then the following block
    22     20   ** of code will give us the ability to simulate a disk I/O error.  This
    23     21   ** is used for testing the I/O recovery logic.
    24     22   */
    25     23   #if defined(SQLITE_TEST)

Changes to src/os_setup.h.

     9      9   **    May you share freely, never taking more than you give.
    10     10   **
    11     11   ******************************************************************************
    12     12   **
    13     13   ** This file contains pre-processor directives related to operating system
    14     14   ** detection and/or setup.
    15     15   */
    16         -#ifndef _OS_SETUP_H_
    17         -#define _OS_SETUP_H_
           16  +#ifndef SQLITE_OS_SETUP_H
           17  +#define SQLITE_OS_SETUP_H
    18     18   
    19     19   /*
    20     20   ** Figure out if we are dealing with Unix, Windows, or some other operating
    21     21   ** system.
    22     22   **
    23     23   ** After the following block of preprocess macros, all of SQLITE_OS_UNIX,
    24     24   ** SQLITE_OS_WIN, and SQLITE_OS_OTHER will defined to either 1 or 0.  One of
................................................................................
    50     50   #  endif
    51     51   #else
    52     52   #  ifndef SQLITE_OS_WIN
    53     53   #    define SQLITE_OS_WIN 0
    54     54   #  endif
    55     55   #endif
    56     56   
    57         -#endif /* _OS_SETUP_H_ */
           57  +#endif /* SQLITE_OS_SETUP_H */

Changes to src/os_win.c.

  3671   3671   */
  3672   3672   #define WIN_SHM_BASE   ((22+SQLITE_SHM_NLOCK)*4)        /* first lock byte */
  3673   3673   #define WIN_SHM_DMS    (WIN_SHM_BASE+SQLITE_SHM_NLOCK)  /* deadman switch */
  3674   3674   
  3675   3675   /*
  3676   3676   ** Apply advisory locks for all n bytes beginning at ofst.
  3677   3677   */
  3678         -#define _SHM_UNLCK  1
  3679         -#define _SHM_RDLCK  2
  3680         -#define _SHM_WRLCK  3
         3678  +#define WINSHM_UNLCK  1
         3679  +#define WINSHM_RDLCK  2
         3680  +#define WINSHM_WRLCK  3
  3681   3681   static int winShmSystemLock(
  3682   3682     winShmNode *pFile,    /* Apply locks to this open shared-memory segment */
  3683         -  int lockType,         /* _SHM_UNLCK, _SHM_RDLCK, or _SHM_WRLCK */
         3683  +  int lockType,         /* WINSHM_UNLCK, WINSHM_RDLCK, or WINSHM_WRLCK */
  3684   3684     int ofst,             /* Offset to first byte to be locked/unlocked */
  3685   3685     int nByte             /* Number of bytes to lock or unlock */
  3686   3686   ){
  3687   3687     int rc = 0;           /* Result code form Lock/UnlockFileEx() */
  3688   3688   
  3689   3689     /* Access to the winShmNode object is serialized by the caller */
  3690   3690     assert( sqlite3_mutex_held(pFile->mutex) || pFile->nRef==0 );
  3691   3691   
  3692   3692     OSTRACE(("SHM-LOCK file=%p, lock=%d, offset=%d, size=%d\n",
  3693   3693              pFile->hFile.h, lockType, ofst, nByte));
  3694   3694   
  3695   3695     /* Release/Acquire the system-level lock */
  3696         -  if( lockType==_SHM_UNLCK ){
         3696  +  if( lockType==WINSHM_UNLCK ){
  3697   3697       rc = winUnlockFile(&pFile->hFile.h, ofst, 0, nByte, 0);
  3698   3698     }else{
  3699   3699       /* Initialize the locking parameters */
  3700   3700       DWORD dwFlags = LOCKFILE_FAIL_IMMEDIATELY;
  3701         -    if( lockType == _SHM_WRLCK ) dwFlags |= LOCKFILE_EXCLUSIVE_LOCK;
         3701  +    if( lockType == WINSHM_WRLCK ) dwFlags |= LOCKFILE_EXCLUSIVE_LOCK;
  3702   3702       rc = winLockFile(&pFile->hFile.h, dwFlags, ofst, 0, nByte, 0);
  3703   3703     }
  3704   3704   
  3705   3705     if( rc!= 0 ){
  3706   3706       rc = SQLITE_OK;
  3707   3707     }else{
  3708   3708       pFile->lastErrno =  osGetLastError();
  3709   3709       rc = SQLITE_BUSY;
  3710   3710     }
  3711   3711   
  3712   3712     OSTRACE(("SHM-LOCK file=%p, func=%s, errno=%lu, rc=%s\n",
  3713         -           pFile->hFile.h, (lockType == _SHM_UNLCK) ? "winUnlockFile" :
         3713  +           pFile->hFile.h, (lockType == WINSHM_UNLCK) ? "winUnlockFile" :
  3714   3714              "winLockFile", pFile->lastErrno, sqlite3ErrName(rc)));
  3715   3715   
  3716   3716     return rc;
  3717   3717   }
  3718   3718   
  3719   3719   /* Forward references to VFS methods */
  3720   3720   static int winOpen(sqlite3_vfs*,const char*,sqlite3_file*,int,int*);
................................................................................
  3834   3834       if( SQLITE_OK!=rc ){
  3835   3835         goto shm_open_err;
  3836   3836       }
  3837   3837   
  3838   3838       /* Check to see if another process is holding the dead-man switch.
  3839   3839       ** If not, truncate the file to zero length.
  3840   3840       */
  3841         -    if( winShmSystemLock(pShmNode, _SHM_WRLCK, WIN_SHM_DMS, 1)==SQLITE_OK ){
         3841  +    if( winShmSystemLock(pShmNode, WINSHM_WRLCK, WIN_SHM_DMS, 1)==SQLITE_OK ){
  3842   3842         rc = winTruncate((sqlite3_file *)&pShmNode->hFile, 0);
  3843   3843         if( rc!=SQLITE_OK ){
  3844   3844           rc = winLogError(SQLITE_IOERR_SHMOPEN, osGetLastError(),
  3845   3845                            "winOpenShm", pDbFd->zPath);
  3846   3846         }
  3847   3847       }
  3848   3848       if( rc==SQLITE_OK ){
  3849         -      winShmSystemLock(pShmNode, _SHM_UNLCK, WIN_SHM_DMS, 1);
  3850         -      rc = winShmSystemLock(pShmNode, _SHM_RDLCK, WIN_SHM_DMS, 1);
         3849  +      winShmSystemLock(pShmNode, WINSHM_UNLCK, WIN_SHM_DMS, 1);
         3850  +      rc = winShmSystemLock(pShmNode, WINSHM_RDLCK, WIN_SHM_DMS, 1);
  3851   3851       }
  3852   3852       if( rc ) goto shm_open_err;
  3853   3853     }
  3854   3854   
  3855   3855     /* Make the new connection a child of the winShmNode */
  3856   3856     p->pShmNode = pShmNode;
  3857   3857   #if defined(SQLITE_DEBUG) || defined(SQLITE_HAVE_OS_TRACE)
................................................................................
  3872   3872     p->pNext = pShmNode->pFirst;
  3873   3873     pShmNode->pFirst = p;
  3874   3874     sqlite3_mutex_leave(pShmNode->mutex);
  3875   3875     return SQLITE_OK;
  3876   3876   
  3877   3877     /* Jump here on any error */
  3878   3878   shm_open_err:
  3879         -  winShmSystemLock(pShmNode, _SHM_UNLCK, WIN_SHM_DMS, 1);
         3879  +  winShmSystemLock(pShmNode, WINSHM_UNLCK, WIN_SHM_DMS, 1);
  3880   3880     winShmPurge(pDbFd->pVfs, 0);      /* This call frees pShmNode if required */
  3881   3881     sqlite3_free(p);
  3882   3882     sqlite3_free(pNew);
  3883   3883     winShmLeaveMutex();
  3884   3884     return rc;
  3885   3885   }
  3886   3886   
................................................................................
  3961   3961         if( pX==p ) continue;
  3962   3962         assert( (pX->exclMask & (p->exclMask|p->sharedMask))==0 );
  3963   3963         allMask |= pX->sharedMask;
  3964   3964       }
  3965   3965   
  3966   3966       /* Unlock the system-level locks */
  3967   3967       if( (mask & allMask)==0 ){
  3968         -      rc = winShmSystemLock(pShmNode, _SHM_UNLCK, ofst+WIN_SHM_BASE, n);
         3968  +      rc = winShmSystemLock(pShmNode, WINSHM_UNLCK, ofst+WIN_SHM_BASE, n);
  3969   3969       }else{
  3970   3970         rc = SQLITE_OK;
  3971   3971       }
  3972   3972   
  3973   3973       /* Undo the local locks */
  3974   3974       if( rc==SQLITE_OK ){
  3975   3975         p->exclMask &= ~mask;
................................................................................
  3989   3989         }
  3990   3990         allShared |= pX->sharedMask;
  3991   3991       }
  3992   3992   
  3993   3993       /* Get shared locks at the system level, if necessary */
  3994   3994       if( rc==SQLITE_OK ){
  3995   3995         if( (allShared & mask)==0 ){
  3996         -        rc = winShmSystemLock(pShmNode, _SHM_RDLCK, ofst+WIN_SHM_BASE, n);
         3996  +        rc = winShmSystemLock(pShmNode, WINSHM_RDLCK, ofst+WIN_SHM_BASE, n);
  3997   3997         }else{
  3998   3998           rc = SQLITE_OK;
  3999   3999         }
  4000   4000       }
  4001   4001   
  4002   4002       /* Get the local shared locks */
  4003   4003       if( rc==SQLITE_OK ){
................................................................................
  4014   4014         }
  4015   4015       }
  4016   4016   
  4017   4017       /* Get the exclusive locks at the system level.  Then if successful
  4018   4018       ** also mark the local connection as being locked.
  4019   4019       */
  4020   4020       if( rc==SQLITE_OK ){
  4021         -      rc = winShmSystemLock(pShmNode, _SHM_WRLCK, ofst+WIN_SHM_BASE, n);
         4021  +      rc = winShmSystemLock(pShmNode, WINSHM_WRLCK, ofst+WIN_SHM_BASE, n);
  4022   4022         if( rc==SQLITE_OK ){
  4023   4023           assert( (p->sharedMask & mask)==0 );
  4024   4024           p->exclMask |= mask;
  4025   4025         }
  4026   4026       }
  4027   4027     }
  4028   4028     sqlite3_mutex_leave(pShmNode->mutex);

Changes to src/os_win.h.

     8      8   **    May you find forgiveness for yourself and forgive others.
     9      9   **    May you share freely, never taking more than you give.
    10     10   **
    11     11   ******************************************************************************
    12     12   **
    13     13   ** This file contains code that is specific to Windows.
    14     14   */
    15         -#ifndef _OS_WIN_H_
    16         -#define _OS_WIN_H_
           15  +#ifndef SQLITE_OS_WIN_H
           16  +#define SQLITE_OS_WIN_H
    17     17   
    18     18   /*
    19     19   ** Include the primary Windows SDK header file.
    20     20   */
    21     21   #include "windows.h"
    22     22   
    23     23   #ifdef __CYGWIN__
................................................................................
    81     81   #if SQLITE_OS_WIN && !SQLITE_OS_WINCE && !SQLITE_OS_WINRT && \
    82     82       SQLITE_THREADSAFE>0 && !defined(__CYGWIN__)
    83     83   # define SQLITE_OS_WIN_THREADS 1
    84     84   #else
    85     85   # define SQLITE_OS_WIN_THREADS 0
    86     86   #endif
    87     87   
    88         -#endif /* _OS_WIN_H_ */
           88  +#endif /* SQLITE_OS_WIN_H */

Changes to src/pager.h.

    10     10   **
    11     11   *************************************************************************
    12     12   ** This header file defines the interface that the sqlite page cache
    13     13   ** subsystem.  The page cache subsystem reads and writes a file a page
    14     14   ** at a time and provides a journal for rollback.
    15     15   */
    16     16   
    17         -#ifndef _PAGER_H_
    18         -#define _PAGER_H_
           17  +#ifndef SQLITE_PAGER_H
           18  +#define SQLITE_PAGER_H
    19     19   
    20     20   /*
    21     21   ** Default maximum size for persistent journal files. A negative 
    22     22   ** value means no limit. This value may be overridden using the 
    23     23   ** sqlite3PagerJournalSizeLimit() API. See also "PRAGMA journal_size_limit".
    24     24   */
    25     25   #ifndef SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT
................................................................................
   225    225     void disable_simulated_io_errors(void);
   226    226     void enable_simulated_io_errors(void);
   227    227   #else
   228    228   # define disable_simulated_io_errors()
   229    229   # define enable_simulated_io_errors()
   230    230   #endif
   231    231   
   232         -#endif /* _PAGER_H_ */
          232  +#endif /* SQLITE_PAGER_H */

Changes to src/sqlite.h.in.

    26     26   ** on how SQLite interfaces are supposed to operate.
    27     27   **
    28     28   ** The name of this file under configuration management is "sqlite.h.in".
    29     29   ** The makefile makes some minor changes to this file (such as inserting
    30     30   ** the version number) and changes its name to "sqlite3.h" as
    31     31   ** part of the build process.
    32     32   */
    33         -#ifndef _SQLITE3_H_
    34         -#define _SQLITE3_H_
           33  +#ifndef SQLITE3_H
           34  +#define SQLITE3_H
    35     35   #include <stdarg.h>     /* Needed for the definition of va_list */
    36     36   
    37     37   /*
    38     38   ** Make sure we can call this stuff from C++.
    39     39   */
    40     40   #ifdef __cplusplus
    41     41   extern "C" {
................................................................................
  8214   8214   #ifdef SQLITE_OMIT_FLOATING_POINT
  8215   8215   # undef double
  8216   8216   #endif
  8217   8217   
  8218   8218   #ifdef __cplusplus
  8219   8219   }  /* End of the 'extern "C"' block */
  8220   8220   #endif
  8221         -#endif /* _SQLITE3_H_ */
         8221  +#endif /* SQLITE3_H */

Changes to src/sqlite3ext.h.

    11     11   *************************************************************************
    12     12   ** This header file defines the SQLite interface for use by
    13     13   ** shared libraries that want to be imported as extensions into
    14     14   ** an SQLite instance.  Shared libraries that intend to be loaded
    15     15   ** as extensions by SQLite should #include this file instead of 
    16     16   ** sqlite3.h.
    17     17   */
    18         -#ifndef _SQLITE3EXT_H_
    19         -#define _SQLITE3EXT_H_
           18  +#ifndef SQLITE3EXT_H
           19  +#define SQLITE3EXT_H
    20     20   #include "sqlite3.h"
    21     21   
    22     22   typedef struct sqlite3_api_routines sqlite3_api_routines;
    23     23   
    24     24   /*
    25     25   ** The following structure holds pointers to all of the SQLite API
    26     26   ** routines.
................................................................................
   539    539     /* This case when the file is being statically linked into the 
   540    540     ** application */
   541    541   # define SQLITE_EXTENSION_INIT1     /*no-op*/
   542    542   # define SQLITE_EXTENSION_INIT2(v)  (void)v; /* unused parameter */
   543    543   # define SQLITE_EXTENSION_INIT3     /*no-op*/
   544    544   #endif
   545    545   
   546         -#endif /* _SQLITE3EXT_H_ */
          546  +#endif /* SQLITE3EXT_H */

Changes to src/sqliteInt.h.

     8      8   **    May you find forgiveness for yourself and forgive others.
     9      9   **    May you share freely, never taking more than you give.
    10     10   **
    11     11   *************************************************************************
    12     12   ** Internal interface definitions for SQLite.
    13     13   **
    14     14   */
    15         -#ifndef _SQLITEINT_H_
    16         -#define _SQLITEINT_H_
           15  +#ifndef SQLITEINT_H
           16  +#define SQLITEINT_H
    17     17   
    18     18   /* Special Comments:
    19     19   **
    20     20   ** Some comments have special meaning to the tools that measure test
    21     21   ** coverage:
    22     22   **
    23     23   **    NO_TEST                     - The branches on this line are not
................................................................................
  4233   4233   int sqlite3ThreadJoin(SQLiteThread*, void**);
  4234   4234   #endif
  4235   4235   
  4236   4236   #if defined(SQLITE_ENABLE_DBSTAT_VTAB) || defined(SQLITE_TEST)
  4237   4237   int sqlite3DbstatRegister(sqlite3*);
  4238   4238   #endif
  4239   4239   
  4240         -#endif /* _SQLITEINT_H_ */
         4240  +#endif /* SQLITEINT_H */

Changes to src/test_intarray.h.

    71     71   ** The intarray object is automatically destroyed when its corresponding
    72     72   ** virtual table is dropped.  Since the virtual tables are created in the
    73     73   ** TEMP database, they are automatically dropped when the database connection
    74     74   ** closes so the application does not normally need to take any special
    75     75   ** action to free the intarray objects.
    76     76   */
    77     77   #include "sqlite3.h"
    78         -#ifndef _INTARRAY_H_
    79         -#define _INTARRAY_H_
           78  +#ifndef SQLITE_INTARRAY_H
           79  +#define SQLITE_INTARRAY_H
    80     80   
    81     81   /*
    82     82   ** Make sure we can call this stuff from C++.
    83     83   */
    84     84   #ifdef __cplusplus
    85     85   extern "C" {
    86     86   #endif
................................................................................
   121    121     sqlite3_int64 *aElements,      /* Content of the intarray */
   122    122     void (*xFree)(void*)           /* How to dispose of the intarray when done */
   123    123   );
   124    124   
   125    125   #ifdef __cplusplus
   126    126   }  /* End of the 'extern "C"' block */
   127    127   #endif
   128         -#endif /* _INTARRAY_H_ */
          128  +#endif /* SQLITE_INTARRAY_H */

Changes to src/test_multiplex.h.

    16     16   ** This particular shim enforces a multiplex system on DB files.  
    17     17   ** This shim shards/partitions a single DB file into smaller 
    18     18   ** "chunks" such that the total DB file size may exceed the maximum
    19     19   ** file size of the underlying file system.
    20     20   **
    21     21   */
    22     22   
    23         -#ifndef _TEST_MULTIPLEX_H
    24         -#define _TEST_MULTIPLEX_H
           23  +#ifndef SQLITE_TEST_MULTIPLEX_H
           24  +#define SQLITE_TEST_MULTIPLEX_H
    25     25   
    26     26   /*
    27     27   ** CAPI: File-control Operations Supported by Multiplex VFS
    28     28   **
    29     29   ** Values interpreted by the xFileControl method of a Multiplex VFS db file-handle.
    30     30   **
    31     31   ** MULTIPLEX_CTRL_ENABLE:
................................................................................
    92     92   */
    93     93   extern int sqlite3_multiplex_shutdown(int eForce);
    94     94   
    95     95   #ifdef __cplusplus
    96     96   }  /* End of the 'extern "C"' block */
    97     97   #endif
    98     98   
    99         -#endif /* _TEST_MULTIPLEX_H */
           99  +#endif /* SQLITE_TEST_MULTIPLEX_H */

Changes to src/vdbe.h.

    11     11   *************************************************************************
    12     12   ** Header file for the Virtual DataBase Engine (VDBE)
    13     13   **
    14     14   ** This header defines the interface to the virtual database engine
    15     15   ** or VDBE.  The VDBE implements an abstract machine that runs a
    16     16   ** simple program to access and modify the underlying database.
    17     17   */
    18         -#ifndef _SQLITE_VDBE_H_
    19         -#define _SQLITE_VDBE_H_
           18  +#ifndef SQLITE_VDBE_H
           19  +#define SQLITE_VDBE_H
    20     20   #include <stdio.h>
    21     21   
    22     22   /*
    23     23   ** A single VDBE is an opaque structure named "Vdbe".  Only routines
    24     24   ** in the source file sqliteVdbe.c are allowed to see the insides
    25     25   ** of this structure.
    26     26   */
................................................................................
   305    305   
   306    306   #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
   307    307   void sqlite3VdbeScanStatus(Vdbe*, int, int, int, LogEst, const char*);
   308    308   #else
   309    309   # define sqlite3VdbeScanStatus(a,b,c,d,e)
   310    310   #endif
   311    311   
   312         -#endif
          312  +#endif /* SQLITE_VDBE_H */

Changes to src/vdbeInt.h.

    11     11   *************************************************************************
    12     12   ** This is the header file for information that is private to the
    13     13   ** VDBE.  This information used to all be at the top of the single
    14     14   ** source code file "vdbe.c".  When that file became too big (over
    15     15   ** 6000 lines long) it was split up into several smaller files and
    16     16   ** this header information was factored out.
    17     17   */
    18         -#ifndef _VDBEINT_H_
    19         -#define _VDBEINT_H_
           18  +#ifndef SQLITE_VDBEINT_H
           19  +#define SQLITE_VDBEINT_H
    20     20   
    21     21   /*
    22     22   ** The maximum number of times that a statement will try to reparse
    23     23   ** itself before giving up and returning SQLITE_SCHEMA.
    24     24   */
    25     25   #ifndef SQLITE_MAX_SCHEMA_RETRY
    26     26   # define SQLITE_MAX_SCHEMA_RETRY 50
................................................................................
   554    554     int sqlite3VdbeMemExpandBlob(Mem *);
   555    555     #define ExpandBlob(P) (((P)->flags&MEM_Zero)?sqlite3VdbeMemExpandBlob(P):0)
   556    556   #else
   557    557     #define sqlite3VdbeMemExpandBlob(x) SQLITE_OK
   558    558     #define ExpandBlob(P) SQLITE_OK
   559    559   #endif
   560    560   
   561         -#endif /* !defined(_VDBEINT_H_) */
          561  +#endif /* !defined(SQLITE_VDBEINT_H) */

Changes to src/wal.h.

    10     10   **
    11     11   *************************************************************************
    12     12   ** This header file defines the interface to the write-ahead logging 
    13     13   ** system. Refer to the comments below and the header comment attached to 
    14     14   ** the implementation of each function in log.c for further details.
    15     15   */
    16     16   
    17         -#ifndef _WAL_H_
    18         -#define _WAL_H_
           17  +#ifndef SQLITE_WAL_H
           18  +#define SQLITE_WAL_H
    19     19   
    20     20   #include "sqliteInt.h"
    21     21   
    22     22   /* Additional values that can be added to the sync_flags argument of
    23     23   ** sqlite3WalFrames():
    24     24   */
    25     25   #define WAL_SYNC_TRANSACTIONS  0x20   /* Sync at the end of each transaction */
................................................................................
   139    139   int sqlite3WalFramesize(Wal *pWal);
   140    140   #endif
   141    141   
   142    142   /* Return the sqlite3_file object for the WAL file */
   143    143   sqlite3_file *sqlite3WalFile(Wal *pWal);
   144    144   
   145    145   #endif /* ifndef SQLITE_OMIT_WAL */
   146         -#endif /* _WAL_H_ */
          146  +#endif /* SQLITE_WAL_H */