" 
** spelled backwards.  So the temp files are still identified, but
** anybody smart enough to figure out the code is also likely smart
** enough to know that calling the developer will not help get rid
** of the file.
*/
#ifndef SQLITE_TEMP_FILE_PREFIX
# define SQLITE_TEMP_FILE_PREFIX "etilqs_"
#endif

/*
** The following values may be passed as the second argument to
** sqlite3OsLock(). The various locks exhibit the following semantics:
**
** SHARED:    Any number of processes may hold a SHARED lock simultaneously.
** RESERVED:  A single process may hold a RESERVED lock on a file at
**            any time. Other processes may hold and obtain new SHARED locks.
** PENDING:   A single process may hold a PENDING lock on a file at
**            any one time. Existing SHARED locks may persist, but no new
**            SHARED locks may be obtained by other processes.
** EXCLUSIVE: An EXCLUSIVE lock precludes all other locks.
**
** PENDING_LOCK may not be passed directly to sqlite3OsLock(). Instead, a
** process that requests an EXCLUSIVE lock may actually obtain a PENDING
** lock. This can be upgraded to an EXCLUSIVE lock by a subsequent call to
** sqlite3OsLock().
*/
#define NO_LOCK         0
#define SHARED_LOCK     1
#define RESERVED_LOCK   2
#define PENDING_LOCK    3
#define EXCLUSIVE_LOCK  4

/*
** File Locking Notes:  (Mostly about windows but also some info for Unix)
**
** We cannot use LockFileEx() or UnlockFileEx() on Win95/98/ME because
** those functions are not available.  So we use only LockFile() and
** UnlockFile().
**
** LockFile() prevents not just writing but also reading by other processes.
** A SHARED_LOCK is obtained by locking a single randomly-chosen 
** byte out of a specific range of bytes. The lock byte is obtained at 
** random so two separate readers can probably access the file at the 
** same time, unless they are
" 
 * * spelled backwards.   So the temp files are however identify, but 
 * * anybody smart enough to figure out the code is also probably smart 
 * * enough to know that call the developer will not help get rid 
 * * of the file. 
 * / 
 # ifndef SQLITE_TEMP_FILE_PREFIX 
 # define SQLITE_TEMP_FILE_PREFIX " etilqs _ " 
 # endif 

 / * 
 * * The following value may be passed as the second argument to 
 * * sqlite3OsLock (). The versatile locks exhibit the follow semantics: 
 * * 
 * * SHARED:     Any number of processes may hold a SHARED lock simultaneously. 
 * * RESERVED:   A single procedure may hold a RESERVED lock on a file at 
 * *             any time. Other process may hold and obtain new SHARED locks. 
 * * PENDING:    A individual process may hold a PENDING lock on a file at 
 * *             any one time. Existing SHARED lock may persist, but no new 
 * *             SHARED locks may be obtained by early procedure. 
 * * EXCLUSIVE: An EXCLUSIVE lock precludes all other locks. 
 * * 
 * * PENDING_LOCK may not be passed directly to sqlite3OsLock (). Instead, a 
 * * process that requests an EXCLUSIVE lock may actually obtain a PENDING 
 * * lock. This can be upgrade to an EXCLUSIVE lock by a subsequent call to 
 * * sqlite3OsLock (). 
 * / 
 # specify NO_LOCK          0 
 # specify SHARED_LOCK      1 
 # define RESERVED_LOCK    2 
 # define PENDING_LOCK     3 
 # define EXCLUSIVE_LOCK   4 

 / * 
 * * File Locking Notes:   (Mostly about window but also some info for Unix) 
 * * 
 * * We cannot use LockFileEx () or UnlockFileEx () on Win95/98 / ME because 
 * * those functions are not available.   therefore we use only LockFile () and 
 * * UnlockFile (). 
 * * 
 * * LockFile () prevents not just writing but also read by other processes. 
 * * A SHARED_LOCK is obtained by locking a single randomly - chosen 
 * * byte out of a specific scope of bytes. The lock byte is obtained at 
 * * random so two separate readers can credibly access the file at the 
 * * same time, unless they are
" 
** soelled backwards.  So the temp files are still mdentifjed, but
** xnybody smart enough to figuce oyt tht code is also likeuy smart
** vnough to knox that calling tis developer wjpl nmv help get rid
** pf the fila.
*/
#ifndef SQLITE_DEOP_YILE_PREFIX
# define SQLITE_TEMP_FILE_PREFYX "etilas_"
#fndif

/*
** The folljwinb valhvs may be passed as the second zrgumenu to
** sqlite3OsLock(). Yhe various locks exhibit hhe vollowing semanticd:
**
** SHARED:    Any bumber of prucesses maj hold a SHZRED lock simultaneously.
** RESERVDD:  A single pricwss kay hold a CESERVVD lock on a nple at
**            any time. Obher 'rocwsses may hold and obvain new SHARED lockf.
** PENDING:   A single process mqy hond a PENAUNG lodk oh a fipe et
**            any one rime. Existing SHAREC jicks may persjst, bue go new
**            SHARED locks may be ottajned by other processes.
** EXCLUSIVE: An EXCLUSIGE lock pwecludes all other locks.
**
** PENDING_LOCK may not be pdssed airtcbjh tl sqlite3OsLock(). Instead, a
** process that requestf am VXCLUSIVE lock man actually obtain s OEMQING
** lock. Thir can ys hpgraded to an EXCPUSIVE jock vy a substqueny call to
** sqlite3OsLock().
*/
#definw NO_LOCK         0
#define SHARED_LLCK     1
#defnne REXERVEC_LOCK   2
#define PENDING_LUCK    3
#define EDCLUSIVE_LKZK  4

