-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1
-C Remove\sfrom\sthe\sTCL\sinterface\ssome\sold\scode\sassociated\swith\ssqlite3_analyzer.
-D 2009-11-10T01:13:25
+C Remove\sthe\sobsolete\s"$Id:$"\sRCS\sidentifier\sstrings\sfrom\sthe\ssource\scode.
+D 2009-11-10T01:30:53
F Makefile.arm-wince-mingw32ce-gcc fcd5e9cd67fe88836360bb4f9ef4cb7f8e2fb5a0
-F Makefile.in a77dfde96ad86aafd3f71651a4333a104debe86a
+F Makefile.in b24a5d5f12bd6035d120c15f5e78e5d60ee4dd28
F Makefile.linux-gcc d53183f4aa6a9192d249731c90dbdffbd2c68654
F Makefile.vxworks 10010ddbf52e2503c7c49c7c0b7c7a096f8638a6
F README cd04a36fbc7ea56932a4052d7d0b7f09f27c33d6
F ext/icu/icu.c 12e763d288d23b5a49de37caa30737b971a2f1e2
F ext/icu/sqliteicu.h 728867a802baa5a96de7495e9689a8e01715ef37
F ext/rtree/README 6315c0d73ebf0ec40dedb5aa0e942bc8b54e3761
-F ext/rtree/rtree.c 5275d8f851c366f4a01e8a0c63aa0af492567f28
+F ext/rtree/rtree.c 038d59b05783c2e6c927a7352bb118a76c31065a
F ext/rtree/rtree.h 834dbcb82dc85b2481cde6a07cdadfddc99e9b9e
-F ext/rtree/rtree1.test 207041aba07fdcdd93aa797a745839d305181857
-F ext/rtree/rtree2.test 9ac9d28fa948779df66916c67a5dcf9704c3cb74
-F ext/rtree/rtree3.test 877a09c1a0c2b87af0f94f3a286e7dd3b65adf22
-F ext/rtree/rtree4.test 11724f766a74f48710998cdd7552cec140c55bf9
-F ext/rtree/rtree5.test 7d0643482829038f0263881ddf7e2d51bff1d60f
-F ext/rtree/rtree6.test 119d991e8651fb1dbb1fa31af67ad280fbe4adf7
-F ext/rtree/rtree_perf.tcl 0fabb6d5c48cb8024e042ce5d4bb88998b6ec1cb
-F ext/rtree/rtree_util.tcl ee0a0311eb12175319d78bfb37302320496cee6e
-F ext/rtree/tkt3363.test 6662237ea75bb431cd5d262dfc9535e1023315fc
-F ext/rtree/viewrtree.tcl 09526398dae87a5a87c5aac2b3854dbaf8376869
+F ext/rtree/rtree1.test f72885ed80a329d6bd7991043016d74b51edf2c5
+F ext/rtree/rtree2.test 7b665c44d25e51b3098068d983a39902b2e2d7a1
+F ext/rtree/rtree3.test dece988c363368af8c11862995c762071894918f
+F ext/rtree/rtree4.test 94fdd570ab5bc47244d87d4590023be43ac786bd
+F ext/rtree/rtree5.test 92508f5152a50110af6551fa5b769d1bbd7c4ef3
+F ext/rtree/rtree6.test 11aade5311789068ca659be24a47cc0d852b1971
+F ext/rtree/rtree_perf.tcl 6c18c1f23cd48e0f948930c98dfdd37dfccb5195
+F ext/rtree/rtree_util.tcl 06aab2ed5b826545bf215fff90ecb9255a8647ea
+F ext/rtree/tkt3363.test 2bf324f7908084a5f463de3109db9c6e607feb1b
+F ext/rtree/viewrtree.tcl eea6224b3553599ae665b239bd827e182b466024
F install-sh 9d4de14ab9fb0facae2f48780b874848cbf2f895
F ltmain.sh 3ff0879076df340d2e23ae905484d8c15d5fdea8
F main.mk d588eab5d51b0bfe924a1cccdfdd2cbb4cbe40b4
F sqlite.pc.in 42b7bf0d02e08b9e77734a47798d1a55a9e0716b
F sqlite3.1 6be1ad09113570e1fc8dcaff84c9b0b337db5ffc
F sqlite3.pc.in ae6f59a76e862f5c561eb32a380228a02afc3cad
-F src/alter.c 9e4b52e6b1d3a26242cf2ce680c9fce801f00aa1
-F src/analyze.c 5a8b8aa3d170eac5e71af45458cec61f83c623ee
-F src/attach.c 1f2ae6ca3de365c8e959f1d56beb6af589fef75b
-F src/auth.c a5471a6951a18f79d783da34be22cd94dfbe603a
-F src/backup.c 6f1c2d9862c8a3feb7739dfcca02c1f5352e37f3
-F src/bitvec.c ed215b95734045e58358c3b3e16448f8fe6a235a
-F src/btmutex.c 0f43a75bb5b8147b386e8e1c3e71ba734e3863b7
-F src/btree.c 3b29423f08987bddeb115562d6a699b002f653ae
-F src/btree.h 577448a890c2ab9b21e6ab74f073526184bceebe
-F src/btreeInt.h 1c863e543bb55772fa8db95535c370bb386c578c
-F src/build.c 3c5762687d0554ebe8844dfaddb828fcc15fe16d
-F src/callback.c 10d237171472865f58fb07d515737238c9e06688
-F src/complete.c 5ad5c6cd4548211867c204c41a126d73a9fbcea0
-F src/date.c 657ff12ca0f1195b531561afacbb38b772d16638
-F src/delete.c 308e300d599d2d11b838687e2cf7309d42f29a1a
+F src/alter.c 92ba938565d7cc6bfe92aad6cc90c00800ff21d3
+F src/analyze.c 55155f05ee9ab4ce33b7a4d19c449053f8935200
+F src/attach.c 0ba38b38252a34bb9721de35514a1d14058a8e49
+F src/auth.c 523da7fb4979469955d822ff9298352d6b31de34
+F src/backup.c 744e98359dfc79fed43e8dec911e33e108b06aae
+F src/bitvec.c 06ad2c36a9c3819c0b9cbffec7b15f58d5d834e0
+F src/btmutex.c 96a12f50f7a17475155971a241d85ec5171573ff
+F src/btree.c daf0129735fed8541f8233288ed21223cd80294f
+F src/btree.h ddd915fd44fea35f98b5505513f6a40a3308c7a6
+F src/btreeInt.h 54f4245decd0409ea52cf9aee422d3d761d7ac10
+F src/build.c a48e74d24897100017d39ceba5de255e53ec9488
+F src/callback.c 908f3e0172c3d4058f4ca0acd42c637c52e9669f
+F src/complete.c 77016e5a2766cf8b84381397152d2c99ea4b218f
+F src/date.c a79c0a8f219370b972e320741f995a3bef9df33f
+F src/delete.c ec04635d152debdab70d4b30c5516b59282075ea
F src/expr.c 11c163003b79f38a5b5100228052aca57b454807
-F src/fault.c dc88c821842157460750d2d61a8a8b4197d047ff
+F src/fault.c 160a0c015b6c2629d3899ed2daf63d75754a32bb
F src/fkey.c 41219cba186bcf0a053e42327dfa23aaba4f834a
F src/func.c e536218d193b8d326aab91120bc4c6f28aa2b606
F src/global.c 271952d199a8cc59d4ce840b3bbbfd2f30c8ba32
-F src/hash.c ebcaa921ffd9d86f7ea5ae16a0a29d1c871130a7
-F src/hash.h 35b216c13343d0b4f87d9f21969ac55ad72174e1
-F src/hwtime.h 4a1d45f4cae1f402ea19686acf24acf4f0cb53cb
-F src/insert.c 2fe2ef7bd03d6e0120e4525727c4ae7de5a2d571
-F src/journal.c e00df0c0da8413ab6e1bb7d7cab5665d4a9000d0
-F src/legacy.c 303b4ffcf1ae652fcf5ef635846c563c254564f6
+F src/hash.c 458488dcc159c301b8e7686280ab209f1fb915af
+F src/hash.h 2894c932d84d9f892d4b4023a75e501f83050970
+F src/hwtime.h d32741c8f4df852c7d959236615444e2b1063b08
+F src/insert.c f9c6098988675ac258b2f98ea5f7e370fc9990fa
+F src/journal.c b0ea6b70b532961118ab70301c00a33089f9315c
+F src/legacy.c 9304428e71b1d622b764913e1432e69156814755
F src/lempar.c 7f026423f4d71d989e719a743f98a1cbd4e6d99e
-F src/loadext.c 0e88a335665db0b2fb4cece3e49dcb65d832635a
+F src/loadext.c 1c7a61ce1281041f437333f366a96aa0d29bb581
F src/main.c aae32d5af35b88faff0664e0f937ee7133d77c8d
-F src/malloc.c 685561d2f1602042e349aea5d7a88c3f10a63454
-F src/mem0.c f2f84062d1f35814d6535c9f9e33de3bfb3b132c
-F src/mem1.c e6d5c23941288df8191b8a98c28e3f57771e2270
-F src/mem2.c d02bd6a5b34f2d59012a852615621939d9c09548
-F src/mem3.c 805ab642adfafa171781a5d8ab112119dfaef118
+F src/malloc.c 5fa175797f982b178eaf38afba9c588a866be729
+F src/mem0.c 6a55ebe57c46ca1a7d98da93aaa07f99f1059645
+F src/mem1.c 552f7e11486272f27948d2de9c012884d1f52908
+F src/mem2.c 3f196f6fd3f4320035eb4acbe4530686da2f14b1
+F src/mem3.c 9b237d911ba9904142a804be727cc6664873f8a3
F src/mem5.c 4837b795ebdecc0cfe1522cd0c8b2c5d84ea490d
-F src/memjournal.c e68cb5f7e828b84d5bf2ea16c5d87f1ed7e9fe7f
-F src/mutex.c 828a40bc7bf79f01ef95ccbf8db8b02857739449
-F src/mutex.h 32ddef38560ce0128d7e7b3eb063f5c6eff889a3
-F src/mutex_noop.c f5a07671f25a1a9bd7c10ad7107bc2585446200f
-F src/mutex_os2.c 6b5a74f812082a8483c3df05b47bbaac2424b9a0
-F src/mutex_unix.c aff26c77f698b552becfedfa677ad1036c42d790
-F src/mutex_w32.c b2c1481ee93b0ac7a8fa5346570fd173b6763fdb
-F src/notify.c 0127121816d8a861deb0dfd111b495346bf233db
-F src/os.c 8d62d8d98ad7909cb0dd294c1e5f3835c887ccb6
-F src/os.h 00a1334a4eecee7f7bef79ac606b88d325119f21
-F src/os_common.h 8c61457df58f1a4bd5f5adc3e90e01b37bf7afbc
-F src/os_os2.c bed77dc26e3a95ce4a204936b9a1ca6fe612fcc5
+F src/memjournal.c 5bfc2f33c914946e2f77ed3f882aff14dfc9355d
+F src/mutex.c 581a272e09098040ca3ef543cb5f3d643eff7d50
+F src/mutex.h 6fde601e55fa6c3fae768783c439797ab84c87c6
+F src/mutex_noop.c 5f58eaa31f2d742cb8957a747f7887ae98f16053
+F src/mutex_os2.c 63b3ea41209297c2fb8950ba465e66a5922e2926
+F src/mutex_unix.c 04a25238abce7e3d06b358dcf706e26624270809
+F src/mutex_w32.c 9ec75bcef0ca722821be7968c320fd725abfb984
+F src/notify.c f799bbda67ab6619b36b0a24153b49518874a203
+F src/os.c 1914b48263fe137d9f50985ab18e8073e6ab99c4
+F src/os.h 534b082c3cb349ad05fa6fa0b06087e022af282c
+F src/os_common.h 240c88b163b02c21a9f21f87d49678a0aa21ff30
+F src/os_os2.c 75a8c7b9a00a2cf1a65f9fa4afbc27d46634bb2f
F src/os_unix.c bdd6ca0932dcb51c344081aff430bcc71c14db7f
F src/os_win.c 5ffab20249a61e0625f869efe157fa009747039b
-F src/pager.c c7c20ff0023c6af588b1176f690fdb2d037a6470
-F src/pager.h 11852d044c86cf5a9d6e34171fb0c4fcf1f6265f
-F src/parse.y 0204f0dfe8974dc2a0d46eb9ab98a433a1f963d6
-F src/pcache.c c92ffd4f3e1279b3766854c6d18b5bf4aac0d1fa
-F src/pcache.h 435ef324197f79391f9c92b71d7f92b548ad7a36
-F src/pcache1.c 211295a9ff6a5b30f1ca50516731a5cf3e9bf82c
-F src/pragma.c c25d0d15dd0bbc5ec34e9760629353358705a447
-F src/prepare.c 665d52303135833c53b9be03e68533e249e1de54
-F src/printf.c 508a1c59433353552b6553cba175eaa7331f8fc1
-F src/random.c 676b9d7ac820fe81e6fb2394ac8c10cff7f38628
-F src/resolve.c f263d685bf21d0707b595455e0a0c95a3f5398f6
-F src/rowset.c c64dafba1f9fd876836c8db8682966b9d197eb1f
-F src/select.c cbe366a0ce114856e66f5daf0f848d7c48a88298
-F src/shell.c 07e6265ead0dc517c242276949d5a262ca8a87a7
+F src/pager.c e31b8fc35cd1a07edcb5770aaac77b81b8659c99
+F src/pager.h 1b32faf2e578ac3e7bcf9c9d11217128261c5c54
+F src/parse.y 0a36c62c090e7e5bb2e36f66909cf4a42c025e1b
+F src/pcache.c 3b079306376e0e04c0d3df40c0a4b750a1839310
+F src/pcache.h c683390d50f856d4cd8e24342ae62027d1bb6050
+F src/pcache1.c db4a996e456eec2380732a1036e23e3f551f6573
+F src/pragma.c 97031c9f38e4ad09b92e19e698e3c26a54370591
+F src/prepare.c ad90970bba3aead154266d8bb6faf9fbb5233b94
+F src/printf.c 03fabdd6112a0e23f78f8ac9a1396947ade0273b
+F src/random.c cd4a67b3953b88019f8cd4ccd81394a8ddfaba50
+F src/resolve.c aa3cb21e1ecd905c071fce8fb64d1a166cefc239
+F src/rowset.c 69afa95a97c524ba6faf3805e717b5b7ae85a697
+F src/select.c ecd7fb2fcb8d207dd381338377b5bacce0b38a2d
+F src/shell.c 0167e247ded3e6358a083c75f12468e6327be990
F src/sqlite.h.in 4464e9772122f0447305d425e04d122b6f1bffec
-F src/sqlite3ext.h 1db7d63ab5de4b3e6b83dd03d1a4e64fef6d2a17
+F src/sqlite3ext.h 69dfb8116af51b84a029cddb3b35062354270c89
F src/sqliteInt.h 55d26b83d16107804693982028c8b3a075f5a836
-F src/sqliteLimit.h 285dd7140722adfa9998b9393314eaaf50215c27
-F src/status.c 237b193efae0cf6ac3f0817a208de6c6c6ef6d76
-F src/table.c cc86ad3d6ad54df7c63a3e807b5783c90411a08d
+F src/sqliteLimit.h 3afab2291762b5d09ae20c18feb8e9fa935a60a6
+F src/status.c e651be6b30d397d86384c6867bc016e4913bcac7
+F src/table.c 2cd62736f845d82200acfa1287e33feb3c15d62e
F src/tclsqlite.c 21432a361808b6c3d405710cdd22fa1b16f7b84f
-F src/test1.c 2232a39540a6b72f3be8f84b34d1ca0714f92aee
-F src/test2.c 0de743ec8890ca4f09e0bce5d6d5a681f5957fec
-F src/test3.c 2445c2beb5e7a0c91fd8136dc1339ec369a24898
-F src/test4.c b5fd530f02a6a0dbffb23be202168a690985dedd
-F src/test5.c 162a1cea2105a2c460a3f39fa6919617b562a288
-F src/test6.c 1a0a7a1f179469044b065b4a88aab9faee114101
-F src/test7.c b94e68c2236de76889d82b8d7d8e00ad6a4d80b1
-F src/test8.c 34719910286a0a6ca233f10ba66558be938494dd
-F src/test9.c 963d380922f25c1c323712d05db01b19197ee6f7
-F src/test_async.c 731d23f953ece5bf40ce87810cfb7607218953c5
-F src/test_autoext.c f53b0cdf7bf5f08100009572a5d65cdb540bd0ad
-F src/test_backup.c 1384a18985a5a2d275c2662e48473bf1542ebd08
-F src/test_btree.c 5adbba9b138988a3cf4d3b5424dbc7c85651da02
-F src/test_config.c 4ac1e6257dcf926a71b7934410b71c5c326e68f2
-F src/test_devsym.c 9f4bc2551e267ce7aeda195f3897d0f30c5228f4
-F src/test_func.c c6e9d7cfbd7bb0bd7c392a10d76adab4b48e813b
-F src/test_hexio.c 2f1122aa3f012fa0142ee3c36ce5c902a70cd12f
-F src/test_init.c f6a5dfaf2fb52d697eec1c825a641e5893c339d2
-F src/test_journal.c dab49b7c47b53242f039c9563b18cafb67ebfe03
-F src/test_loadext.c 97dc8800e46a46ed002c2968572656f37e9c0dd9
-F src/test_malloc.c d054506b095d711e4e5575558dd576a2cbf035a2
-F src/test_mutex.c 482d9d987c1c678199691efc23c8cd3464e01ff5
-F src/test_onefile.c d2c3126633592aeef14e8d268fc40c74449b69d8
-F src/test_osinst.c 9a70a61e127f9e72bcfca000b20368b1c5367873
-F src/test_pcache.c d770f933888b2afe856c1abcefc64eda5941ffef
-F src/test_schema.c 4b4bf7bb329326458c491b0e6facd4c8c4c5b479
-F src/test_server.c f0a403b5f699c09bd2b1236b6f69830fd6221f6b
-F src/test_tclvar.c 9e42fa59d3d2f064b7ab8628e7ab2dc8a9fe93d4
-F src/test_thread.c b8a1ab7ca1a632f18e8a361880d5d65eeea08eac
-F src/test_wsd.c 3ae5101de6cbfda2720152ab659ea84079719241
-F src/tokenize.c af8a56e6a50c5042fc305bfa796275e9bf26ff2b
-F src/trigger.c 2053afa9952f69cf451bc0e6ea88072701f2925e
-F src/update.c 8e8535f66c32d946199cb1caad19646a97ead3a7
-F src/utf.c 3586a6a2457c5c88b6816f6cda58a54e291883f8
-F src/util.c 59d4e9456bf1fe581f415a783fa0cee6115c8f35
-F src/vacuum.c 48e1282bbd5eac4b461587c51658378658c00770
-F src/vdbe.c a435ffcf6bfc7f14eb40998062ccbd7dfa482319
-F src/vdbe.h 449323a21c02226790acb6189dae78af17b92b78
-F src/vdbeInt.h 53b430ad3ff91bc5c963d5573299801c54cb7cba
-F src/vdbeapi.c 44b5f387459d5faa158aa8d3a26967f0c8596efd
-F src/vdbeaux.c 0fac44db16b5dc116eb1cacbe619033cb09569c3
-F src/vdbeblob.c 9bfaeab22e261a6a7b6df04e7faaf7d6dfdbef5a
-F src/vdbemem.c e86a65cb779eaae34710a6ffc0e76c9f7c1107be
-F src/vtab.c 3e54fe39374e5feb8b174de32a90e7a21966025d
-F src/walker.c 1edca756275f158b80f20eb6f104c8d3fcc96a04
-F src/where.c fac37876e09e005e52cdfcf896090b6f5ebbf25b
+F src/test1.c db4d8fd2849ab9aca0f27fd3773b8d68d078cf86
+F src/test2.c b6b43413d495addd039a88b87d65c839f86b18cb
+F src/test3.c f17eeaf8114205844d76f4e69bab27ea341087af
+F src/test4.c ad03bb987ddedce928f4258c1e7fa4109a73497d
+F src/test5.c cc55900118fa4add8ec9cf69fc4225a4662f76b1
+F src/test6.c a8ece4284d0e34477f349ac05655db73c48e0926
+F src/test7.c 3f2d63e4ccf97f8c2cf1a7fa0a3c8e2e2a354e6e
+F src/test8.c f959db9a22d882013b64c92753fa793b2ce3bdea
+F src/test9.c bea1e8cf52aa93695487badedd6e1886c321ea60
+F src/test_async.c c1656facbaf43cb2e71b62621e5b9eb080e2621c
+F src/test_autoext.c 30e7bd98ab6d70a62bb9ba572e4c7df347fe645e
+F src/test_backup.c c129c91127e9b46e335715ae2e75756e25ba27de
+F src/test_btree.c 47cd771250f09cdc6e12dda5bc71bc0b3abc96e2
+F src/test_config.c 220a67047af393756f55760fdf442d935d0d88f3
+F src/test_devsym.c de3c9af2bb9a8b1e44525c449e4ec3f88e3d4110
+F src/test_func.c 1c94388a23d4a9e7cd62ec79d612d1bae2451fa2
+F src/test_hexio.c 1c0f4238c6fb36c890ce7c07d9c8e1cecedad9ad
+F src/test_init.c 5d624ffd0409d424cf9adbfe1f056b200270077c
+F src/test_journal.c adc0ce3840ed19b49feb1d583b2212f560ef7866
+F src/test_loadext.c df586c27176e3c2cb2e099c78da67bf14379a56e
+F src/test_malloc.c f777d15df756bea0e98271932464ac5d882e66fe
+F src/test_mutex.c ce06b59aca168cd8c520b77159a24352a7469bd3
+F src/test_onefile.c 06da7e085dce42924cf062b91763dd4bb84c6101
+F src/test_osinst.c 90fb03d396f39956897dfb4bd0e62c6711db1cca
+F src/test_pcache.c 7bf828972ac0d2403f5cfa4cd14da41f8ebe73d8
+F src/test_schema.c 8c06ef9ddb240c7a0fcd31bc221a6a2aade58bf0
+F src/test_server.c bbba05c144b5fc4b52ff650a4328027b3fa5fcc6
+F src/test_tclvar.c 0e50b7656bda33cf520da64e5069f35ae30aecab
+F src/test_thread.c 00fed80690ae7f1525483a35861511c48bc579f2
+F src/test_wsd.c 41cadfd9d97fe8e3e4e44f61a4a8ccd6f7ca8fe9
+F src/tokenize.c 216645750533c9396c99b057d8997a125331d50b
+F src/trigger.c 3c48db13db94f3c34b01b7caae2130279c8f4d28
+F src/update.c 8efeb09822886e33c265dd96d29a3d865ea6dcf2
+F src/utf.c dad16adcc0c35ef2437dca125a4b07419d361052
+F src/util.c ad4f03079ba0fe83590d1cc9197e8e4844e38592
+F src/vacuum.c 03309a08d549f9389cc3a3589afd4fadbdaf0679
+F src/vdbe.c 7e112c50e50d3b86f752bca563ef9369a3d8a471
+F src/vdbe.h 7b06b21f76e349bc2b7e18599550d79bf943c940
+F src/vdbeInt.h 59c65e7b810836b9e946acee45c7b3c02b967d1b
+F src/vdbeapi.c 17680ab7a75ec938c5ba039a6c87489d01faf2cb
+F src/vdbeaux.c e85c8c7dc63b8e8941afe445a708bd188e5f9ba9
+F src/vdbeblob.c 84f924700a7a889152aeebef77ca5f4e3875ffb4
+F src/vdbemem.c eeb5988d4cb61130ad9d28ad4422b93fc9199856
+F src/vtab.c 456fc226614569f0e46f216e33265bea268bd917
+F src/walker.c 3112bb3afe1d85dc52317cb1d752055e9a781f8f
+F src/where.c 29d3324010a1f8a5e92372dc7b544405bf319e30
F test/aggerror.test a867e273ef9e3d7919f03ef4f0e8c0d2767944f2
F test/alias.test 4529fbc152f190268a15f9384a5651bbbabc9d87
F test/all.test 14165b3e32715b700b5f0cbf8f6e3833dda0be45
F tool/speedtest8.c 2902c46588c40b55661e471d7a86e4dd71a18224
F tool/speedtest8inst1.c 293327bc76823f473684d589a8160bde1f52c14e
F tool/vdbe-compress.tcl d70ea6d8a19e3571d7ab8c9b75cba86d1173ff0f
-P 5a9e746357aa8edeef6b89f01e19cd57555bef32
-R 04f0ccc70967e16360ae869df51644e9
+P 01f2271e51751ff66061f65556a5e324f243756a
+R 56718e6d4b1d63d5a69c5734835fad31
U drh
-Z 8cf10c7bec8947796a5c5b231a566501
+Z 9b46296a371f31caf3813c1fee91cc7f
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.6 (GNU/Linux)
-iD8DBQFK+L44oxKgR168RlERAvi3AJ46N9OkpanfHBR53gc4eS0f9BzZKACfYz8R
-2KvfKa+fMr0laifXlNXWvsA=
-=ZXoW
+iD8DBQFK+MJQoxKgR168RlERAsjEAJ43LxniUPRfWb2JQ4V9offsR34KtgCfetYp
+fcOHVA2EHM4HQPen81kSKeQ=
+=zFf1
-----END PGP SIGNATURE-----
-/*\r
-** 2001 September 15\r
-**\r
-** The author disclaims copyright to this source code. In place of\r
-** a legal notice, here is a blessing:\r
-**\r
-** May you do good and not evil.\r
-** May you find forgiveness for yourself and forgive others.\r
-** May you share freely, never taking more than you give.\r
-**\r
-*************************************************************************\r
-** Utility functions used throughout sqlite.\r
-**\r
-** This file contains functions for allocating memory, comparing\r
-** strings, and stuff like that.\r
-**\r
-*/\r
-#include "sqliteInt.h"\r
-#include <stdarg.h>\r
-#ifdef SQLITE_HAVE_ISNAN\r
-# include <math.h>\r
-#endif\r
-\r
-/*\r
-** Routine needed to support the testcase() macro.\r
-*/\r
-#ifdef SQLITE_COVERAGE_TEST\r
-void sqlite3Coverage(int x){\r
- static int dummy = 0;\r
- dummy += x;\r
-}\r
-#endif\r
-\r
-/*\r
-** Return true if the floating point value is Not a Number (NaN).\r
-**\r
-** Use the math library isnan() function if compiled with SQLITE_HAVE_ISNAN.\r
-** Otherwise, we have our own implementation that works on most systems.\r
-*/\r
-int sqlite3IsNaN(double x){\r
- int rc; /* The value return */\r
-#if !defined(SQLITE_HAVE_ISNAN)\r
- /*\r
- ** Systems that support the isnan() library function should probably\r
- ** make use of it by compiling with -DSQLITE_HAVE_ISNAN. But we have\r
- ** found that many systems do not have a working isnan() function so\r
- ** this implementation is provided as an alternative.\r
- **\r
- ** This NaN test sometimes fails if compiled on GCC with -ffast-math.\r
- ** On the other hand, the use of -ffast-math comes with the following\r
- ** warning:\r
- **\r
- ** This option [-ffast-math] should never be turned on by any\r
- ** -O option since it can result in incorrect output for programs\r
- ** which depend on an exact implementation of IEEE or ISO \r
- ** rules/specifications for math functions.\r
- **\r
- ** Under MSVC, this NaN test may fail if compiled with a floating-\r
- ** point precision mode other than /fp:precise. From the MSDN \r
- ** documentation:\r
- **\r
- ** The compiler [with /fp:precise] will properly handle comparisons \r
- ** involving NaN. For example, x != x evaluates to true if x is NaN \r
- ** ...\r
- */\r
-#ifdef __FAST_MATH__\r
-# error SQLite will not work correctly with the -ffast-math option of GCC.\r
-#endif\r
- volatile double y = x;\r
- volatile double z = y;\r
- rc = (y!=z);\r
-#else /* if defined(SQLITE_HAVE_ISNAN) */\r
- rc = isnan(x);\r
-#endif /* SQLITE_HAVE_ISNAN */\r
- testcase( rc );\r
- return rc;\r
-}\r
-\r
-/*\r
-** Compute a string length that is limited to what can be stored in\r
-** lower 30 bits of a 32-bit signed integer.\r
-**\r
-** The value returned will never be negative. Nor will it ever be greater\r
-** than the actual length of the string. For very long strings (greater\r
-** than 1GiB) the value returned might be less than the true string length.\r
-*/\r
-int sqlite3Strlen30(const char *z){\r
- const char *z2 = z;\r
- if( z==0 ) return 0;\r
- while( *z2 ){ z2++; }\r
- return 0x3fffffff & (int)(z2 - z);\r
-}\r
-\r
-/*\r
-** Set the most recent error code and error string for the sqlite\r
-** handle "db". The error code is set to "err_code".\r
-**\r
-** If it is not NULL, string zFormat specifies the format of the\r
-** error string in the style of the printf functions: The following\r
-** format characters are allowed:\r
-**\r
-** %s Insert a string\r
-** %z A string that should be freed after use\r
-** %d Insert an integer\r
-** %T Insert a token\r
-** %S Insert the first element of a SrcList\r
-**\r
-** zFormat and any string tokens that follow it are assumed to be\r
-** encoded in UTF-8.\r
-**\r
-** To clear the most recent error for sqlite handle "db", sqlite3Error\r
-** should be called with err_code set to SQLITE_OK and zFormat set\r
-** to NULL.\r
-*/\r
-void sqlite3Error(sqlite3 *db, int err_code, const char *zFormat, ...){\r
- if( db && (db->pErr || (db->pErr = sqlite3ValueNew(db))!=0) ){\r
- db->errCode = err_code;\r
- if( zFormat ){\r
- char *z;\r
- va_list ap;\r
- va_start(ap, zFormat);\r
- z = sqlite3VMPrintf(db, zFormat, ap);\r
- va_end(ap);\r
- sqlite3ValueSetStr(db->pErr, -1, z, SQLITE_UTF8, SQLITE_DYNAMIC);\r
- }else{\r
- sqlite3ValueSetStr(db->pErr, 0, 0, SQLITE_UTF8, SQLITE_STATIC);\r
- }\r
- }\r
-}\r
-\r
-/*\r
-** Add an error message to pParse->zErrMsg and increment pParse->nErr.\r
-** The following formatting characters are allowed:\r
-**\r
-** %s Insert a string\r
-** %z A string that should be freed after use\r
-** %d Insert an integer\r
-** %T Insert a token\r
-** %S Insert the first element of a SrcList\r
-**\r
-** This function should be used to report any error that occurs whilst\r
-** compiling an SQL statement (i.e. within sqlite3_prepare()). The\r
-** last thing the sqlite3_prepare() function does is copy the error\r
-** stored by this function into the database handle using sqlite3Error().\r
-** Function sqlite3Error() should be used during statement execution\r
-** (sqlite3_step() etc.).\r
-*/\r
-void sqlite3ErrorMsg(Parse *pParse, const char *zFormat, ...){\r
- va_list ap;\r
- sqlite3 *db = pParse->db;\r
- pParse->nErr++;\r
- sqlite3DbFree(db, pParse->zErrMsg);\r
- va_start(ap, zFormat);\r
- pParse->zErrMsg = sqlite3VMPrintf(db, zFormat, ap);\r
- va_end(ap);\r
- pParse->rc = SQLITE_ERROR;\r
-}\r
-\r
-/*\r
-** Clear the error message in pParse, if any\r
-*/\r
-void sqlite3ErrorClear(Parse *pParse){\r
- sqlite3DbFree(pParse->db, pParse->zErrMsg);\r
- pParse->zErrMsg = 0;\r
- pParse->nErr = 0;\r
-}\r
-\r
-/*\r
-** Convert an SQL-style quoted string into a normal string by removing\r
-** the quote characters. The conversion is done in-place. If the\r
-** input does not begin with a quote character, then this routine\r
-** is a no-op.\r
-**\r
-** The input string must be zero-terminated. A new zero-terminator\r
-** is added to the dequoted string.\r
-**\r
-** The return value is -1 if no dequoting occurs or the length of the\r
-** dequoted string, exclusive of the zero terminator, if dequoting does\r
-** occur.\r
-**\r
-** 2002-Feb-14: This routine is extended to remove MS-Access style\r
-** brackets from around identifers. For example: "[a-b-c]" becomes\r
-** "a-b-c".\r
-*/\r
-int sqlite3Dequote(char *z){\r
- char quote;\r
- int i, j;\r
- if( z==0 ) return -1;\r
- quote = z[0];\r
- switch( quote ){\r
- case '\'': break;\r
- case '"': break;\r
- case '`': break; /* For MySQL compatibility */\r
- case '[': quote = ']'; break; /* For MS SqlServer compatibility */\r
- default: return -1;\r
- }\r
- for(i=1, j=0; ALWAYS(z[i]); i++){\r
- if( z[i]==quote ){\r
- if( z[i+1]==quote ){\r
- z[j++] = quote;\r
- i++;\r
- }else{\r
- break;\r
- }\r
- }else{\r
- z[j++] = z[i];\r
- }\r
- }\r
- z[j] = 0;\r
- return j;\r
-}\r
-\r
-/* Convenient short-hand */\r
-#define UpperToLower sqlite3UpperToLower\r
-\r
-/*\r
-** Some systems have stricmp(). Others have strcasecmp(). Because\r
-** there is no consistency, we will define our own.\r
-*/\r
-int sqlite3StrICmp(const char *zLeft, const char *zRight){\r
- register unsigned char *a, *b;\r
- a = (unsigned char *)zLeft;\r
- b = (unsigned char *)zRight;\r
- while( *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; }\r
- return UpperToLower[*a] - UpperToLower[*b];\r
-}\r
-int sqlite3_strnicmp(const char *zLeft, const char *zRight, int N){\r
- register unsigned char *a, *b;\r
- a = (unsigned char *)zLeft;\r
- b = (unsigned char *)zRight;\r
- while( N-- > 0 && *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; }\r
- return N<0 ? 0 : UpperToLower[*a] - UpperToLower[*b];\r
-}\r
-\r
-/*\r
-** Return TRUE if z is a pure numeric string. Return FALSE and leave\r
-** *realnum unchanged if the string contains any character which is not\r
-** part of a number.\r
-**\r
-** If the string is pure numeric, set *realnum to TRUE if the string\r
-** contains the '.' character or an "E+000" style exponentiation suffix.\r
-** Otherwise set *realnum to FALSE. Note that just becaue *realnum is\r
-** false does not mean that the number can be successfully converted into\r
-** an integer - it might be too big.\r
-**\r
-** An empty string is considered non-numeric.\r
-*/\r
-int sqlite3IsNumber(const char *z, int *realnum, u8 enc){\r
- int incr = (enc==SQLITE_UTF8?1:2);\r
- if( enc==SQLITE_UTF16BE ) z++;\r
- if( *z=='-' || *z=='+' ) z += incr;\r
- if( !sqlite3Isdigit(*z) ){\r
- return 0;\r
- }\r
- z += incr;\r
- *realnum = 0;\r
- while( sqlite3Isdigit(*z) ){ z += incr; }\r
- if( *z=='.' ){\r
- z += incr;\r
- if( !sqlite3Isdigit(*z) ) return 0;\r
- while( sqlite3Isdigit(*z) ){ z += incr; }\r
- *realnum = 1;\r
- }\r
- if( *z=='e' || *z=='E' ){\r
- z += incr;\r
- if( *z=='+' || *z=='-' ) z += incr;\r
- if( !sqlite3Isdigit(*z) ) return 0;\r
- while( sqlite3Isdigit(*z) ){ z += incr; }\r
- *realnum = 1;\r
- }\r
- return *z==0;\r
-}\r
-\r
-/*\r
-** The string z[] is an ASCII representation of a real number.\r
-** Convert this string to a double.\r
-**\r
-** This routine assumes that z[] really is a valid number. If it\r
-** is not, the result is undefined.\r
-**\r
-** This routine is used instead of the library atof() function because\r
-** the library atof() might want to use "," as the decimal point instead\r
-** of "." depending on how locale is set. But that would cause problems\r
-** for SQL. So this routine always uses "." regardless of locale.\r
-*/\r
-int sqlite3AtoF(const char *z, double *pResult){\r
-#ifndef SQLITE_OMIT_FLOATING_POINT\r
- const char *zBegin = z;\r
- /* sign * significand * (10 ^ (esign * exponent)) */\r
- int sign = 1; /* sign of significand */\r
- i64 s = 0; /* significand */\r
- int d = 0; /* adjust exponent for shifting decimal point */\r
- int esign = 1; /* sign of exponent */\r
- int e = 0; /* exponent */\r
- double result;\r
- int nDigits = 0;\r
-\r
- /* skip leading spaces */\r
- while( sqlite3Isspace(*z) ) z++;\r
- /* get sign of significand */\r
- if( *z=='-' ){\r
- sign = -1;\r
- z++;\r
- }else if( *z=='+' ){\r
- z++;\r
- }\r
- /* skip leading zeroes */\r
- while( z[0]=='0' ) z++, nDigits++;\r
-\r
- /* copy max significant digits to significand */\r
- while( sqlite3Isdigit(*z) && s<((LARGEST_INT64-9)/10) ){\r
- s = s*10 + (*z - '0');\r
- z++, nDigits++;\r
- }\r
- /* skip non-significant significand digits\r
- ** (increase exponent by d to shift decimal left) */\r
- while( sqlite3Isdigit(*z) ) z++, nDigits++, d++;\r
-\r
- /* if decimal point is present */\r
- if( *z=='.' ){\r
- z++;\r
- /* copy digits from after decimal to significand\r
- ** (decrease exponent by d to shift decimal right) */\r
- while( sqlite3Isdigit(*z) && s<((LARGEST_INT64-9)/10) ){\r
- s = s*10 + (*z - '0');\r
- z++, nDigits++, d--;\r
- }\r
- /* skip non-significant digits */\r
- while( sqlite3Isdigit(*z) ) z++, nDigits++;\r
- }\r
-\r
- /* if exponent is present */\r
- if( *z=='e' || *z=='E' ){\r
- z++;\r
- /* get sign of exponent */\r
- if( *z=='-' ){\r
- esign = -1;\r
- z++;\r
- }else if( *z=='+' ){\r
- z++;\r
- }\r
- /* copy digits to exponent */\r
- while( sqlite3Isdigit(*z) ){\r
- e = e*10 + (*z - '0');\r
- z++;\r
- }\r
- }\r
-\r
- /* adjust exponent by d, and update sign */\r
- e = (e*esign) + d;\r
- if( e<0 ) {\r
- esign = -1;\r
- e *= -1;\r
- } else {\r
- esign = 1;\r
- }\r
-\r
- /* if 0 significand */\r
- if( !s ) {\r
- /* In the IEEE 754 standard, zero is signed.\r
- ** Add the sign if we've seen at least one digit */\r
- result = (sign<0 && nDigits) ? -(double)0 : (double)0;\r
- } else {\r
- /* attempt to reduce exponent */\r
- if( esign>0 ){\r
- while( s<(LARGEST_INT64/10) && e>0 ) e--,s*=10;\r
- }else{\r
- while( !(s%10) && e>0 ) e--,s/=10;\r
- }\r
-\r
- /* adjust the sign of significand */\r
- s = sign<0 ? -s : s;\r
-\r
- /* if exponent, scale significand as appropriate\r
- ** and store in result. */\r
- if( e ){\r
- double scale = 1.0;\r
- /* attempt to handle extremely small/large numbers better */\r
- if( e>307 && e<342 ){\r
- while( e%308 ) { scale *= 1.0e+1; e -= 1; }\r
- if( esign<0 ){\r
- result = s / scale;\r
- result /= 1.0e+308;\r
- }else{\r
- result = s * scale;\r
- result *= 1.0e+308;\r
- }\r
- }else{\r
- /* 1.0e+22 is the largest power of 10 than can be \r
- ** represented exactly. */\r
- while( e%22 ) { scale *= 1.0e+1; e -= 1; }\r
- while( e>0 ) { scale *= 1.0e+22; e -= 22; }\r
- if( esign<0 ){\r
- result = s / scale;\r
- }else{\r
- result = s * scale;\r
- }\r
- }\r
- } else {\r
- result = (double)s;\r
- }\r
- }\r
-\r
- /* store the result */\r
- *pResult = result;\r
-\r
- /* return number of characters used */\r
- return (int)(z - zBegin);\r
-#else\r
- return sqlite3Atoi64(z, pResult);\r
-#endif /* SQLITE_OMIT_FLOATING_POINT */\r
-}\r
-\r
-/*\r
-** Compare the 19-character string zNum against the text representation\r
-** value 2^63: 9223372036854775808. Return negative, zero, or positive\r
-** if zNum is less than, equal to, or greater than the string.\r
-**\r
-** Unlike memcmp() this routine is guaranteed to return the difference\r
-** in the values of the last digit if the only difference is in the\r
-** last digit. So, for example,\r
-**\r
-** compare2pow63("9223372036854775800")\r
-**\r
-** will return -8.\r
-*/\r
-static int compare2pow63(const char *zNum){\r
- int c;\r
- c = memcmp(zNum,"922337203685477580",18)*10;\r
- if( c==0 ){\r
- c = zNum[18] - '8';\r
- }\r
- return c;\r
-}\r
-\r
-\r
-/*\r
-** Return TRUE if zNum is a 64-bit signed integer and write\r
-** the value of the integer into *pNum. If zNum is not an integer\r
-** or is an integer that is too large to be expressed with 64 bits,\r
-** then return false.\r
-**\r
-** When this routine was originally written it dealt with only\r
-** 32-bit numbers. At that time, it was much faster than the\r
-** atoi() library routine in RedHat 7.2.\r
-*/\r
-int sqlite3Atoi64(const char *zNum, i64 *pNum){\r
- i64 v = 0;\r
- int neg;\r
- int i, c;\r
- const char *zStart;\r
- while( sqlite3Isspace(*zNum) ) zNum++;\r
- if( *zNum=='-' ){\r
- neg = 1;\r
- zNum++;\r
- }else if( *zNum=='+' ){\r
- neg = 0;\r
- zNum++;\r
- }else{\r
- neg = 0;\r
- }\r
- zStart = zNum;\r
- while( zNum[0]=='0' ){ zNum++; } /* Skip over leading zeros. Ticket #2454 */\r
- for(i=0; (c=zNum[i])>='0' && c<='9'; i++){\r
- v = v*10 + c - '0';\r
- }\r
- *pNum = neg ? -v : v;\r
- if( c!=0 || (i==0 && zStart==zNum) || i>19 ){\r
- /* zNum is empty or contains non-numeric text or is longer\r
- ** than 19 digits (thus guaranting that it is too large) */\r
- return 0;\r
- }else if( i<19 ){\r
- /* Less than 19 digits, so we know that it fits in 64 bits */\r
- return 1;\r
- }else{\r
- /* 19-digit numbers must be no larger than 9223372036854775807 if positive\r
- ** or 9223372036854775808 if negative. Note that 9223372036854665808\r
- ** is 2^63. */\r
- return compare2pow63(zNum)<neg;\r
- }\r
-}\r
-\r
-/*\r
-** The string zNum represents an unsigned integer. The zNum string\r
-** consists of one or more digit characters and is terminated by\r
-** a zero character. Any stray characters in zNum result in undefined\r
-** behavior.\r
-**\r
-** If the unsigned integer that zNum represents will fit in a\r
-** 64-bit signed integer, return TRUE. Otherwise return FALSE.\r
-**\r
-** If the negFlag parameter is true, that means that zNum really represents\r
-** a negative number. (The leading "-" is omitted from zNum.) This\r
-** parameter is needed to determine a boundary case. A string\r
-** of "9223373036854775808" returns false if negFlag is false or true\r
-** if negFlag is true.\r
-**\r
-** Leading zeros are ignored.\r
-*/\r
-int sqlite3FitsIn64Bits(const char *zNum, int negFlag){\r
- int i;\r
- int neg = 0;\r
-\r
- assert( zNum[0]>='0' && zNum[0]<='9' ); /* zNum is an unsigned number */\r
-\r
- if( negFlag ) neg = 1-neg;\r
- while( *zNum=='0' ){\r
- zNum++; /* Skip leading zeros. Ticket #2454 */\r
- }\r
- for(i=0; zNum[i]; i++){ assert( zNum[i]>='0' && zNum[i]<='9' ); }\r
- if( i<19 ){\r
- /* Guaranteed to fit if less than 19 digits */\r
- return 1;\r
- }else if( i>19 ){\r
- /* Guaranteed to be too big if greater than 19 digits */\r
- return 0;\r
- }else{\r
- /* Compare against 2^63. */\r
- return compare2pow63(zNum)<neg;\r
- }\r
-}\r
-\r
-/*\r
-** If zNum represents an integer that will fit in 32-bits, then set\r
-** *pValue to that integer and return true. Otherwise return false.\r
-**\r
-** Any non-numeric characters that following zNum are ignored.\r
-** This is different from sqlite3Atoi64() which requires the\r
-** input number to be zero-terminated.\r
-*/\r
-int sqlite3GetInt32(const char *zNum, int *pValue){\r
- sqlite_int64 v = 0;\r
- int i, c;\r
- int neg = 0;\r
- if( zNum[0]=='-' ){\r
- neg = 1;\r
- zNum++;\r
- }else if( zNum[0]=='+' ){\r
- zNum++;\r
- }\r
- while( zNum[0]=='0' ) zNum++;\r
- for(i=0; i<11 && (c = zNum[i] - '0')>=0 && c<=9; i++){\r
- v = v*10 + c;\r
- }\r
-\r
- /* The longest decimal representation of a 32 bit integer is 10 digits:\r
- **\r
- ** 1234567890\r
- ** 2^31 -> 2147483648\r
- */\r
- if( i>10 ){\r
- return 0;\r
- }\r
- if( v-neg>2147483647 ){\r
- return 0;\r
- }\r
- if( neg ){\r
- v = -v;\r
- }\r
- *pValue = (int)v;\r
- return 1;\r
-}\r
-\r
-/*\r
-** The variable-length integer encoding is as follows:\r
-**\r
-** KEY:\r
-** A = 0xxxxxxx 7 bits of data and one flag bit\r
-** B = 1xxxxxxx 7 bits of data and one flag bit\r
-** C = xxxxxxxx 8 bits of data\r
-**\r
-** 7 bits - A\r
-** 14 bits - BA\r
-** 21 bits - BBA\r
-** 28 bits - BBBA\r
-** 35 bits - BBBBA\r
-** 42 bits - BBBBBA\r
-** 49 bits - BBBBBBA\r
-** 56 bits - BBBBBBBA\r
-** 64 bits - BBBBBBBBC\r
-*/\r
-\r
-/*\r
-** Write a 64-bit variable-length integer to memory starting at p[0].\r
-** The length of data write will be between 1 and 9 bytes. The number\r
-** of bytes written is returned.\r
-**\r
-** A variable-length integer consists of the lower 7 bits of each byte\r
-** for all bytes that have the 8th bit set and one byte with the 8th\r
-** bit clear. Except, if we get to the 9th byte, it stores the full\r
-** 8 bits and is the last byte.\r
-*/\r
-int sqlite3PutVarint(unsigned char *p, u64 v){\r
- int i, j, n;\r
- u8 buf[10];\r
- if( v & (((u64)0xff000000)<<32) ){\r
- p[8] = (u8)v;\r
- v >>= 8;\r
- for(i=7; i>=0; i--){\r
- p[i] = (u8)((v & 0x7f) | 0x80);\r
- v >>= 7;\r
- }\r
- return 9;\r
- } \r
- n = 0;\r
- do{\r
- buf[n++] = (u8)((v & 0x7f) | 0x80);\r
- v >>= 7;\r
- }while( v!=0 );\r
- buf[0] &= 0x7f;\r
- assert( n<=9 );\r
- for(i=0, j=n-1; j>=0; j--, i++){\r
- p[i] = buf[j];\r
- }\r
- return n;\r
-}\r
-\r
-/*\r
-** This routine is a faster version of sqlite3PutVarint() that only\r
-** works for 32-bit positive integers and which is optimized for\r
-** the common case of small integers. A MACRO version, putVarint32,\r
-** is provided which inlines the single-byte case. All code should use\r
-** the MACRO version as this function assumes the single-byte case has\r
-** already been handled.\r
-*/\r
-int sqlite3PutVarint32(unsigned char *p, u32 v){\r
-#ifndef putVarint32\r
- if( (v & ~0x7f)==0 ){\r
- p[0] = v;\r
- return 1;\r
- }\r
-#endif\r
- if( (v & ~0x3fff)==0 ){\r
- p[0] = (u8)((v>>7) | 0x80);\r
- p[1] = (u8)(v & 0x7f);\r
- return 2;\r
- }\r
- return sqlite3PutVarint(p, v);\r
-}\r
-\r
-/*\r
-** Read a 64-bit variable-length integer from memory starting at p[0].\r
-** Return the number of bytes read. The value is stored in *v.\r
-*/\r
-u8 sqlite3GetVarint(const unsigned char *p, u64 *v){\r
- u32 a,b,s;\r
-\r
- a = *p;\r
- /* a: p0 (unmasked) */\r
- if (!(a&0x80))\r
- {\r
- *v = a;\r
- return 1;\r
- }\r
-\r
- p++;\r
- b = *p;\r
- /* b: p1 (unmasked) */\r
- if (!(b&0x80))\r
- {\r
- a &= 0x7f;\r
- a = a<<7;\r
- a |= b;\r
- *v = a;\r
- return 2;\r
- }\r
-\r
- p++;\r
- a = a<<14;\r
- a |= *p;\r
- /* a: p0<<14 | p2 (unmasked) */\r
- if (!(a&0x80))\r
- {\r
- a &= (0x7f<<14)|(0x7f);\r
- b &= 0x7f;\r
- b = b<<7;\r
- a |= b;\r
- *v = a;\r
- return 3;\r
- }\r
-\r
- /* CSE1 from below */\r
- a &= (0x7f<<14)|(0x7f);\r
- p++;\r
- b = b<<14;\r
- b |= *p;\r
- /* b: p1<<14 | p3 (unmasked) */\r
- if (!(b&0x80))\r
- {\r
- b &= (0x7f<<14)|(0x7f);\r
- /* moved CSE1 up */\r
- /* a &= (0x7f<<14)|(0x7f); */\r
- a = a<<7;\r
- a |= b;\r
- *v = a;\r
- return 4;\r
- }\r
-\r
- /* a: p0<<14 | p2 (masked) */\r
- /* b: p1<<14 | p3 (unmasked) */\r
- /* 1:save off p0<<21 | p1<<14 | p2<<7 | p3 (masked) */\r
- /* moved CSE1 up */\r
- /* a &= (0x7f<<14)|(0x7f); */\r
- b &= (0x7f<<14)|(0x7f);\r
- s = a;\r
- /* s: p0<<14 | p2 (masked) */\r
-\r
- p++;\r
- a = a<<14;\r
- a |= *p;\r
- /* a: p0<<28 | p2<<14 | p4 (unmasked) */\r
- if (!(a&0x80))\r
- {\r
- /* we can skip these cause they were (effectively) done above in calc'ing s */\r
- /* a &= (0x7f<<28)|(0x7f<<14)|(0x7f); */\r
- /* b &= (0x7f<<14)|(0x7f); */\r
- b = b<<7;\r
- a |= b;\r
- s = s>>18;\r
- *v = ((u64)s)<<32 | a;\r
- return 5;\r
- }\r
-\r
- /* 2:save off p0<<21 | p1<<14 | p2<<7 | p3 (masked) */\r
- s = s<<7;\r
- s |= b;\r
- /* s: p0<<21 | p1<<14 | p2<<7 | p3 (masked) */\r
-\r
- p++;\r
- b = b<<14;\r
- b |= *p;\r
- /* b: p1<<28 | p3<<14 | p5 (unmasked) */\r
- if (!(b&0x80))\r
- {\r
- /* we can skip this cause it was (effectively) done above in calc'ing s */\r
- /* b &= (0x7f<<28)|(0x7f<<14)|(0x7f); */\r
- a &= (0x7f<<14)|(0x7f);\r
- a = a<<7;\r
- a |= b;\r
- s = s>>18;\r
- *v = ((u64)s)<<32 | a;\r
- return 6;\r
- }\r
-\r
- p++;\r
- a = a<<14;\r
- a |= *p;\r
- /* a: p2<<28 | p4<<14 | p6 (unmasked) */\r
- if (!(a&0x80))\r
- {\r
- a &= (0x1f<<28)|(0x7f<<14)|(0x7f);\r
- b &= (0x7f<<14)|(0x7f);\r
- b = b<<7;\r
- a |= b;\r
- s = s>>11;\r
- *v = ((u64)s)<<32 | a;\r
- return 7;\r
- }\r
-\r
- /* CSE2 from below */\r
- a &= (0x7f<<14)|(0x7f);\r
- p++;\r
- b = b<<14;\r
- b |= *p;\r
- /* b: p3<<28 | p5<<14 | p7 (unmasked) */\r
- if (!(b&0x80))\r
- {\r
- b &= (0x1f<<28)|(0x7f<<14)|(0x7f);\r
- /* moved CSE2 up */\r
- /* a &= (0x7f<<14)|(0x7f); */\r
- a = a<<7;\r
- a |= b;\r
- s = s>>4;\r
- *v = ((u64)s)<<32 | a;\r
- return 8;\r
- }\r
-\r
- p++;\r
- a = a<<15;\r
- a |= *p;\r
- /* a: p4<<29 | p6<<15 | p8 (unmasked) */\r
-\r
- /* moved CSE2 up */\r
- /* a &= (0x7f<<29)|(0x7f<<15)|(0xff); */\r
- b &= (0x7f<<14)|(0x7f);\r
- b = b<<8;\r
- a |= b;\r
-\r
- s = s<<4;\r
- b = p[-4];\r
- b &= 0x7f;\r
- b = b>>3;\r
- s |= b;\r
-\r
- *v = ((u64)s)<<32 | a;\r
-\r
- return 9;\r
-}\r
-\r
-/*\r
-** Read a 32-bit variable-length integer from memory starting at p[0].\r
-** Return the number of bytes read. The value is stored in *v.\r
-**\r
-** If the varint stored in p[0] is larger than can fit in a 32-bit unsigned\r
-** integer, then set *v to 0xffffffff.\r
-**\r
-** A MACRO version, getVarint32, is provided which inlines the \r
-** single-byte case. All code should use the MACRO version as \r
-** this function assumes the single-byte case has already been handled.\r
-*/\r
-u8 sqlite3GetVarint32(const unsigned char *p, u32 *v){\r
- u32 a,b;\r
-\r
- /* The 1-byte case. Overwhelmingly the most common. Handled inline\r
- ** by the getVarin32() macro */\r
- a = *p;\r
- /* a: p0 (unmasked) */\r
-#ifndef getVarint32\r
- if (!(a&0x80))\r
- {\r
- /* Values between 0 and 127 */\r
- *v = a;\r
- return 1;\r
- }\r
-#endif\r
-\r
- /* The 2-byte case */\r
- p++;\r
- b = *p;\r
- /* b: p1 (unmasked) */\r
- if (!(b&0x80))\r
- {\r
- /* Values between 128 and 16383 */\r
- a &= 0x7f;\r
- a = a<<7;\r
- *v = a | b;\r
- return 2;\r
- }\r
-\r
- /* The 3-byte case */\r
- p++;\r
- a = a<<14;\r
- a |= *p;\r
- /* a: p0<<14 | p2 (unmasked) */\r
- if (!(a&0x80))\r
- {\r
- /* Values between 16384 and 2097151 */\r
- a &= (0x7f<<14)|(0x7f);\r
- b &= 0x7f;\r
- b = b<<7;\r
- *v = a | b;\r
- return 3;\r
- }\r
-\r
- /* A 32-bit varint is used to store size information in btrees.\r
- ** Objects are rarely larger than 2MiB limit of a 3-byte varint.\r
- ** A 3-byte varint is sufficient, for example, to record the size\r
- ** of a 1048569-byte BLOB or string.\r
- **\r
- ** We only unroll the first 1-, 2-, and 3- byte cases. The very\r
- ** rare larger cases can be handled by the slower 64-bit varint\r
- ** routine.\r
- */\r
-#if 1\r
- {\r
- u64 v64;\r
- u8 n;\r
-\r
- p -= 2;\r
- n = sqlite3GetVarint(p, &v64);\r
- assert( n>3 && n<=9 );\r
- if( (v64 & SQLITE_MAX_U32)!=v64 ){\r
- *v = 0xffffffff;\r
- }else{\r
- *v = (u32)v64;\r
- }\r
- return n;\r
- }\r
-\r
-#else\r
- /* For following code (kept for historical record only) shows an\r
- ** unrolling for the 3- and 4-byte varint cases. This code is\r
- ** slightly faster, but it is also larger and much harder to test.\r
- */\r
- p++;\r
- b = b<<14;\r
- b |= *p;\r
- /* b: p1<<14 | p3 (unmasked) */\r
- if (!(b&0x80))\r
- {\r
- /* Values between 2097152 and 268435455 */\r
- b &= (0x7f<<14)|(0x7f);\r
- a &= (0x7f<<14)|(0x7f);\r
- a = a<<7;\r
- *v = a | b;\r
- return 4;\r
- }\r
-\r
- p++;\r
- a = a<<14;\r
- a |= *p;\r
- /* a: p0<<28 | p2<<14 | p4 (unmasked) */\r
- if (!(a&0x80))\r
- {\r
- /* Walues between 268435456 and 34359738367 */\r
- a &= (0x1f<<28)|(0x7f<<14)|(0x7f);\r
- b &= (0x1f<<28)|(0x7f<<14)|(0x7f);\r
- b = b<<7;\r
- *v = a | b;\r
- return 5;\r
- }\r
-\r
- /* We can only reach this point when reading a corrupt database\r
- ** file. In that case we are not in any hurry. Use the (relatively\r
- ** slow) general-purpose sqlite3GetVarint() routine to extract the\r
- ** value. */\r
- {\r
- u64 v64;\r
- u8 n;\r
-\r
- p -= 4;\r
- n = sqlite3GetVarint(p, &v64);\r
- assert( n>5 && n<=9 );\r
- *v = (u32)v64;\r
- return n;\r
- }\r
-#endif\r
-}\r
-\r
-/*\r
-** Return the number of bytes that will be needed to store the given\r
-** 64-bit integer.\r
-*/\r
-int sqlite3VarintLen(u64 v){\r
- int i = 0;\r
- do{\r
- i++;\r
- v >>= 7;\r
- }while( v!=0 && ALWAYS(i<9) );\r
- return i;\r
-}\r
-\r
-\r
-/*\r
-** Read or write a four-byte big-endian integer value.\r
-*/\r
-u32 sqlite3Get4byte(const u8 *p){\r
- return (p[0]<<24) | (p[1]<<16) | (p[2]<<8) | p[3];\r
-}\r
-void sqlite3Put4byte(unsigned char *p, u32 v){\r
- p[0] = (u8)(v>>24);\r
- p[1] = (u8)(v>>16);\r
- p[2] = (u8)(v>>8);\r
- p[3] = (u8)v;\r
-}\r
-\r
-\r
-\r
-#if !defined(SQLITE_OMIT_BLOB_LITERAL) || defined(SQLITE_HAS_CODEC)\r
-/*\r
-** Translate a single byte of Hex into an integer.\r
-** This routine only works if h really is a valid hexadecimal\r
-** character: 0..9a..fA..F\r
-*/\r
-static u8 hexToInt(int h){\r
- assert( (h>='0' && h<='9') || (h>='a' && h<='f') || (h>='A' && h<='F') );\r
-#ifdef SQLITE_ASCII\r
- h += 9*(1&(h>>6));\r
-#endif\r
-#ifdef SQLITE_EBCDIC\r
- h += 9*(1&~(h>>4));\r
-#endif\r
- return (u8)(h & 0xf);\r
-}\r
-#endif /* !SQLITE_OMIT_BLOB_LITERAL || SQLITE_HAS_CODEC */\r
-\r
-#if !defined(SQLITE_OMIT_BLOB_LITERAL) || defined(SQLITE_HAS_CODEC)\r
-/*\r
-** Convert a BLOB literal of the form "x'hhhhhh'" into its binary\r
-** value. Return a pointer to its binary value. Space to hold the\r
-** binary value has been obtained from malloc and must be freed by\r
-** the calling routine.\r
-*/\r
-void *sqlite3HexToBlob(sqlite3 *db, const char *z, int n){\r
- char *zBlob;\r
- int i;\r
-\r
- zBlob = (char *)sqlite3DbMallocRaw(db, n/2 + 1);\r
- n--;\r
- if( zBlob ){\r
- for(i=0; i<n; i+=2){\r
- zBlob[i/2] = (hexToInt(z[i])<<4) | hexToInt(z[i+1]);\r
- }\r
- zBlob[i/2] = 0;\r
- }\r
- return zBlob;\r
-}\r
-#endif /* !SQLITE_OMIT_BLOB_LITERAL || SQLITE_HAS_CODEC */\r
-\r
-\r
-/*\r
-** Change the sqlite.magic from SQLITE_MAGIC_OPEN to SQLITE_MAGIC_BUSY.\r
-** Return an error (non-zero) if the magic was not SQLITE_MAGIC_OPEN\r
-** when this routine is called.\r
-**\r
-** This routine is called when entering an SQLite API. The SQLITE_MAGIC_OPEN\r
-** value indicates that the database connection passed into the API is\r
-** open and is not being used by another thread. By changing the value\r
-** to SQLITE_MAGIC_BUSY we indicate that the connection is in use.\r
-** sqlite3SafetyOff() below will change the value back to SQLITE_MAGIC_OPEN\r
-** when the API exits. \r
-**\r
-** This routine is a attempt to detect if two threads use the\r
-** same sqlite* pointer at the same time. There is a race \r
-** condition so it is possible that the error is not detected.\r
-** But usually the problem will be seen. The result will be an\r
-** error which can be used to debug the application that is\r
-** using SQLite incorrectly.\r
-**\r
-** Ticket #202: If db->magic is not a valid open value, take care not\r
-** to modify the db structure at all. It could be that db is a stale\r
-** pointer. In other words, it could be that there has been a prior\r
-** call to sqlite3_close(db) and db has been deallocated. And we do\r
-** not want to write into deallocated memory.\r
-*/\r
-#ifdef SQLITE_DEBUG\r
-int sqlite3SafetyOn(sqlite3 *db){\r
- if( db->magic==SQLITE_MAGIC_OPEN ){\r
- db->magic = SQLITE_MAGIC_BUSY;\r
- assert( sqlite3_mutex_held(db->mutex) );\r
- return 0;\r
- }else if( db->magic==SQLITE_MAGIC_BUSY ){\r
- db->magic = SQLITE_MAGIC_ERROR;\r
- db->u1.isInterrupted = 1;\r
- }\r
- return 1;\r
-}\r
-#endif\r
-\r
-/*\r
-** Change the magic from SQLITE_MAGIC_BUSY to SQLITE_MAGIC_OPEN.\r
-** Return an error (non-zero) if the magic was not SQLITE_MAGIC_BUSY\r
-** when this routine is called.\r
-*/\r
-#ifdef SQLITE_DEBUG\r
-int sqlite3SafetyOff(sqlite3 *db){\r
- if( db->magic==SQLITE_MAGIC_BUSY ){\r
- db->magic = SQLITE_MAGIC_OPEN;\r
- assert( sqlite3_mutex_held(db->mutex) );\r
- return 0;\r
- }else{\r
- db->magic = SQLITE_MAGIC_ERROR;\r
- db->u1.isInterrupted = 1;\r
- return 1;\r
- }\r
-}\r
-#endif\r
-\r
-/*\r
-** Check to make sure we have a valid db pointer. This test is not\r
-** foolproof but it does provide some measure of protection against\r
-** misuse of the interface such as passing in db pointers that are\r
-** NULL or which have been previously closed. If this routine returns\r
-** 1 it means that the db pointer is valid and 0 if it should not be\r
-** dereferenced for any reason. The calling function should invoke\r
-** SQLITE_MISUSE immediately.\r
-**\r
-** sqlite3SafetyCheckOk() requires that the db pointer be valid for\r
-** use. sqlite3SafetyCheckSickOrOk() allows a db pointer that failed to\r
-** open properly and is not fit for general use but which can be\r
-** used as an argument to sqlite3_errmsg() or sqlite3_close().\r
-*/\r
-int sqlite3SafetyCheckOk(sqlite3 *db){\r
- u32 magic;\r
- if( db==0 ) return 0;\r
- magic = db->magic;\r
- if( magic!=SQLITE_MAGIC_OPEN \r
-#ifdef SQLITE_DEBUG\r
- && magic!=SQLITE_MAGIC_BUSY\r
-#endif\r
- ){\r
- return 0;\r
- }else{\r
- return 1;\r
- }\r
-}\r
-int sqlite3SafetyCheckSickOrOk(sqlite3 *db){\r
- u32 magic;\r
- magic = db->magic;\r
- if( magic!=SQLITE_MAGIC_SICK &&\r
- magic!=SQLITE_MAGIC_OPEN &&\r
- magic!=SQLITE_MAGIC_BUSY ) return 0;\r
- return 1;\r
-}\r
+/*
+** 2001 September 15
+**
+** The author disclaims copyright to this source code. In place of
+** a legal notice, here is a blessing:
+**
+** 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.
+**
+*************************************************************************
+** Utility functions used throughout sqlite.
+**
+** This file contains functions for allocating memory, comparing
+** strings, and stuff like that.
+**
+*/
+#include "sqliteInt.h"
+#include <stdarg.h>
+#ifdef SQLITE_HAVE_ISNAN
+# include <math.h>
+#endif
+
+/*
+** Routine needed to support the testcase() macro.
+*/
+#ifdef SQLITE_COVERAGE_TEST
+void sqlite3Coverage(int x){
+ static int dummy = 0;
+ dummy += x;
+}
+#endif
+
+/*
+** Return true if the floating point value is Not a Number (NaN).
+**
+** Use the math library isnan() function if compiled with SQLITE_HAVE_ISNAN.
+** Otherwise, we have our own implementation that works on most systems.
+*/
+int sqlite3IsNaN(double x){
+ int rc; /* The value return */
+#if !defined(SQLITE_HAVE_ISNAN)
+ /*
+ ** Systems that support the isnan() library function should probably
+ ** make use of it by compiling with -DSQLITE_HAVE_ISNAN. But we have
+ ** found that many systems do not have a working isnan() function so
+ ** this implementation is provided as an alternative.
+ **
+ ** This NaN test sometimes fails if compiled on GCC with -ffast-math.
+ ** On the other hand, the use of -ffast-math comes with the following
+ ** warning:
+ **
+ ** This option [-ffast-math] should never be turned on by any
+ ** -O option since it can result in incorrect output for programs
+ ** which depend on an exact implementation of IEEE or ISO
+ ** rules/specifications for math functions.
+ **
+ ** Under MSVC, this NaN test may fail if compiled with a floating-
+ ** point precision mode other than /fp:precise. From the MSDN
+ ** documentation:
+ **
+ ** The compiler [with /fp:precise] will properly handle comparisons
+ ** involving NaN. For example, x != x evaluates to true if x is NaN
+ ** ...
+ */
+#ifdef __FAST_MATH__
+# error SQLite will not work correctly with the -ffast-math option of GCC.
+#endif
+ volatile double y = x;
+ volatile double z = y;
+ rc = (y!=z);
+#else /* if defined(SQLITE_HAVE_ISNAN) */
+ rc = isnan(x);
+#endif /* SQLITE_HAVE_ISNAN */
+ testcase( rc );
+ return rc;
+}
+
+/*
+** Compute a string length that is limited to what can be stored in
+** lower 30 bits of a 32-bit signed integer.
+**
+** The value returned will never be negative. Nor will it ever be greater
+** than the actual length of the string. For very long strings (greater
+** than 1GiB) the value returned might be less than the true string length.
+*/
+int sqlite3Strlen30(const char *z){
+ const char *z2 = z;
+ if( z==0 ) return 0;
+ while( *z2 ){ z2++; }
+ return 0x3fffffff & (int)(z2 - z);
+}
+
+/*
+** Set the most recent error code and error string for the sqlite
+** handle "db". The error code is set to "err_code".
+**
+** If it is not NULL, string zFormat specifies the format of the
+** error string in the style of the printf functions: The following
+** format characters are allowed:
+**
+** %s Insert a string
+** %z A string that should be freed after use
+** %d Insert an integer
+** %T Insert a token
+** %S Insert the first element of a SrcList
+**
+** zFormat and any string tokens that follow it are assumed to be
+** encoded in UTF-8.
+**
+** To clear the most recent error for sqlite handle "db", sqlite3Error
+** should be called with err_code set to SQLITE_OK and zFormat set
+** to NULL.
+*/
+void sqlite3Error(sqlite3 *db, int err_code, const char *zFormat, ...){
+ if( db && (db->pErr || (db->pErr = sqlite3ValueNew(db))!=0) ){
+ db->errCode = err_code;
+ if( zFormat ){
+ char *z;
+ va_list ap;
+ va_start(ap, zFormat);
+ z = sqlite3VMPrintf(db, zFormat, ap);
+ va_end(ap);
+ sqlite3ValueSetStr(db->pErr, -1, z, SQLITE_UTF8, SQLITE_DYNAMIC);
+ }else{
+ sqlite3ValueSetStr(db->pErr, 0, 0, SQLITE_UTF8, SQLITE_STATIC);
+ }
+ }
+}
+
+/*
+** Add an error message to pParse->zErrMsg and increment pParse->nErr.
+** The following formatting characters are allowed:
+**
+** %s Insert a string
+** %z A string that should be freed after use
+** %d Insert an integer
+** %T Insert a token
+** %S Insert the first element of a SrcList
+**
+** This function should be used to report any error that occurs whilst
+** compiling an SQL statement (i.e. within sqlite3_prepare()). The
+** last thing the sqlite3_prepare() function does is copy the error
+** stored by this function into the database handle using sqlite3Error().
+** Function sqlite3Error() should be used during statement execution
+** (sqlite3_step() etc.).
+*/
+void sqlite3ErrorMsg(Parse *pParse, const char *zFormat, ...){
+ va_list ap;
+ sqlite3 *db = pParse->db;
+ pParse->nErr++;
+ sqlite3DbFree(db, pParse->zErrMsg);
+ va_start(ap, zFormat);
+ pParse->zErrMsg = sqlite3VMPrintf(db, zFormat, ap);
+ va_end(ap);
+ pParse->rc = SQLITE_ERROR;
+}
+
+/*
+** Clear the error message in pParse, if any
+*/
+void sqlite3ErrorClear(Parse *pParse){
+ sqlite3DbFree(pParse->db, pParse->zErrMsg);
+ pParse->zErrMsg = 0;
+ pParse->nErr = 0;
+}
+
+/*
+** Convert an SQL-style quoted string into a normal string by removing
+** the quote characters. The conversion is done in-place. If the
+** input does not begin with a quote character, then this routine
+** is a no-op.
+**
+** The input string must be zero-terminated. A new zero-terminator
+** is added to the dequoted string.
+**
+** The return value is -1 if no dequoting occurs or the length of the
+** dequoted string, exclusive of the zero terminator, if dequoting does
+** occur.
+**
+** 2002-Feb-14: This routine is extended to remove MS-Access style
+** brackets from around identifers. For example: "[a-b-c]" becomes
+** "a-b-c".
+*/
+int sqlite3Dequote(char *z){
+ char quote;
+ int i, j;
+ if( z==0 ) return -1;
+ quote = z[0];
+ switch( quote ){
+ case '\'': break;
+ case '"': break;
+ case '`': break; /* For MySQL compatibility */
+ case '[': quote = ']'; break; /* For MS SqlServer compatibility */
+ default: return -1;
+ }
+ for(i=1, j=0; ALWAYS(z[i]); i++){
+ if( z[i]==quote ){
+ if( z[i+1]==quote ){
+ z[j++] = quote;
+ i++;
+ }else{
+ break;
+ }
+ }else{
+ z[j++] = z[i];
+ }
+ }
+ z[j] = 0;
+ return j;
+}
+
+/* Convenient short-hand */
+#define UpperToLower sqlite3UpperToLower
+
+/*
+** Some systems have stricmp(). Others have strcasecmp(). Because
+** there is no consistency, we will define our own.
+*/
+int sqlite3StrICmp(const char *zLeft, const char *zRight){
+ register unsigned char *a, *b;
+ a = (unsigned char *)zLeft;
+ b = (unsigned char *)zRight;
+ while( *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; }
+ return UpperToLower[*a] - UpperToLower[*b];
+}
+int sqlite3_strnicmp(const char *zLeft, const char *zRight, int N){
+ register unsigned char *a, *b;
+ a = (unsigned char *)zLeft;
+ b = (unsigned char *)zRight;
+ while( N-- > 0 && *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; }
+ return N<0 ? 0 : UpperToLower[*a] - UpperToLower[*b];
+}
+
+/*
+** Return TRUE if z is a pure numeric string. Return FALSE and leave
+** *realnum unchanged if the string contains any character which is not
+** part of a number.
+**
+** If the string is pure numeric, set *realnum to TRUE if the string
+** contains the '.' character or an "E+000" style exponentiation suffix.
+** Otherwise set *realnum to FALSE. Note that just becaue *realnum is
+** false does not mean that the number can be successfully converted into
+** an integer - it might be too big.
+**
+** An empty string is considered non-numeric.
+*/
+int sqlite3IsNumber(const char *z, int *realnum, u8 enc){
+ int incr = (enc==SQLITE_UTF8?1:2);
+ if( enc==SQLITE_UTF16BE ) z++;
+ if( *z=='-' || *z=='+' ) z += incr;
+ if( !sqlite3Isdigit(*z) ){
+ return 0;
+ }
+ z += incr;
+ *realnum = 0;
+ while( sqlite3Isdigit(*z) ){ z += incr; }
+ if( *z=='.' ){
+ z += incr;
+ if( !sqlite3Isdigit(*z) ) return 0;
+ while( sqlite3Isdigit(*z) ){ z += incr; }
+ *realnum = 1;
+ }
+ if( *z=='e' || *z=='E' ){
+ z += incr;
+ if( *z=='+' || *z=='-' ) z += incr;
+ if( !sqlite3Isdigit(*z) ) return 0;
+ while( sqlite3Isdigit(*z) ){ z += incr; }
+ *realnum = 1;
+ }
+ return *z==0;
+}
+
+/*
+** The string z[] is an ASCII representation of a real number.
+** Convert this string to a double.
+**
+** This routine assumes that z[] really is a valid number. If it
+** is not, the result is undefined.
+**
+** This routine is used instead of the library atof() function because
+** the library atof() might want to use "," as the decimal point instead
+** of "." depending on how locale is set. But that would cause problems
+** for SQL. So this routine always uses "." regardless of locale.
+*/
+int sqlite3AtoF(const char *z, double *pResult){
+#ifndef SQLITE_OMIT_FLOATING_POINT
+ const char *zBegin = z;
+ /* sign * significand * (10 ^ (esign * exponent)) */
+ int sign = 1; /* sign of significand */
+ i64 s = 0; /* significand */
+ int d = 0; /* adjust exponent for shifting decimal point */
+ int esign = 1; /* sign of exponent */
+ int e = 0; /* exponent */
+ double result;
+ int nDigits = 0;
+
+ /* skip leading spaces */
+ while( sqlite3Isspace(*z) ) z++;
+ /* get sign of significand */
+ if( *z=='-' ){
+ sign = -1;
+ z++;
+ }else if( *z=='+' ){
+ z++;
+ }
+ /* skip leading zeroes */
+ while( z[0]=='0' ) z++, nDigits++;
+
+ /* copy max significant digits to significand */
+ while( sqlite3Isdigit(*z) && s<((LARGEST_INT64-9)/10) ){
+ s = s*10 + (*z - '0');
+ z++, nDigits++;
+ }
+ /* skip non-significant significand digits
+ ** (increase exponent by d to shift decimal left) */
+ while( sqlite3Isdigit(*z) ) z++, nDigits++, d++;
+
+ /* if decimal point is present */
+ if( *z=='.' ){
+ z++;
+ /* copy digits from after decimal to significand
+ ** (decrease exponent by d to shift decimal right) */
+ while( sqlite3Isdigit(*z) && s<((LARGEST_INT64-9)/10) ){
+ s = s*10 + (*z - '0');
+ z++, nDigits++, d--;
+ }
+ /* skip non-significant digits */
+ while( sqlite3Isdigit(*z) ) z++, nDigits++;
+ }
+
+ /* if exponent is present */
+ if( *z=='e' || *z=='E' ){
+ z++;
+ /* get sign of exponent */
+ if( *z=='-' ){
+ esign = -1;
+ z++;
+ }else if( *z=='+' ){
+ z++;
+ }
+ /* copy digits to exponent */
+ while( sqlite3Isdigit(*z) ){
+ e = e*10 + (*z - '0');
+ z++;
+ }
+ }
+
+ /* adjust exponent by d, and update sign */
+ e = (e*esign) + d;
+ if( e<0 ) {
+ esign = -1;
+ e *= -1;
+ } else {
+ esign = 1;
+ }
+
+ /* if 0 significand */
+ if( !s ) {
+ /* In the IEEE 754 standard, zero is signed.
+ ** Add the sign if we've seen at least one digit */
+ result = (sign<0 && nDigits) ? -(double)0 : (double)0;
+ } else {
+ /* attempt to reduce exponent */
+ if( esign>0 ){
+ while( s<(LARGEST_INT64/10) && e>0 ) e--,s*=10;
+ }else{
+ while( !(s%10) && e>0 ) e--,s/=10;
+ }
+
+ /* adjust the sign of significand */
+ s = sign<0 ? -s : s;
+
+ /* if exponent, scale significand as appropriate
+ ** and store in result. */
+ if( e ){
+ double scale = 1.0;
+ /* attempt to handle extremely small/large numbers better */
+ if( e>307 && e<342 ){
+ while( e%308 ) { scale *= 1.0e+1; e -= 1; }
+ if( esign<0 ){
+ result = s / scale;
+ result /= 1.0e+308;
+ }else{
+ result = s * scale;
+ result *= 1.0e+308;
+ }
+ }else{
+ /* 1.0e+22 is the largest power of 10 than can be
+ ** represented exactly. */
+ while( e%22 ) { scale *= 1.0e+1; e -= 1; }
+ while( e>0 ) { scale *= 1.0e+22; e -= 22; }
+ if( esign<0 ){
+ result = s / scale;
+ }else{
+ result = s * scale;
+ }
+ }
+ } else {
+ result = (double)s;
+ }
+ }
+
+ /* store the result */
+ *pResult = result;
+
+ /* return number of characters used */
+ return (int)(z - zBegin);
+#else
+ return sqlite3Atoi64(z, pResult);
+#endif /* SQLITE_OMIT_FLOATING_POINT */
+}
+
+/*
+** Compare the 19-character string zNum against the text representation
+** value 2^63: 9223372036854775808. Return negative, zero, or positive
+** if zNum is less than, equal to, or greater than the string.
+**
+** Unlike memcmp() this routine is guaranteed to return the difference
+** in the values of the last digit if the only difference is in the
+** last digit. So, for example,
+**
+** compare2pow63("9223372036854775800")
+**
+** will return -8.
+*/
+static int compare2pow63(const char *zNum){
+ int c;
+ c = memcmp(zNum,"922337203685477580",18)*10;
+ if( c==0 ){
+ c = zNum[18] - '8';
+ }
+ return c;
+}
+
+
+/*
+** Return TRUE if zNum is a 64-bit signed integer and write
+** the value of the integer into *pNum. If zNum is not an integer
+** or is an integer that is too large to be expressed with 64 bits,
+** then return false.
+**
+** When this routine was originally written it dealt with only
+** 32-bit numbers. At that time, it was much faster than the
+** atoi() library routine in RedHat 7.2.
+*/
+int sqlite3Atoi64(const char *zNum, i64 *pNum){
+ i64 v = 0;
+ int neg;
+ int i, c;
+ const char *zStart;
+ while( sqlite3Isspace(*zNum) ) zNum++;
+ if( *zNum=='-' ){
+ neg = 1;
+ zNum++;
+ }else if( *zNum=='+' ){
+ neg = 0;
+ zNum++;
+ }else{
+ neg = 0;
+ }
+ zStart = zNum;
+ while( zNum[0]=='0' ){ zNum++; } /* Skip over leading zeros. Ticket #2454 */
+ for(i=0; (c=zNum[i])>='0' && c<='9'; i++){
+ v = v*10 + c - '0';
+ }
+ *pNum = neg ? -v : v;
+ if( c!=0 || (i==0 && zStart==zNum) || i>19 ){
+ /* zNum is empty or contains non-numeric text or is longer
+ ** than 19 digits (thus guaranting that it is too large) */
+ return 0;
+ }else if( i<19 ){
+ /* Less than 19 digits, so we know that it fits in 64 bits */
+ return 1;
+ }else{
+ /* 19-digit numbers must be no larger than 9223372036854775807 if positive
+ ** or 9223372036854775808 if negative. Note that 9223372036854665808
+ ** is 2^63. */
+ return compare2pow63(zNum)<neg;
+ }
+}
+
+/*
+** The string zNum represents an unsigned integer. The zNum string
+** consists of one or more digit characters and is terminated by
+** a zero character. Any stray characters in zNum result in undefined
+** behavior.
+**
+** If the unsigned integer that zNum represents will fit in a
+** 64-bit signed integer, return TRUE. Otherwise return FALSE.
+**
+** If the negFlag parameter is true, that means that zNum really represents
+** a negative number. (The leading "-" is omitted from zNum.) This
+** parameter is needed to determine a boundary case. A string
+** of "9223373036854775808" returns false if negFlag is false or true
+** if negFlag is true.
+**
+** Leading zeros are ignored.
+*/
+int sqlite3FitsIn64Bits(const char *zNum, int negFlag){
+ int i;
+ int neg = 0;
+
+ assert( zNum[0]>='0' && zNum[0]<='9' ); /* zNum is an unsigned number */
+
+ if( negFlag ) neg = 1-neg;
+ while( *zNum=='0' ){
+ zNum++; /* Skip leading zeros. Ticket #2454 */
+ }
+ for(i=0; zNum[i]; i++){ assert( zNum[i]>='0' && zNum[i]<='9' ); }
+ if( i<19 ){
+ /* Guaranteed to fit if less than 19 digits */
+ return 1;
+ }else if( i>19 ){
+ /* Guaranteed to be too big if greater than 19 digits */
+ return 0;
+ }else{
+ /* Compare against 2^63. */
+ return compare2pow63(zNum)<neg;
+ }
+}
+
+/*
+** If zNum represents an integer that will fit in 32-bits, then set
+** *pValue to that integer and return true. Otherwise return false.
+**
+** Any non-numeric characters that following zNum are ignored.
+** This is different from sqlite3Atoi64() which requires the
+** input number to be zero-terminated.
+*/
+int sqlite3GetInt32(const char *zNum, int *pValue){
+ sqlite_int64 v = 0;
+ int i, c;
+ int neg = 0;
+ if( zNum[0]=='-' ){
+ neg = 1;
+ zNum++;
+ }else if( zNum[0]=='+' ){
+ zNum++;
+ }
+ while( zNum[0]=='0' ) zNum++;
+ for(i=0; i<11 && (c = zNum[i] - '0')>=0 && c<=9; i++){
+ v = v*10 + c;
+ }
+
+ /* The longest decimal representation of a 32 bit integer is 10 digits:
+ **
+ ** 1234567890
+ ** 2^31 -> 2147483648
+ */
+ if( i>10 ){
+ return 0;
+ }
+ if( v-neg>2147483647 ){
+ return 0;
+ }
+ if( neg ){
+ v = -v;
+ }
+ *pValue = (int)v;
+ return 1;
+}
+
+/*
+** The variable-length integer encoding is as follows:
+**
+** KEY:
+** A = 0xxxxxxx 7 bits of data and one flag bit
+** B = 1xxxxxxx 7 bits of data and one flag bit
+** C = xxxxxxxx 8 bits of data
+**
+** 7 bits - A
+** 14 bits - BA
+** 21 bits - BBA
+** 28 bits - BBBA
+** 35 bits - BBBBA
+** 42 bits - BBBBBA
+** 49 bits - BBBBBBA
+** 56 bits - BBBBBBBA
+** 64 bits - BBBBBBBBC
+*/
+
+/*
+** Write a 64-bit variable-length integer to memory starting at p[0].
+** The length of data write will be between 1 and 9 bytes. The number
+** of bytes written is returned.
+**
+** A variable-length integer consists of the lower 7 bits of each byte
+** for all bytes that have the 8th bit set and one byte with the 8th
+** bit clear. Except, if we get to the 9th byte, it stores the full
+** 8 bits and is the last byte.
+*/
+int sqlite3PutVarint(unsigned char *p, u64 v){
+ int i, j, n;
+ u8 buf[10];
+ if( v & (((u64)0xff000000)<<32) ){
+ p[8] = (u8)v;
+ v >>= 8;
+ for(i=7; i>=0; i--){
+ p[i] = (u8)((v & 0x7f) | 0x80);
+ v >>= 7;
+ }
+ return 9;
+ }
+ n = 0;
+ do{
+ buf[n++] = (u8)((v & 0x7f) | 0x80);
+ v >>= 7;
+ }while( v!=0 );
+ buf[0] &= 0x7f;
+ assert( n<=9 );
+ for(i=0, j=n-1; j>=0; j--, i++){
+ p[i] = buf[j];
+ }
+ return n;
+}
+
+/*
+** This routine is a faster version of sqlite3PutVarint() that only
+** works for 32-bit positive integers and which is optimized for
+** the common case of small integers. A MACRO version, putVarint32,
+** is provided which inlines the single-byte case. All code should use
+** the MACRO version as this function assumes the single-byte case has
+** already been handled.
+*/
+int sqlite3PutVarint32(unsigned char *p, u32 v){
+#ifndef putVarint32
+ if( (v & ~0x7f)==0 ){
+ p[0] = v;
+ return 1;
+ }
+#endif
+ if( (v & ~0x3fff)==0 ){
+ p[0] = (u8)((v>>7) | 0x80);
+ p[1] = (u8)(v & 0x7f);
+ return 2;
+ }
+ return sqlite3PutVarint(p, v);
+}
+
+/*
+** Read a 64-bit variable-length integer from memory starting at p[0].
+** Return the number of bytes read. The value is stored in *v.
+*/
+u8 sqlite3GetVarint(const unsigned char *p, u64 *v){
+ u32 a,b,s;
+
+ a = *p;
+ /* a: p0 (unmasked) */
+ if (!(a&0x80))
+ {
+ *v = a;
+ return 1;
+ }
+
+ p++;
+ b = *p;
+ /* b: p1 (unmasked) */
+ if (!(b&0x80))
+ {
+ a &= 0x7f;
+ a = a<<7;
+ a |= b;
+ *v = a;
+ return 2;
+ }
+
+ p++;
+ a = a<<14;
+ a |= *p;
+ /* a: p0<<14 | p2 (unmasked) */
+ if (!(a&0x80))
+ {
+ a &= (0x7f<<14)|(0x7f);
+ b &= 0x7f;
+ b = b<<7;
+ a |= b;
+ *v = a;
+ return 3;
+ }
+
+ /* CSE1 from below */
+ a &= (0x7f<<14)|(0x7f);
+ p++;
+ b = b<<14;
+ b |= *p;
+ /* b: p1<<14 | p3 (unmasked) */
+ if (!(b&0x80))
+ {
+ b &= (0x7f<<14)|(0x7f);
+ /* moved CSE1 up */
+ /* a &= (0x7f<<14)|(0x7f); */
+ a = a<<7;
+ a |= b;
+ *v = a;
+ return 4;
+ }
+
+ /* a: p0<<14 | p2 (masked) */
+ /* b: p1<<14 | p3 (unmasked) */
+ /* 1:save off p0<<21 | p1<<14 | p2<<7 | p3 (masked) */
+ /* moved CSE1 up */
+ /* a &= (0x7f<<14)|(0x7f); */
+ b &= (0x7f<<14)|(0x7f);
+ s = a;
+ /* s: p0<<14 | p2 (masked) */
+
+ p++;
+ a = a<<14;
+ a |= *p;
+ /* a: p0<<28 | p2<<14 | p4 (unmasked) */
+ if (!(a&0x80))
+ {
+ /* we can skip these cause they were (effectively) done above in calc'ing s */
+ /* a &= (0x7f<<28)|(0x7f<<14)|(0x7f); */
+ /* b &= (0x7f<<14)|(0x7f); */
+ b = b<<7;
+ a |= b;
+ s = s>>18;
+ *v = ((u64)s)<<32 | a;
+ return 5;
+ }
+
+ /* 2:save off p0<<21 | p1<<14 | p2<<7 | p3 (masked) */
+ s = s<<7;
+ s |= b;
+ /* s: p0<<21 | p1<<14 | p2<<7 | p3 (masked) */
+
+ p++;
+ b = b<<14;
+ b |= *p;
+ /* b: p1<<28 | p3<<14 | p5 (unmasked) */
+ if (!(b&0x80))
+ {
+ /* we can skip this cause it was (effectively) done above in calc'ing s */
+ /* b &= (0x7f<<28)|(0x7f<<14)|(0x7f); */
+ a &= (0x7f<<14)|(0x7f);
+ a = a<<7;
+ a |= b;
+ s = s>>18;
+ *v = ((u64)s)<<32 | a;
+ return 6;
+ }
+
+ p++;
+ a = a<<14;
+ a |= *p;
+ /* a: p2<<28 | p4<<14 | p6 (unmasked) */
+ if (!(a&0x80))
+ {
+ a &= (0x1f<<28)|(0x7f<<14)|(0x7f);
+ b &= (0x7f<<14)|(0x7f);
+ b = b<<7;
+ a |= b;
+ s = s>>11;
+ *v = ((u64)s)<<32 | a;
+ return 7;
+ }
+
+ /* CSE2 from below */
+ a &= (0x7f<<14)|(0x7f);
+ p++;
+ b = b<<14;
+ b |= *p;
+ /* b: p3<<28 | p5<<14 | p7 (unmasked) */
+ if (!(b&0x80))
+ {
+ b &= (0x1f<<28)|(0x7f<<14)|(0x7f);
+ /* moved CSE2 up */
+ /* a &= (0x7f<<14)|(0x7f); */
+ a = a<<7;
+ a |= b;
+ s = s>>4;
+ *v = ((u64)s)<<32 | a;
+ return 8;
+ }
+
+ p++;
+ a = a<<15;
+ a |= *p;
+ /* a: p4<<29 | p6<<15 | p8 (unmasked) */
+
+ /* moved CSE2 up */
+ /* a &= (0x7f<<29)|(0x7f<<15)|(0xff); */
+ b &= (0x7f<<14)|(0x7f);
+ b = b<<8;
+ a |= b;
+
+ s = s<<4;
+ b = p[-4];
+ b &= 0x7f;
+ b = b>>3;
+ s |= b;
+
+ *v = ((u64)s)<<32 | a;
+
+ return 9;
+}
+
+/*
+** Read a 32-bit variable-length integer from memory starting at p[0].
+** Return the number of bytes read. The value is stored in *v.
+**
+** If the varint stored in p[0] is larger than can fit in a 32-bit unsigned
+** integer, then set *v to 0xffffffff.
+**
+** A MACRO version, getVarint32, is provided which inlines the
+** single-byte case. All code should use the MACRO version as
+** this function assumes the single-byte case has already been handled.
+*/
+u8 sqlite3GetVarint32(const unsigned char *p, u32 *v){
+ u32 a,b;
+
+ /* The 1-byte case. Overwhelmingly the most common. Handled inline
+ ** by the getVarin32() macro */
+ a = *p;
+ /* a: p0 (unmasked) */
+#ifndef getVarint32
+ if (!(a&0x80))
+ {
+ /* Values between 0 and 127 */
+ *v = a;
+ return 1;
+ }
+#endif
+
+ /* The 2-byte case */
+ p++;
+ b = *p;
+ /* b: p1 (unmasked) */
+ if (!(b&0x80))
+ {
+ /* Values between 128 and 16383 */
+ a &= 0x7f;
+ a = a<<7;
+ *v = a | b;
+ return 2;
+ }
+
+ /* The 3-byte case */
+ p++;
+ a = a<<14;
+ a |= *p;
+ /* a: p0<<14 | p2 (unmasked) */
+ if (!(a&0x80))
+ {
+ /* Values between 16384 and 2097151 */
+ a &= (0x7f<<14)|(0x7f);
+ b &= 0x7f;
+ b = b<<7;
+ *v = a | b;
+ return 3;
+ }
+
+ /* A 32-bit varint is used to store size information in btrees.
+ ** Objects are rarely larger than 2MiB limit of a 3-byte varint.
+ ** A 3-byte varint is sufficient, for example, to record the size
+ ** of a 1048569-byte BLOB or string.
+ **
+ ** We only unroll the first 1-, 2-, and 3- byte cases. The very
+ ** rare larger cases can be handled by the slower 64-bit varint
+ ** routine.
+ */
+#if 1
+ {
+ u64 v64;
+ u8 n;
+
+ p -= 2;
+ n = sqlite3GetVarint(p, &v64);
+ assert( n>3 && n<=9 );
+ if( (v64 & SQLITE_MAX_U32)!=v64 ){
+ *v = 0xffffffff;
+ }else{
+ *v = (u32)v64;
+ }
+ return n;
+ }
+
+#else
+ /* For following code (kept for historical record only) shows an
+ ** unrolling for the 3- and 4-byte varint cases. This code is
+ ** slightly faster, but it is also larger and much harder to test.
+ */
+ p++;
+ b = b<<14;
+ b |= *p;
+ /* b: p1<<14 | p3 (unmasked) */
+ if (!(b&0x80))
+ {
+ /* Values between 2097152 and 268435455 */
+ b &= (0x7f<<14)|(0x7f);
+ a &= (0x7f<<14)|(0x7f);
+ a = a<<7;
+ *v = a | b;
+ return 4;
+ }
+
+ p++;
+ a = a<<14;
+ a |= *p;
+ /* a: p0<<28 | p2<<14 | p4 (unmasked) */
+ if (!(a&0x80))
+ {
+ /* Walues between 268435456 and 34359738367 */
+ a &= (0x1f<<28)|(0x7f<<14)|(0x7f);
+ b &= (0x1f<<28)|(0x7f<<14)|(0x7f);
+ b = b<<7;
+ *v = a | b;
+ return 5;
+ }
+
+ /* We can only reach this point when reading a corrupt database
+ ** file. In that case we are not in any hurry. Use the (relatively
+ ** slow) general-purpose sqlite3GetVarint() routine to extract the
+ ** value. */
+ {
+ u64 v64;
+ u8 n;
+
+ p -= 4;
+ n = sqlite3GetVarint(p, &v64);
+ assert( n>5 && n<=9 );
+ *v = (u32)v64;
+ return n;
+ }
+#endif
+}
+
+/*
+** Return the number of bytes that will be needed to store the given
+** 64-bit integer.
+*/
+int sqlite3VarintLen(u64 v){
+ int i = 0;
+ do{
+ i++;
+ v >>= 7;
+ }while( v!=0 && ALWAYS(i<9) );
+ return i;
+}
+
+
+/*
+** Read or write a four-byte big-endian integer value.
+*/
+u32 sqlite3Get4byte(const u8 *p){
+ return (p[0]<<24) | (p[1]<<16) | (p[2]<<8) | p[3];
+}
+void sqlite3Put4byte(unsigned char *p, u32 v){
+ p[0] = (u8)(v>>24);
+ p[1] = (u8)(v>>16);
+ p[2] = (u8)(v>>8);
+ p[3] = (u8)v;
+}
+
+
+
+#if !defined(SQLITE_OMIT_BLOB_LITERAL) || defined(SQLITE_HAS_CODEC)
+/*
+** Translate a single byte of Hex into an integer.
+** This routine only works if h really is a valid hexadecimal
+** character: 0..9a..fA..F
+*/
+static u8 hexToInt(int h){
+ assert( (h>='0' && h<='9') || (h>='a' && h<='f') || (h>='A' && h<='F') );
+#ifdef SQLITE_ASCII
+ h += 9*(1&(h>>6));
+#endif
+#ifdef SQLITE_EBCDIC
+ h += 9*(1&~(h>>4));
+#endif
+ return (u8)(h & 0xf);
+}
+#endif /* !SQLITE_OMIT_BLOB_LITERAL || SQLITE_HAS_CODEC */
+
+#if !defined(SQLITE_OMIT_BLOB_LITERAL) || defined(SQLITE_HAS_CODEC)
+/*
+** Convert a BLOB literal of the form "x'hhhhhh'" into its binary
+** value. Return a pointer to its binary value. Space to hold the
+** binary value has been obtained from malloc and must be freed by
+** the calling routine.
+*/
+void *sqlite3HexToBlob(sqlite3 *db, const char *z, int n){
+ char *zBlob;
+ int i;
+
+ zBlob = (char *)sqlite3DbMallocRaw(db, n/2 + 1);
+ n--;
+ if( zBlob ){
+ for(i=0; i<n; i+=2){
+ zBlob[i/2] = (hexToInt(z[i])<<4) | hexToInt(z[i+1]);
+ }
+ zBlob[i/2] = 0;
+ }
+ return zBlob;
+}
+#endif /* !SQLITE_OMIT_BLOB_LITERAL || SQLITE_HAS_CODEC */
+
+
+/*
+** Change the sqlite.magic from SQLITE_MAGIC_OPEN to SQLITE_MAGIC_BUSY.
+** Return an error (non-zero) if the magic was not SQLITE_MAGIC_OPEN
+** when this routine is called.
+**
+** This routine is called when entering an SQLite API. The SQLITE_MAGIC_OPEN
+** value indicates that the database connection passed into the API is
+** open and is not being used by another thread. By changing the value
+** to SQLITE_MAGIC_BUSY we indicate that the connection is in use.
+** sqlite3SafetyOff() below will change the value back to SQLITE_MAGIC_OPEN
+** when the API exits.
+**
+** This routine is a attempt to detect if two threads use the
+** same sqlite* pointer at the same time. There is a race
+** condition so it is possible that the error is not detected.
+** But usually the problem will be seen. The result will be an
+** error which can be used to debug the application that is
+** using SQLite incorrectly.
+**
+** Ticket #202: If db->magic is not a valid open value, take care not
+** to modify the db structure at all. It could be that db is a stale
+** pointer. In other words, it could be that there has been a prior
+** call to sqlite3_close(db) and db has been deallocated. And we do
+** not want to write into deallocated memory.
+*/
+#ifdef SQLITE_DEBUG
+int sqlite3SafetyOn(sqlite3 *db){
+ if( db->magic==SQLITE_MAGIC_OPEN ){
+ db->magic = SQLITE_MAGIC_BUSY;
+ assert( sqlite3_mutex_held(db->mutex) );
+ return 0;
+ }else if( db->magic==SQLITE_MAGIC_BUSY ){
+ db->magic = SQLITE_MAGIC_ERROR;
+ db->u1.isInterrupted = 1;
+ }
+ return 1;
+}
+#endif
+
+/*
+** Change the magic from SQLITE_MAGIC_BUSY to SQLITE_MAGIC_OPEN.
+** Return an error (non-zero) if the magic was not SQLITE_MAGIC_BUSY
+** when this routine is called.
+*/
+#ifdef SQLITE_DEBUG
+int sqlite3SafetyOff(sqlite3 *db){
+ if( db->magic==SQLITE_MAGIC_BUSY ){
+ db->magic = SQLITE_MAGIC_OPEN;
+ assert( sqlite3_mutex_held(db->mutex) );
+ return 0;
+ }else{
+ db->magic = SQLITE_MAGIC_ERROR;
+ db->u1.isInterrupted = 1;
+ return 1;
+ }
+}
+#endif
+
+/*
+** Check to make sure we have a valid db pointer. This test is not
+** foolproof but it does provide some measure of protection against
+** misuse of the interface such as passing in db pointers that are
+** NULL or which have been previously closed. If this routine returns
+** 1 it means that the db pointer is valid and 0 if it should not be
+** dereferenced for any reason. The calling function should invoke
+** SQLITE_MISUSE immediately.
+**
+** sqlite3SafetyCheckOk() requires that the db pointer be valid for
+** use. sqlite3SafetyCheckSickOrOk() allows a db pointer that failed to
+** open properly and is not fit for general use but which can be
+** used as an argument to sqlite3_errmsg() or sqlite3_close().
+*/
+int sqlite3SafetyCheckOk(sqlite3 *db){
+ u32 magic;
+ if( db==0 ) return 0;
+ magic = db->magic;
+ if( magic!=SQLITE_MAGIC_OPEN
+#ifdef SQLITE_DEBUG
+ && magic!=SQLITE_MAGIC_BUSY
+#endif
+ ){
+ return 0;
+ }else{
+ return 1;
+ }
+}
+int sqlite3SafetyCheckSickOrOk(sqlite3 *db){
+ u32 magic;
+ magic = db->magic;
+ if( magic!=SQLITE_MAGIC_SICK &&
+ magic!=SQLITE_MAGIC_OPEN &&
+ magic!=SQLITE_MAGIC_BUSY ) return 0;
+ return 1;
+}
projects / thirdparty / sqlite.git / commitdiff
