-C Reorder\sbounds\schecking\sin\ssqlite3Fp10Convert2()
-D 2026-03-17T09:18:36.777
+C Include\sthe\sfloat-point\stable\sgenerator\sutility\sin\sthe\stools\sdirectory.
+D 2026-03-17T09:45:47.412
F .fossil-settings/binary-glob 61195414528fb3ea9693577e1980230d78a1f8b0a54c78cf1b9b24d0a409ed6a x
F .fossil-settings/empty-dirs dbb81e8fc0401ac46a1491ab34a7f2c7c0452f2f06b54ebb845d024ca8283ef1
F .fossil-settings/ignore-glob 35175cdfcf539b2318cb04a9901442804be81cd677d8b889fcc9149c21f239ea
F src/update.c 3e5e7ff66fa19ebe4d1b113d480639a24cc1175adbefabbd1a948a07f28e37cf
F src/upsert.c 215328c3f91623c520ec8672c44323553f12caeb4f01b1090ebdca99fdf7b4f1
F src/utf.c 7267c3fb9e2467020507601af3354c2446c61f444387e094c779dccd5ca62165
-F src/util.c ced03971dad5ae9418a2ced329506de16e5ff2ed7152e059400499332c1a593b
+F src/util.c cf91389b58590edfb5978199ef59488ef8e3723e1ba1aa0ff15c62f8a658b95f
F src/vacuum.c d3d35d8ae893d419ade5fa196d761a83bddcbb62137a1a157ae751ef38b26e82
F src/vdbe.c 5328c99dd256ee8132383565a86e253543a85daccfd7477c52f20bac6b385a7f
F src/vdbe.h 966d0677a540b7ea6549b7c4e1312fc0d830fce3a235a58c801f2cc31cf5ecf9
F tool/mkccode.tcl c42a8f8cf78f92e83795d5447460dbce7aaf78a3bbf9082f1507dc71a3665f3c x
F tool/mkcombo.tcl 2a5189b219c4a495e1ff7fc980bd568d3cfb82ae9d50c84e77f7a161e96fc132
F tool/mkctimec.tcl 3fb5cad05922f5da61262cb6bcd5868a34e94a49ca8833ae2d7796e7df075576 x
+F tool/mkfptab.c 24ea40113f96584caca3f6dd06b4ad5adffa0f39023910cb83fa7ef2ffa9b0ba
F tool/mkkeywordhash.c 82d5af1d0e677900739fba59155cddac172d8c712c2d91ab73d6e6bcb30060f0
F tool/mkmsvcmin.tcl d76c45efda1cce2d4005bcea7b8a22bb752e3256009f331120fb4fecb14ebb7a
F tool/mkopcodec.tcl 33d20791e191df43209b77d37f0ff0904620b28465cca6990cf8d60da61a07ef
F tool/warnings.sh d924598cf2f55a4ecbc2aeb055c10bd5f48114793e7ba25f9585435da29e7e98
F tool/win/sqlite.vsix deb315d026cc8400325c5863eef847784a219a2f
F tool/winmain.c 00c8fb88e365c9017db14c73d3c78af62194d9644feaf60e220ab0f411f3604c
-P a19c0785dcfb9fb74963c45b161b12ac8f4379e2b990f6c5de0d7b959c5be98d
-R 31509aecbe36d702bbcca4c3d7b1c6e3
+P 23ad656edb3a63e7e6602770e1f2c4a5ef1f3d41565e7f13408b5305619dfa3d
+R 0212d90b78d20068a702d7e70e4b68de
U drh
-Z 3ad3a7a0646ac1e8f0a50096402694d2
+Z a52753c1b6f0991d0a121a4d3cb8bc3e
# Remove this line to create a well-formed Fossil manifest.
** (2) For p outside the range 0 to 26, use aScale[] for the initial value
** then refine that result (if necessary) by a single multiplication
** against aBase[].
+**
+** The constant tables aBase[], aScale[], and aScaleLo[] are generated
+** by the C program at ../tool/mkfptab.c run with the --round option.
*/
static u64 powerOfTen(int p, u32 *pLo){
static const u64 aBase[] = {
UINT64_C(0xf2d56790ab41c2a2), /* 10: 1.0e-81 << 333 */
UINT64_C(0xc428d05aa4751e4c), /* 11: 1.0e-54 << 243 */
UINT64_C(0x9e74d1b791e07e48), /* 12: 1.0e-27 << 153 */
- UINT64_C(0xcccccccccccccccc), /* 13: 1.0e+0 << 63 (Special case) */
+ UINT64_C(0xcccccccccccccccc), /* 13: 1.0e-1 << 67 (special case) */
UINT64_C(0xcecb8f27f4200f3a), /* 14: 1.0e+27 >> 26 */
UINT64_C(0xa70c3c40a64e6c51), /* 15: 1.0e+54 >> 116 */
UINT64_C(0x86f0ac99b4e8dafd), /* 16: 1.0e+81 >> 206 */
0xfae27299, /* 10: 1.0e-81 << 333 */
0xaa97e14c, /* 11: 1.0e-54 << 243 */
0x775ea265, /* 12: 1.0e-27 << 153 */
- 0xcccccccc, /* 13: 1.0e-1 << 67 (Special case) */
+ 0xcccccccc, /* 13: 1.0e-1 << 67 (special case) */
0x00000000, /* 14: 1.0e+27 >> 26 */
0x999090b6, /* 15: 1.0e+54 >> 116 */
0x69a028bb, /* 16: 1.0e+81 >> 206 */
--- /dev/null
+/*
+** This program generates C code for the tables used to generate powers
+** of 10 in the powerOfTen() subroutine in util.c.
+**
+** The objective of the powerOfTen() subroutine is to provide the most
+** significant 96 bits of any power of 10 between -348 and +347. Rather
+** than generate a massive 8K table, three much smaller tables are constructed,
+** which can then generate the requested power of 10 using a single
+** 160-bit multiple.
+**
+** This program works by internally generating a table of powers of
+** 10 accurate to 256 bits each. It then that full-sized, high-accuracy
+** table to construct the three smaller tables needed by powerOfTen().
+**
+** LIMITATION:
+**
+** This program uses the __uint128_t datatype, available in gcc/clang.
+** It won't build using other compilers.
+*/
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <assert.h>
+
+typedef unsigned __int128 u128; /* 128-bit unsigned integer */
+typedef unsigned long long int u64; /* 64-bit unsigned integer */
+
+/* There is no native 256-bit unsigned integer type, so synthesize one
+** using four 64-bit unsigned integers. Must significant first. */
+struct u256 {
+ u64 a[4]; /* big-endian */
+};
+typedef struct u256 u256;
+
+/*
+** Return a u64 with the N-th bit set.
+*/
+#define U64_BIT(N) (((u64)1)<<(N))
+
+/* Multiple *pX by 10, in-place */
+static void u256_times_10(u256 *pX){
+ u64 carry = 0;
+ int i;
+ for(i=3; i>=0; i--){
+ u128 y = (10 * (u128)pX->a[i]) + carry;
+ pX->a[i] = (u64)y;
+ carry = (u64)(y>>64);
+ }
+}
+
+/* Multiple *pX by 2, in-place. AKA, left-shift */
+static void u256_times_2(u256 *pX){
+ u64 carry = 0;
+ int i;
+ for(i=3; i>=0; i--){
+ u64 y = pX->a[i];
+ pX->a[i] = (y<<1) | carry;
+ carry = y>>63;
+ }
+}
+
+/* Divide *pX by 10, in-place */
+static void u256_div_10(u256 *pX){
+ u64 rem = 0;
+ int i;
+ for(i=0; i<4; i++){
+ u128 acc = (((u128)rem)<<64) | pX->a[i];
+ pX->a[i] = acc/10;
+ rem = (u64)(acc%10);
+ }
+}
+
+/* Divide *pX by 2, in-place, AKA, right-shift */
+static void u256_div_2(u256 *pX){
+ u64 rem = 0;
+ int i;
+ for(i=0; i<4; i++){
+ u64 y = pX->a[i];
+ pX->a[i] = (y>>1) | (rem<<63);
+ rem = y&1;
+ }
+}
+
+/* Note: The main table is a little larger on the low end than the required
+** range of -348..+347, since we need the -351 value for the reduced tables.
+*/
+#define SCALE_FIRST (-351) /* Least power-of-10 */
+#define SCALE_LAST (+347) /* Largest power-of-10 */
+#define SCALE_COUNT (SCALE_LAST - SCALE_FIRST + 1) /* Size of main table */
+#define SCALE_ZERO (351)
+
+int main(int argc, char **argv){
+ int i, j, iNext;
+ int e;
+ int bRound = 0;
+ int bTruth = 0;
+ const u64 top = ((u64)1)<<63;
+ u256 v;
+ u64 aHi[SCALE_COUNT];
+ u64 aLo[SCALE_COUNT];
+ int aE[SCALE_COUNT];
+
+ for(i=1; i<argc; i++){
+ const char *z = argv[i];
+ if( z[0]=='-' && z[1]=='-' && z[2]!=0 ) z++;
+ if( strcmp(z,"-round")==0 ){
+ bRound = 1;
+ }else
+ if( strcmp(z,"-truth")==0 ){
+ bTruth = 1;
+ }else
+ {
+ fprintf(stderr, "unknown option: \"%s\"\n", argv[i]);
+ exit(1);
+ }
+ }
+
+ /* Generate the master 256-bit power-of-10 table */
+ v.a[0] = top;
+ v.a[1] = 0;
+ v.a[2] = 0;
+ v.a[3] = 0;
+ for(i=SCALE_ZERO, e=63; i>=0; i--){
+ aHi[i] = v.a[0];
+ aLo[i] = v.a[1];
+ aE[i] = e;
+ u256_div_10(&v);
+ while( v.a[0] < top ){
+ e++;
+ u256_times_2(&v);
+ }
+ }
+ v.a[0] = 0;
+ v.a[1] = top;
+ v.a[2] = 0;
+ v.a[3] = 0;
+ for(i=SCALE_ZERO+1, e=63; i<SCALE_COUNT; i++){
+ u256_times_10(&v);
+ while( v.a[0]>0 ){
+ e--;
+ u256_div_2(&v);
+ }
+ aHi[i] = v.a[1];
+ aLo[i] = v.a[2];
+ aE[i] = e;
+ }
+
+ if( bTruth ){
+ /* With the --truth flag, also output the aTruth[] table that
+ ** contains 128 bits of every power-of-two in the range */
+ printf(" /* Powers of ten, accurate to 128 bits each */\n");
+ printf(" static const struct {u64 hi; u64 lo;} aTruth[] = {\n");
+ for(i=0; i<SCALE_COUNT; i++){
+ u64 x = aHi[i];
+ u64 y = aLo[i];
+ int e = aE[i];
+ char *zOp;
+ if( e>0 ){
+ zOp = "<<";
+ }else{
+ e = -e;
+ zOp = ">>";
+ }
+ printf(" {0x%016llx, 0x%016llx}, /* %2d: 1.0e%+d %s %d */\n",
+ x, y, i, i+SCALE_FIRST, zOp, e);
+ }
+ printf(" };\n");
+ }
+
+ /* The aBase[] table contains powers of 10 between 0 and 26. These
+ ** all fit in a single 64-bit integer.
+ */
+ printf(" static const u64 aBase[] = {\n");
+ for(i=SCALE_ZERO, j=0; i<SCALE_ZERO+27; i++, j++){
+ u64 x = aHi[i];
+ int e = aE[i];
+ char *zOp;
+ if( e>0 ){
+ zOp = "<<";
+ }else{
+ e = -e;
+ zOp = ">>";
+ }
+ printf(" UINT64_C(0x%016llx), /* %2d: 1.0e%+d %s %d */\n",
+ x, j, i+SCALE_FIRST, zOp, e);
+ }
+ printf(" };\n");
+
+ /* For powers of 10 outside the range [0..26], we have to multiple
+ ** on of the aBase[] entries by a scaling factor to get the true
+ ** power of ten. The scaling factors are all approximates accurate
+ ** to 96 bytes, represented by a 64-bit integer in aScale[] for the
+ ** most significant bits and a 32-bit integer in aScaleLo[] for the
+ ** next 32 bites.
+ **
+ ** The scale factors are at increments of 27. Except, the entry for 0
+ ** is replaced by the -1 value as a special case.
+ */
+ printf(" static const u64 aScale[] = {\n");
+ for(i=j=0; i<SCALE_COUNT; i=iNext, j++){
+ const char *zExtra = "";
+ iNext = i+27;
+ if( i==SCALE_ZERO ){ i--; zExtra = " (special case)"; }
+ u64 x = aHi[i];
+ int e = aE[i];
+ char *zOp;
+ if( e>0 ){
+ zOp = "<<";
+ }else{
+ e = -e;
+ zOp = ">>";
+ }
+ printf(" UINT64_C(0x%016llx), /* %2d: 1.0e%+d %s %d%s */\n",
+ x, j, i+SCALE_FIRST, zOp, e, zExtra);
+ }
+ printf(" };\n");
+ printf(" static const unsigned int aScaleLo[] = {\n");
+ for(i=j=0; i<SCALE_COUNT; i=iNext, j++){
+ const char *zExtra = "";
+ iNext = i+27;
+ if( i==SCALE_ZERO ){ i--; zExtra = " (special case)"; }
+ u64 x = aLo[i];
+ int e = aE[i];
+ char *zOp;
+ if( bRound && (x & U64_BIT(31))!=0 && i!=SCALE_ZERO-1 ) x += U64_BIT(32);
+ if( e>0 ){
+ zOp = "<<";
+ }else{
+ e = -e;
+ zOp = ">>";
+ }
+ printf(" 0x%08llx, /* %2d: 1.0e%+d %s %d%s */\n",
+ x>>32, j, i+SCALE_FIRST, zOp, e, zExtra);
+ }
+ printf(" };\n");
+ return 0;
+}
projects / thirdparty / sqlite.git / commitdiff