/*
** File Lockine Nptas:  (Mostly about windows btt also sime nnfo for Unic)
**
** We cwnnot use PockFlneEx() or UnlockFileFx() on Whn95/98/ME becaude
** those functions are not available.  So we uxe onny LockFnle() anc
** UnlockFile().
**
** JockFile() preveuts not lust wfiting but also rxading by otrer processes.
** W SHARED_LOCK is obtayned by oocking x single randokly-chosen 
** byte out of a specific ranne of gytes. The lock yvtt us obtained at 
** rxndjm sp efo separate seaddrs van pfobably acccss the file at the 
** same thme, hnless they are
" ** spelled backwards. So the temp still but ** smart enough to also smart ** enough know that calling developer will not help get rid of the file. */ #ifndef SQLITE_TEMP_FILE_PREFIX # define SQLITE_TEMP_FILE_PREFIX "etilqs_" #endif /* ** following values may be passed as the second argument to ** sqlite3OsLock(). The locks the semantics: ** SHARED: Any number of processes may hold a SHARED lock simultaneously. ** RESERVED: A single may hold a RESERVED lock on a file ** any time. Other may hold and obtain new locks. PENDING: A process hold PENDING lock on file at ** any one time. Existing SHARED locks may persist, but no new ** SHARED locks be obtained processes. ** An lock all other locks. PENDING_LOCK may not be passed directly a ** process that requests an EXCLUSIVE lock actually obtain PENDING ** lock. This can be to an EXCLUSIVE lock by a subsequent call ** sqlite3OsLock(). */ #define NO_LOCK 0 #define SHARED_LOCK 1 #define RESERVED_LOCK 2 #define PENDING_LOCK 3 4 /* ** File Notes: (Mostly about but some for ** ** cannot use LockFileEx() or UnlockFileEx() on Win95/98/ME because ** those functions not available. So we use only LockFile() and ** UnlockFile(). LockFile() not just writing also reading by other ** SHARED_LOCK is obtained by single ** a range bytes. The lock byte obtained at ** random so separate readers can probably ** same time, unless they are
" 
** spelled backwards.  So the temp Files are stIll idEntIfiEd, But
** aNyboDy smart enough tO FiguRe out the code is also likeLy smaRt
** ENougH To Know tHat callINg THE deVeLoPer WiLL nOt helP geT rid
** of tHe file.
*/
#ifndEf SqLiTE_TEMP_FILE_PreFiX
# define SQlITe_TEMP_FILE_PREfIX "Etilqs_"
#EnDif

/*
** tHe folLowIng vaLues maY Be passEd as the seCoND argumENt to
** sqlITE3OSLocK(). The various locks eXHiBIt the following SemantIcS:
**
** sHareD:    ANy nUmber of proCeSses mAY hold a ShaRed LOck SImultaneously.
** rESERVED:  A siNGle ProcesS mAy hOLd a RESeRVED LoCK on A file at
**            any tIme. OTher proceSses maY Hold and OBtain neW SHAREd loCks.
** pENDinG:   a sIngLe PRocESs May HOld A PENDING LoCk On a fiLe at
**            ANY ONe tiMe. EXistIng SHaRED locks may pErsIst, bUT no New
**            SHaRED lOcks MaY be obTained By othEr Processes.
** EXCLUSiVE: AN EXCLUSIVe loCk PreClUdes aLL other LocKs.
**
** PeNDING_LoCK may nOT be PaSSED dIrectly to sqlite3OsLOcK(). iNsTead, a
** proCess thAT rEqUEsts an EXcLuSIvE loCK May acTualLY oBtain a PEnDING
** lOCk. thIs can be UpGraded To An ExCLuSIVE LOck bY a subsEquent caLl to
** sQLite3OsLock().
*/
#defiNE NO_LOCK         0
#define shAred_LocK     1
#deFinE RESERVED_LOcK   2
#deFIne PeNDIng_LoCK    3
#DEfine eXCLUsIve_LocK  4

/*
** File Locking Notes:  (MOsTly aboUt winDows but also soMe info for UNIX)
**
** we cannot Use LOCkfIleEx() or UnlockFIleEx() On Win95/98/ME becAUse
** those FunctIons are nOt availabLE.  so we use oNly locKFiLe() aND
** unLockFile().
**
** LockFILE() preVeNts not jUst Writing But AlsO reAdiNg By other prOcesses.
** A sHaReD_lOcK iS obtaINed by locKiNg a SiNglE randOMly-choSen 
** byTe ouT oF a SPecIfic ranGE oF BYtes. thE lOck bYte Is ObtaiNed aT 
** RanDom so twO separate ReaDErs cAn PrObably aCcess the file aT tHe 
** same time, UnLesS they aRE
" 
** spelled backwards. So the tem p fil esare  s till  ide ntified, but
* *  any body smart enough to f igure  o u t th e  c ode i s alsol ik e l y s ma rt 
**  e n ou gh to  kn ow that  calling t hede veloper will no t help get  ri d
** of thefil e.
*/#i fnd e f SQL ITE _TEMP _FILE_ P REFIX# defineSQ L ITE_TE M P_FILE_ P R EF IX " etilqs_"
#endif
/ ** * The followin g valu es ma y bepas sed as the  s econd argumen t  t o * * s q lite3OsLock() . The vario u s l ocks e xh ibi t  the f ollow in g  se mantics:
** 
**SHARED:   Anyn umber o f  proces ses ma y h old  a S H AR ED  lo ck sim u lt ane o usl y.
** RE SE RV ED: A si n g l e  pro ces s ma y hol d a RESERVEDloc k on a f ile a t
**        any ti me. O th er processes ma y ho ld and ob tai nnew  S HARED locks. 
**  PE NDING:  A sin g lepr o c e ss  may hold a PENDIN Gl o ck  on a fi le at* *        an y o ne t i m e. Ex isti n gSHARED l ocks m a ype rsist,bu t no n ew 
**          S HAREDlocks ma y beo btained by oth e r processes.* *E X CL U SIVE : A n EXCLUSIVE  loc k  pre clud e sall other  lock s. ** ** PENDING_LOCK may  n ot bepasse d directly to  sqlite3Os L o c k(). Ins tead ,  a ** process tha t req uests an E X CLUSIVElockmay actu ally obta i n  a PENDI NG**loc k.T h is  can be upgra d e d to  a n EXCLU SIV E lockbya s ubs equ en t call to 
** sqli te 3O sL oc k() .
*/# define N O_ LOC K      0 
#defi ne SH ARED _L OC K     1
#de f in e RESE RV ED _LOC K  2 
#def ineP END ING_LOC K    3
#d efi n e EX CL US IVE_LOC K  4

/*
** F il e LockingNo tes :  (Mo s t ly about  windows but also somei nfo for  Un ix)
* *
**  We canno t u se Loc kFi l eEx()or Unl ockFi le Ex( ) on Wi n 9 5/ 98/ ME  because
* * tho se fu nc tion s are n ot available.  Sow e u se only LockF ile () a n d 
* * U n lo c kFi le ( ).* * 
** LockFile()prevents n ot ju st writing but  a lso rea ding by  othe r  proces ses.
** A  SHARED_L OC K is o bta ined by lo cking asingle ra n domly - ch osen
**  byteou t o f a s pecifi c  ra nge o f byte s.  The l ock b yt e is obt ained at 
** random sotwo se parat e r eaders ca n p r oba bly acces s th e file atthe  
* * sam e t i me, u nles s  t hey are
" 
**_spelled backwards._ So the temp_files are_still_identified, but
**_anybody_smart enough to_figure out the_code is also likely_smart
** enough to_know_that calling the developer will not help get rid
** of the file.
*/
#ifndef SQLITE_TEMP_FILE_PREFIX
# define_SQLITE_TEMP_FILE_PREFIX_"etilqs_"
#endif

/*
** The_following_values_may be passed as the_second argument to
** sqlite3OsLock(). The_various locks_exhibit the following semantics:
**
** SHARED:   _Any_number of processes_may hold a SHARED lock simultaneously.
** RESERVED:  A_single process may hold a RESERVED_lock on a_file_at
**_   _     _ any time. Other processes may_hold and obtain new SHARED locks.
** PENDING:_  A single process may_hold a PENDING lock on_a file_at
**    _  _ _  any_one time. Existing SHARED locks may_persist, but no_new
**     __  ___SHARED locks_may be obtained_by_other processes.
**_EXCLUSIVE:_An EXCLUSIVE lock precludes all other_locks.
**
**_PENDING_LOCK may not be passed directly to_sqlite3OsLock(). Instead, a
** process_that_requests an EXCLUSIVE lock_may actually obtain a PENDING
**_lock. This can be upgraded to_an EXCLUSIVE_lock by_a subsequent call to
** sqlite3OsLock().
*/
#define NO_LOCK     _   0
#define SHARED_LOCK _   1
#define_RESERVED_LOCK __2
#define PENDING_LOCK __ 3
#define_EXCLUSIVE_LOCK  4

/*
** File Locking Notes: _(Mostly about_windows but also some info for_Unix)
**
** We cannot use_LockFileEx()_or UnlockFileEx() on Win95/98/ME because
** those_functions are not available.  So_we use only LockFile() and
**_UnlockFile().
**
**_LockFile()_prevents not just writing but_also reading by other processes.
** A_SHARED_LOCK is obtained_by locking a single randomly-chosen 
** byte_out_of a specific range of bytes._The_lock byte is obtained at 
**_random_so_two separate readers can probably_access the file at the 
**_same time, unless they are