c/libxlsxwriter
1
0
Fork 0
mirror of https://github.com/jmcnamara/libxlsxwriter synced 2025-03-28 21:13:14 +00:00
Code Issues Packages Projects Releases Wiki Activity

Added optional third party dtoa library.

Browse Source 
Added the optional Milo Yip DTOA library (emyg_dtoa) to avoid
issues where the standard sprintf() dtoa function changes output
based on locale settings. It is also 40-50% faster than the
standard dtoa for raw numeric data.

If you wish to use this third party library you can compile
libxlsxwriter with it by passing `USE_DTOA_LIBRARY=1` to
make. The USE_DOUBLE_FUNCTION build variable is no longer used.

Imported source from https://github.com/miloyip/dtoa-benchmark

Feature request #272
This commit is contained in:
John McNamara 2021-07-11 13:40:35 +01:00
parent 393ded9a2d
commit bda599d033
23 changed files with 711 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.travis.yml
View File

@ -10,7 +10,7 @@ env:
- NO_VALGRIND=1 USE_STANDARD_TMPFILE=1 CFLAGS='-Werror'
- NO_VALGRIND=1 CFLAGS='-Werror -m32'
- NO_VALGRIND=1 USE_SYSTEM_MINIZIP=1 CFLAGS='-Werror'
- NO_VALGRIND=1 USE_DOUBLE_FUNCTION=1 CFLAGS='-Werror'
- NO_VALGRIND=1 USE_DTOA_LIBRARY=1 CFLAGS='-Werror'
- NO_VALGRIND=1 USE_NO_MD5=1 CFLAGS='-Werror'
- NO_VALGRIND=1 USE_OPENSSL_MD5=1 CFLAGS='-Werror'
- NO_VALGRIND=1 USE_FMEMOPEN=1 CFLAGS='-Werror'

16
CMakeLists.txt
View File

@ -47,6 +47,12 @@
# during configuration. This may produce bugs while cross-
# compiling or using MinGW/MSYS.
#
# USE_DTOA_LIBRARY
# Use the third party emyg_dtoa() library (default off). The
# emyg_dtoa() library is used to avoid sprintf double issues with
# different locale settings. To enable this library, pass
# `-DUSE_DTOA_LIBRARY=ON` during configuration.
#
# USE_NO_MD5
# Compile without third party MD5 support. This will turn off the
# functionality of avoiding duplicate image files in the output xlsx
@ -127,7 +133,7 @@ option(USE_NO_MD5 "Build libxlsxwriter without third party MD5 lib" OFF)
option(USE_OPENSSL_MD5 "Build libxlsxwriter with the OpenSSL MD5 lib" OFF)
option(USE_FMEMOPEN "Use fmemopen() in place of some temporary files" OFF)
option(IOAPI_NO_64 "Disable 64-bit filesystem support" OFF)
option(USE_DOUBLE_FUNCTION "Build libxlsxwriter with locale independent double" OFF)
option(USE_DTOA_LIBRARY "Use the locale independent third party Milo Yip DTOA library" OFF)
if(MSVC)
option(USE_STATIC_MSVC_RUNTIME "Use the static runtime library" OFF)
@ -163,8 +169,8 @@ if(USE_FMEMOPEN)
list(APPEND LXW_PRIVATE_COMPILE_DEFINITIONS USE_FMEMOPEN)
endif()
if(USE_DOUBLE_FUNCTION)
list(APPEND LXW_PRIVATE_COMPILE_DEFINITIONS USE_DOUBLE_FUNCTION)
if(USE_DTOA_LIBRARY)
list(APPEND LXW_PRIVATE_COMPILE_DEFINITIONS USE_DTOA_LIBRARY)
endif()
if(NOT BUILD_SHARED_LIBS)
@ -260,6 +266,10 @@ if(USE_OPENSSL_MD5)
endif()
endif()
if (USE_DTOA_LIBRARY)
list(APPEND LXW_SOURCES third_party/dtoa/emyg_dtoa.c)
endif()
set(LXW_PROJECT_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
set(LXW_LIB_DIR "${LXW_PROJECT_DIR}/lib")
add_library(${PROJECT_NAME} "")

35
License.txt
View File

@ -35,8 +35,8 @@ Libxlsxwriter is released under a FreeBSD license:
Libxlsxwriter includes `queue.h` and `tree.h` from FreeBSD, the `minizip`
component of `zlib`, `tmpfileplus` and `md5` which have the following
licenses:
component of `zlib`. It also includes and uses the optional `tmpfileplus`,
`md5` and `emyg_dtoa`. These components which have the following licenses:
Queue.h from FreeBSD:
@ -147,6 +147,37 @@ See the [Mozilla Public License, v. 2.0](http://mozilla.org/MPL/2.0/).
Note, it is possible to compile libxlsxwriter using the standard library
`tmpfile()` function instead of `tmpfileplus`, see @ref gsg_tmpdir.
The [Milo Yip DTOA library](https://github.com/miloyip/dtoa-benchmark) for
converting doubles to strings. It has the following license:
Copyright (C) 2015 Doug Currie
based on dtoa_milo.h
Copyright (C) 2014 Milo Yip
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
This Milo Yip DTOA library (emyg_dtoa) is uses to avoid issues where the
standard sprintf() dtoa function changes output based on locale settings. It
is also 40-50% faster than the standard dtoa for raw numeric data. The use of
this library is optional. If you wish to use it you can pass
`USE_DTOA_LIBRARY=1` to make when compiling.
[Openwall MD5](https://openwall.info/wiki/people/solar/software/public-domain-source-code/md5)
has the following licence:

5
Makefile
View File

@ -33,12 +33,14 @@ endif
ifndef USE_STANDARD_TMPFILE
$(Q)$(MAKE) -C third_party/tmpfileplus
endif
ifndef USE_NO_MD5
ifndef USE_OPENSSL_MD5
$(Q)$(MAKE) -C third_party/md5
endif
endif
ifdef USE_DTOA_LIBRARY
$(Q)$(MAKE) -C third_party/dtoa
endif
# Build a macOS universal binary.
universal_binary :
@ -73,6 +75,7 @@ clean :
$(Q)$(MAKE) clean -C third_party/minizip
$(Q)$(MAKE) clean -C third_party/tmpfileplus
$(Q)$(MAKE) clean -C third_party/md5
$(Q)$(MAKE) clean -C third_party/dtoa
# Run the unit tests.
test : all test_unit test_functional

20
docs/src/getting_started.dox
View File

@ -659,6 +659,26 @@ Libxlsxwriter can be compiled on a big endian system as follows:
make USE_BIG_ENDIAN=1
@section gsg_dtoa Using a double formatting library
Excel uses an IEEE 754 doubles for all numeric values. These values are stored
in standard `sprintf(...,"%.16G",...)` formatting as numbers like "1234.56" or
"456E+123". However in some locales, such as "de_DE" these numbers can be
stored with the locale specific decimal place like "1234,56" which causes
Excel to give an error when it loads the file.
It some cases this issue can be resolved by using the `setlocale()` or
`uselocale()` functions in your application. Alternatively you can compile
libxlsxwriter with support for a third party `dtoa()` (decimal to ascii)
function. Currently libxlsxwriter uses the [Milo Yip DTOA
library](https://github.com/miloyip/dtoa-benchmark) as an optional
compilation. This avoids the locale sprintf issue and it is also 40-50% faster
than the standard dtoa for raw numeric data.
If you wish to use it you can pass "USE_DTOA_LIBRARY=1" to `make` or
"-DUSE_DTOA_LIBRARY=ON" to cmake.
@section gsg_next Next steps
If you got libxlsxwriter built and working successfully then the next sections

12
docs/src/working_with_memory.dox
View File

@ -5,12 +5,9 @@
@section ww_mem_constant Constant Memory Mode
By default libxlsxwriter holds all cell data in memory. This is to allow
non-sequential data storage and also to allow future features where formatting
is applied separately from the data.
The effect of this is that for large files libxlsxwriter can consume a lot of
memory.
By default libxlsxwriter holds all cell data in memory to allow non-sequential
data storage. The effect of this is that for large files libxlsxwriter can
consume a lot of memory.
Fortunately, this memory usage can be reduced almost completely by using
workbook_new_opt() and the lxw_workbook_options `constant_memory` property:
@ -91,6 +88,9 @@ depending on the amount of repeated string data.
Currently the library is optimized but not highly optimized. Also, the library
is currently single threaded.
Compiling with the embedded but option dtoa library is 40-50% faster for raw
numeric data. See @ref gsg_dtoa.
Next: @ref working_with_macros

3
examples/Makefile
View File

@ -38,6 +38,9 @@ $(LIBXLSXWRITER):
ifndef USE_STANDARD_TMPFILE
$(Q)$(MAKE) -C ../third_party/tmpfileplus
endif
ifndef USE_STANDARD_DOUBLE
$(Q)$(MAKE) -C ../third_party/dtoa
endif
ifndef USE_NO_MD5
$(Q)$(MAKE) -C ../third_party/md5
endif

26
include/xlsxwriter/third_party/emyg_dtoa.h vendored Normal file
View File

@ -0,0 +1,26 @@
/* emyg_dtoa.h
** Copyright (C) 2015 Doug Currie
** based on dtoa_milo.h
** Copyright (C) 2014 Milo Yip
**
** Permission is hereby granted, free of charge, to any person obtaining a copy
** of this software and associated documentation files (the "Software"), to deal
** in the Software without restriction, including without limitation the rights
** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
** copies of the Software, and to permit persons to whom the Software is
** furnished to do so, subject to the following conditions:
**
** The above copyright notice and this permission notice shall be included in
** all copies or substantial portions of the Software.
**
** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
** THE SOFTWARE.
*/
/* Source from https://github.com/miloyip/dtoa-benchmark */
void emyg_dtoa (double value, char* buffer);

10
include/xlsxwriter/utility.h
View File

@ -235,13 +235,15 @@ void lxw_str_tolower(char *str);
FILE *lxw_tmpfile(char *tmpdir);
FILE *lxw_fopen(const char *filename, const char *mode);
/* Use a user defined function to format doubles in sprintf or else a simple
* macro (the default). */
#ifdef USE_DOUBLE_FUNCTION
/* Use the third party dtoa function to avoid locale issues with sprintf
* double formatting. Otherwise we use a simple macro that falls back to the
* default c-lib sprintf.
*/
#ifdef USE_DTOA_LIBRARY
int lxw_sprintf_dbl(char *data, double number);
#else
#define lxw_sprintf_dbl(data, number) \
lxw_snprintf(data, LXW_ATTR_32, "%.16g", number)
lxw_snprintf(data, LXW_ATTR_32, "%.16G", number)
#endif
uint16_t lxw_hash_password(const char *password);

15
src/Makefile
View File

@ -64,9 +64,12 @@ ifdef USE_BIG_ENDIAN
CFLAGS += -DLXW_BIG_ENDIAN
endif
# Use a user-defined double number formatting function.
ifdef USE_DOUBLE_FUNCTION
CFLAGS += -DUSE_DOUBLE_FUNCTION
# Use a third party double number formatting function.
ifdef USE_DTOA_LIBRARY
CFLAGS += -DUSE_DTOA_LIBRARY
DTOA_LIB_DIR = ../third_party/dtoa
DTOA_LIB_OBJ = $(DTOA_LIB_DIR)/emyg_dtoa.o
DTOA_LIB_SO = $(DTOA_LIB_DIR)/emyg_dtoa.so
endif
# Use fmemopen() to avoid creating certain temporary files
@ -152,7 +155,7 @@ test_lib : libxlsxwriter_test.a
# The static library.
$(LIBXLSXWRITER_A) : $(OBJS)
$(Q)$(AR) $(ARFLAGS) $@ $(MINIZIP_OBJ) $(TMPFILEPLUS_OBJ) $(MD5_OBJ) $^
$(Q)$(AR) $(ARFLAGS) $@ $(MINIZIP_OBJ) $(TMPFILEPLUS_OBJ) $(DTOA_LIB_OBJ) $(MD5_OBJ) $^
# The dynamic library.
ifeq ($(findstring m32,$(CFLAGS)),m32)
@ -160,11 +163,11 @@ ARCH = -m32
endif
$(LIBXLSXWRITER_SO) : $(SOBJS)
$(Q)$(CC) $(LDFLAGS) $(SOFLAGS) $(ARCH) $(TARGET_ARCH) -o $@ $(MINIZIP_SO) $(TMPFILEPLUS_SO) $(MD5_SO) $^ $(LIBS)
$(Q)$(CC) $(LDFLAGS) $(SOFLAGS) $(ARCH) $(TARGET_ARCH) -o $@ $(MINIZIP_SO) $(TMPFILEPLUS_SO) $(MD5_SO) $(DTOA_LIB_SO) $^ $(LIBS)
# The test library.
$(LIBXLSXWRITER_TO) : $(TOBJS)
$(Q)$(AR) $(ARFLAGS) $@ $(MINIZIP_OBJ) $(TMPFILEPLUS_OBJ) $(MD5_OBJ) $^
$(Q)$(AR) $(ARFLAGS) $@ $(MINIZIP_OBJ) $(TMPFILEPLUS_OBJ) $(DTOA_LIB_SO) $(MD5_OBJ) $^
# Minimal target for quick compile without creating the libs.
test_compile : $(OBJS)

25
src/utility.c
View File

@ -16,6 +16,10 @@
#include "xlsxwriter/common.h"
#include "xlsxwriter/third_party/tmpfileplus.h"
#ifdef USE_DTOA_LIBRARY
#include "xlsxwriter/third_party/emyg_dtoa.h"
#endif
char *error_strings[LXW_MAX_ERRNO + 1] = {
"No error.",
"Memory error, failed to malloc() required memory.",
@ -575,27 +579,14 @@ lxw_tmpfile(char *tmpdir)
}
/*
* Sample function to handle sprintf of doubles for locale portable code. This
* is usually handled by a lxw_sprintf_dbl() macro but it can be replaced with
* a function of the same name.
*
* The code below is a simplified example that changes numbers like 123,45 to
* 123.45. End-users can replace this with something more rigorous if
* required.
* Use third party function to handle sprintf of doubles for locale portable
* code.
*/
#ifdef USE_DOUBLE_FUNCTION
#ifdef USE_DTOA_LIBRARY
int
lxw_sprintf_dbl(char *data, double number)
{
char *tmp;
lxw_snprintf(data, LXW_ATTR_32, "%.16g", number);
/* Replace comma with decimal point. */
tmp = strchr(data, ',');
if (tmp)
*tmp = '.';
emyg_dtoa(number, data);
return 0;
}
#endif

6
src/worksheet.c
View File

@ -3643,7 +3643,7 @@ STATIC void
_write_number_cell(lxw_worksheet *self, char *range,
int32_t style_index, lxw_cell *cell)
{
#ifdef USE_DOUBLE_FUNCTION
#ifdef USE_DTOA_LIBRARY
char data[LXW_ATTR_32];
lxw_sprintf_dbl(data, cell->u.number);
@ -3657,11 +3657,11 @@ _write_number_cell(lxw_worksheet *self, char *range,
#else
if (style_index)
fprintf(self->file,
"<c r=\"%s\" s=\"%d\"><v>%.16g</v></c>",
"<c r=\"%s\" s=\"%d\"><v>%.16G</v></c>",
range, style_index, cell->u.number);
else
fprintf(self->file,
"<c r=\"%s\"><v>%.16g</v></c>", range, cell->u.number);
"<c r=\"%s\"><v>%.16G</v></c>", range, cell->u.number);
#endif
}

6
test/functional/src/Makefile
View File

@ -42,9 +42,9 @@ ifdef USE_OPENSSL_MD5
LIBS += -lcrypto
endif
# Use a user-defined double number formatting function.
ifdef USE_DOUBLE_FUNCTION
CFLAGS += -DUSE_DOUBLE_FUNCTION
# Use a third party double number formatting function.
ifdef USE_DTOA_LIBRARY
CFLAGS += -DUSE_DTOA_LIBRARY
endif
all : $(LIBXLSXWRITER) $(EXES)

2
test/functional/src/test_data08.c
View File

@ -13,7 +13,7 @@
int main() {
/* Test that the module works if the locale is changed. */
#ifdef USE_DOUBLE_FUNCTION
#ifdef USE_DTOA_LIBRARY
setlocale(LC_NUMERIC, "de_DE");
#endif

34
test/functional/src/test_types11.c Normal file
View File

@ -0,0 +1,34 @@
/*****************************************************************************
* Test cases for libxlsxwriter.
*
* Test to compare output against Excel files.
*
* Copyright 2014-2020, John McNamara, jmcnamara@cpan.org
*
*/
#include "xlsxwriter.h"
int main() {
lxw_workbook *workbook = workbook_new("test_types11.xlsx");
lxw_worksheet *worksheet = workbook_add_worksheet(workbook, NULL);
worksheet_set_column(worksheet, 0, 0, 32, NULL);
/* Test floating point formatting. */
worksheet_write_number(worksheet, 0, 0, 0, NULL);
worksheet_write_number(worksheet, 1, 0, 1, NULL);
worksheet_write_number(worksheet, 2, 0, -1, NULL);
worksheet_write_number(worksheet, 3, 0, 1.2, NULL);
worksheet_write_number(worksheet, 4, 0, -1.2, NULL);
worksheet_write_number(worksheet, 5, 0, 1.2E8, NULL);
worksheet_write_number(worksheet, 6, 0, 1.2E+20, NULL);
worksheet_write_number(worksheet, 7, 0, 1.2E-20, NULL);
worksheet_write_number(worksheet, 8, 0, -1.2E+20, NULL);
worksheet_write_number(worksheet, 9, 0, -1.2E-20, NULL);
worksheet_write_number(worksheet, 10, 0, 1.E+100, NULL);
worksheet_write_number(worksheet, 11, 0, 1.E-100, NULL);
return workbook_close(workbook);
}

3
test/functional/test_types.py
View File

@ -18,3 +18,6 @@ class TestCompareXLSXFiles(base_test_class.XLSXBaseTest):
def test_types08(self):
self.run_exe_test('test_types08')
def test_types11(self):
self.run_exe_test('test_types11')

BIN
test/functional/xlsx_files/types11.xlsx Normal file
View File

Binary file not shown.

5
test/unit/Makefile
View File

@ -58,11 +58,6 @@ endif
# End of LIBS
# Use a user-defined double number formatting function.
ifdef USE_DOUBLE_FUNCTION
CFLAGS += -DUSE_DOUBLE_FUNCTION
endif
# House-keeping build targets.
all :
$(Q)$(MAKE) -C utility

7
test/unit/Makefile.unit
View File

@ -36,10 +36,9 @@ ifdef USE_OPENSSL_MD5
LIBS_O += -lcrypto
endif
# Use a user-defined double number formatting function.
ifdef USE_DOUBLE_FUNCTION
CFLAGS += -DUSE_DOUBLE_FUNCTION
# Use a third party double number formatting function.
ifdef USE_DTOA_LIBRARY
CFLAGS += -DUSE_DTOA_LIBRARY
endif
# Make all the individual tests.

42
third_party/dtoa/Makefile vendored Normal file
View File

@ -0,0 +1,42 @@
###############################################################################
#
# Simplied Makefile to build the emyg_dtoa library for libxlsxwriter.
#
# Keep the output quiet by default.
Q=@
ifdef V
Q=
endif
UNAME := $(shell uname)
# Check for MinGW/MinGW64/Cygwin environments.
ifneq (,$(findstring MINGW, $(UNAME)))
MING_LIKE = y
endif
ifneq (,$(findstring MSYS, $(UNAME)))
MING_LIKE = y
endif
ifneq (,$(findstring CYGWIN, $(UNAME)))
MING_LIKE = y
endif
FPIC = -fPIC
# Change make options on MinGW/MinGW64/Cygwin.
ifdef MING_LIKE
FPIC =
CC = gcc
endif
all: emyg_dtoa.o emyg_dtoa.so
%.o : %.c
$(Q)$(CC) -c $(CFLAGS) $<
%.so : %.c
$(Q)$(CC) $(FPIC) -c $(CFLAGS) $< -o $@
clean:
$(Q)/bin/rm -f *.o *.so

461
third_party/dtoa/emyg_dtoa.c vendored Normal file
View File

@ -0,0 +1,461 @@
/* emyg_dtoa.c
** Copyright (C) 2015 Doug Currie
** based on dtoa_milo.h
** Copyright (C) 2014 Milo Yip
**
** Permission is hereby granted, free of charge, to any person obtaining a copy
** of this software and associated documentation files (the "Software"), to deal
** in the Software without restriction, including without limitation the rights
** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
** copies of the Software, and to permit persons to whom the Software is
** furnished to do so, subject to the following conditions:
**
** The above copyright notice and this permission notice shall be included in
** all copies or substantial portions of the Software.
**
** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
** THE SOFTWARE.
*/
/* This code is a mostly mechanical translation of Milo Yip's C++ version of
** Grisu2 to C. For algorithm information, see Loitsch, Florian. "Printing
** floating-point numbers quickly and accurately with integers." ACM Sigplan
** Notices 45.6 (2010): 233-243.
*/
/* Source from https://github.com/miloyip/dtoa-benchmark */
#include <assert.h>
#include <math.h>
#if defined(_MSC_VER)
#include <stdint.h>
#include <intrin.h>
#include <float.h>
#else
#include <stdint.h>
#endif
#include <string.h>
#include "emyg_dtoa.h"
#define UINT64_C2(h, l) (((uint64_t )(h) << 32) | (uint64_t )(l))
typedef struct DiyFp_s {
uint64_t f;
int e;
} DiyFp;
static const int kDiySignificandSize = 64;
static const int kDpSignificandSize = 52;
static const int kDpExponentBias = 0x3FF + 52;
static const int kDpMinExponent = -0x3FF - 52;
static const uint64_t kDpExponentMask = UINT64_C2(0x7FF00000, 0x00000000);
static const uint64_t kDpSignificandMask = UINT64_C2(0x000FFFFF, 0xFFFFFFFF);
static const uint64_t kDpHiddenBit = UINT64_C2(0x00100000, 0x00000000);
static __inline DiyFp DiyFp_from_parts (uint64_t f, int e) {
DiyFp fp;
fp.f = f;
fp.e = e;
return fp;
}
DiyFp DiyFp_from_double (double d) {
DiyFp res;
int biased_e;
uint64_t significand;
union {
double d;
uint64_t u64;
} u;
u.d = d;
biased_e = (u.u64 & kDpExponentMask) >> kDpSignificandSize;
significand = (u.u64 & kDpSignificandMask);
if (biased_e != 0) {
res.f = significand + kDpHiddenBit;
res.e = biased_e - kDpExponentBias;
}
else {
res.f = significand;
res.e = kDpMinExponent + 1;
}
return res;
}
static __inline DiyFp DiyFp_subtract (const DiyFp lhs, const DiyFp rhs) {
assert(lhs.e == rhs.e);
assert(lhs.f >= rhs.f);
return DiyFp_from_parts(lhs.f - rhs.f, lhs.e);
}
static __inline DiyFp DiyFp_multiply (const DiyFp lhs, const DiyFp rhs) {
#if defined(_MSC_VER) && defined(_M_AMD64)
uint64_t h;
uint64_t l = _umul128(lhs.f, rhs.f, &h);
/* Handle rounding. */
if (l & ((uint64_t)1u << 63))
h++;
return DiyFp_from_parts(h, lhs.e + rhs.e + 64);
#elif ((__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6) || __clang_major__ >= 9) && defined(__x86_64__))
unsigned __int128 p = (unsigned __int128 )(lhs.f) * (unsigned __int128 )(rhs.f);
uint64_t h = p >> 64;
uint64_t l = (uint64_t )(p);
/* Handle rounding. */
if (l & ((uint64_t)1u << 63))
h++;
return DiyFp_from_parts(h, lhs.e + rhs.e + 64);
#else
const uint64_t M32 = 0xFFFFFFFF;
const uint64_t a = lhs.f >> 32;
const uint64_t b = lhs.f & M32;
const uint64_t c = rhs.f >> 32;
const uint64_t d = rhs.f & M32;
const uint64_t ac = a * c;
const uint64_t bc = b * c;
const uint64_t ad = a * d;
const uint64_t bd = b * d;
uint64_t tmp = (bd >> 32) + (ad & M32) + (bc & M32);
tmp += 1U << 31; /* mult_round */
return DiyFp_from_parts(ac + (ad >> 32) + (bc >> 32) + (tmp >> 32), lhs.e + rhs.e + 64);
#endif
}
static __inline DiyFp Normalize (const DiyFp lhs) {
#if defined(_MSC_VER) && defined(_M_AMD64)
unsigned long index;
_BitScanReverse64(&index, lhs.f);
return DiyFp_from_parts(lhs.f << (63 - index), lhs.e - (63 - index));
#elif defined(__GNUC__)
int s = __builtin_clzll(lhs.f);
return DiyFp_from_parts(lhs.f << s, lhs.e - s);
#else
DiyFp res = lhs;
while (!(res.f & kDpHiddenBit)) {
res.f <<= 1;
res.e--;
}
res.f <<= (kDiySignificandSize - kDpSignificandSize - 1);
res.e = res.e - (kDiySignificandSize - kDpSignificandSize - 1);
return res;
#endif
}
static __inline DiyFp NormalizeBoundary (const DiyFp lhs) {
#if defined(_MSC_VER) && defined(_M_AMD64)
unsigned long index;
_BitScanReverse64(&index, lhs.f);
return DiyFp_from_parts(lhs.f << (63 - index), lhs.e - (63 - index));
#else
DiyFp res = lhs;
while (!(res.f & (kDpHiddenBit << 1))) {
res.f <<= 1;
res.e--;
}
res.f <<= (kDiySignificandSize - kDpSignificandSize - 2);
res.e = res.e - (kDiySignificandSize - kDpSignificandSize - 2);
return res;
#endif
}
static __inline void NormalizedBoundaries (DiyFp lhs, DiyFp* minus, DiyFp* plus) {
DiyFp pl = NormalizeBoundary(DiyFp_from_parts((lhs.f << 1) + 1, lhs.e - 1));
DiyFp mi = (lhs.f == kDpHiddenBit)
? DiyFp_from_parts((lhs.f << 2) - 1, lhs.e - 2)
: DiyFp_from_parts((lhs.f << 1) - 1, lhs.e - 1);
mi.f <<= mi.e - pl.e;
mi.e = pl.e;
*plus = pl;
*minus = mi;
}
static __inline DiyFp GetCachedPower (int e, int* K) {
unsigned index;
/* 10^-348, 10^-340, ..., 10^340 */
static const uint64_t kCachedPowers_F[] = {
UINT64_C2(0xfa8fd5a0, 0x081c0288), UINT64_C2(0xbaaee17f, 0xa23ebf76),
UINT64_C2(0x8b16fb20, 0x3055ac76), UINT64_C2(0xcf42894a, 0x5dce35ea),
UINT64_C2(0x9a6bb0aa, 0x55653b2d), UINT64_C2(0xe61acf03, 0x3d1a45df),
UINT64_C2(0xab70fe17, 0xc79ac6ca), UINT64_C2(0xff77b1fc, 0xbebcdc4f),
UINT64_C2(0xbe5691ef, 0x416bd60c), UINT64_C2(0x8dd01fad, 0x907ffc3c),
UINT64_C2(0xd3515c28, 0x31559a83), UINT64_C2(0x9d71ac8f, 0xada6c9b5),
UINT64_C2(0xea9c2277, 0x23ee8bcb), UINT64_C2(0xaecc4991, 0x4078536d),
UINT64_C2(0x823c1279, 0x5db6ce57), UINT64_C2(0xc2109436, 0x4dfb5637),
UINT64_C2(0x9096ea6f, 0x3848984f), UINT64_C2(0xd77485cb, 0x25823ac7),
UINT64_C2(0xa086cfcd, 0x97bf97f4), UINT64_C2(0xef340a98, 0x172aace5),
UINT64_C2(0xb23867fb, 0x2a35b28e), UINT64_C2(0x84c8d4df, 0xd2c63f3b),
UINT64_C2(0xc5dd4427, 0x1ad3cdba), UINT64_C2(0x936b9fce, 0xbb25c996),
UINT64_C2(0xdbac6c24, 0x7d62a584), UINT64_C2(0xa3ab6658, 0x0d5fdaf6),
UINT64_C2(0xf3e2f893, 0xdec3f126), UINT64_C2(0xb5b5ada8, 0xaaff80b8),
UINT64_C2(0x87625f05, 0x6c7c4a8b), UINT64_C2(0xc9bcff60, 0x34c13053),
UINT64_C2(0x964e858c, 0x91ba2655), UINT64_C2(0xdff97724, 0x70297ebd),
UINT64_C2(0xa6dfbd9f, 0xb8e5b88f), UINT64_C2(0xf8a95fcf, 0x88747d94),
UINT64_C2(0xb9447093, 0x8fa89bcf), UINT64_C2(0x8a08f0f8, 0xbf0f156b),
UINT64_C2(0xcdb02555, 0x653131b6), UINT64_C2(0x993fe2c6, 0xd07b7fac),
UINT64_C2(0xe45c10c4, 0x2a2b3b06), UINT64_C2(0xaa242499, 0x697392d3),
UINT64_C2(0xfd87b5f2, 0x8300ca0e), UINT64_C2(0xbce50864, 0x92111aeb),
UINT64_C2(0x8cbccc09, 0x6f5088cc), UINT64_C2(0xd1b71758, 0xe219652c),
UINT64_C2(0x9c400000, 0x00000000), UINT64_C2(0xe8d4a510, 0x00000000),
UINT64_C2(0xad78ebc5, 0xac620000), UINT64_C2(0x813f3978, 0xf8940984),
UINT64_C2(0xc097ce7b, 0xc90715b3), UINT64_C2(0x8f7e32ce, 0x7bea5c70),
UINT64_C2(0xd5d238a4, 0xabe98068), UINT64_C2(0x9f4f2726, 0x179a2245),
UINT64_C2(0xed63a231, 0xd4c4fb27), UINT64_C2(0xb0de6538, 0x8cc8ada8),
UINT64_C2(0x83c7088e, 0x1aab65db), UINT64_C2(0xc45d1df9, 0x42711d9a),
UINT64_C2(0x924d692c, 0xa61be758), UINT64_C2(0xda01ee64, 0x1a708dea),
UINT64_C2(0xa26da399, 0x9aef774a), UINT64_C2(0xf209787b, 0xb47d6b85),
UINT64_C2(0xb454e4a1, 0x79dd1877), UINT64_C2(0x865b8692, 0x5b9bc5c2),
UINT64_C2(0xc83553c5, 0xc8965d3d), UINT64_C2(0x952ab45c, 0xfa97a0b3),
UINT64_C2(0xde469fbd, 0x99a05fe3), UINT64_C2(0xa59bc234, 0xdb398c25),
UINT64_C2(0xf6c69a72, 0xa3989f5c), UINT64_C2(0xb7dcbf53, 0x54e9bece),
UINT64_C2(0x88fcf317, 0xf22241e2), UINT64_C2(0xcc20ce9b, 0xd35c78a5),
UINT64_C2(0x98165af3, 0x7b2153df), UINT64_C2(0xe2a0b5dc, 0x971f303a),
UINT64_C2(0xa8d9d153, 0x5ce3b396), UINT64_C2(0xfb9b7cd9, 0xa4a7443c),
UINT64_C2(0xbb764c4c, 0xa7a44410), UINT64_C2(0x8bab8eef, 0xb6409c1a),
UINT64_C2(0xd01fef10, 0xa657842c), UINT64_C2(0x9b10a4e5, 0xe9913129),
UINT64_C2(0xe7109bfb, 0xa19c0c9d), UINT64_C2(0xac2820d9, 0x623bf429),
UINT64_C2(0x80444b5e, 0x7aa7cf85), UINT64_C2(0xbf21e440, 0x03acdd2d),
UINT64_C2(0x8e679c2f, 0x5e44ff8f), UINT64_C2(0xd433179d, 0x9c8cb841),
UINT64_C2(0x9e19db92, 0xb4e31ba9), UINT64_C2(0xeb96bf6e, 0xbadf77d9),
UINT64_C2(0xaf87023b, 0x9bf0ee6b)
};
static const int16_t kCachedPowers_E[] = {
-1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980,
-954, -927, -901, -874, -847, -821, -794, -768, -741, -715,
-688, -661, -635, -608, -582, -555, -529, -502, -475, -449,
-422, -396, -369, -343, -316, -289, -263, -236, -210, -183,
-157, -130, -103, -77, -50, -24, 3, 30, 56, 83,
109, 136, 162, 189, 216, 242, 269, 295, 322, 348,
375, 402, 428, 455, 481, 508, 534, 561, 588, 614,
641, 667, 694, 720, 747, 774, 800, 827, 853, 880,
907, 933, 960, 986, 1013, 1039, 1066
};
/* dk must be positive, so can do ceiling in positive */
double dk = (-61 - e) * 0.30102999566398114 + 347;
int k = (int )(dk);
if (k != dk)
k++;
index = (unsigned )((k >> 3) + 1);
/* decimal exponent no need lookup table */
*K = -(-348 + (int )(index << 3));
assert(index < sizeof(kCachedPowers_F) / sizeof(kCachedPowers_F[0]));
return DiyFp_from_parts(kCachedPowers_F[index], kCachedPowers_E[index]);
}
static __inline void GrisuRound(char* buffer, int len, uint64_t delta, uint64_t rest, uint64_t ten_kappa, uint64_t wp_w) {
while (rest < wp_w && delta - rest >= ten_kappa &&
(rest + ten_kappa < wp_w || /* closer */
wp_w - rest > rest + ten_kappa - wp_w)) {
buffer[len - 1]--;
rest += ten_kappa;
}
}
static __inline unsigned CountDecimalDigit32(uint32_t n) {
/* Simple pure C++ implementation was faster than __builtin_clz version in this situation. */
if (n < 10) return 1;
if (n < 100) return 2;
if (n < 1000) return 3;
if (n < 10000) return 4;
if (n < 100000) return 5;
if (n < 1000000) return 6;
if (n < 10000000) return 7;
if (n < 100000000) return 8;
if (n < 1000000000) return 9;
return 10;
}
static __inline void DigitGen(const DiyFp W, const DiyFp Mp, uint64_t delta, char* buffer, int* len, int* K) {
static const uint32_t kPow10[] = { 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000 };
const DiyFp one = DiyFp_from_parts((uint64_t )(1) << -Mp.e, Mp.e);
const DiyFp wp_w = DiyFp_subtract(Mp, W);
uint32_t p1 = (uint32_t )(Mp.f >> -one.e);
uint64_t p2 = Mp.f & (one.f - 1);
int kappa = (int )(CountDecimalDigit32(p1));
*len = 0;
while (kappa > 0) {
uint32_t d;
uint64_t tmp;
switch (kappa) {
case 10: d = p1 / 1000000000; p1 %= 1000000000; break;
case 9: d = p1 / 100000000; p1 %= 100000000; break;
case 8: d = p1 / 10000000; p1 %= 10000000; break;
case 7: d = p1 / 1000000; p1 %= 1000000; break;
case 6: d = p1 / 100000; p1 %= 100000; break;
case 5: d = p1 / 10000; p1 %= 10000; break;
case 4: d = p1 / 1000; p1 %= 1000; break;
case 3: d = p1 / 100; p1 %= 100; break;
case 2: d = p1 / 10; p1 %= 10; break;
case 1: d = p1; p1 = 0; break;
default:
#if defined(_MSC_VER)
__assume(0);
#elif __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)
__builtin_unreachable();
#else
d = 0;
#endif
}
if (d || *len)
buffer[(*len)++] = '0' + (char )(d);
kappa--;
tmp = ((uint64_t )(p1) << -one.e) + p2;
if (tmp <= delta) {
*K += kappa;
GrisuRound(buffer, *len, delta, tmp, (uint64_t )(kPow10[kappa]) << -one.e, wp_w.f);
return;
}
}
/* kappa = 0 */
for (;;) {
char d;
p2 *= 10;
delta *= 10;
d = (char )(p2 >> -one.e);
if (d || *len)
buffer[(*len)++] = '0' + d;
p2 &= one.f - 1;
kappa--;
if (p2 < delta) {
*K += kappa;
GrisuRound(buffer, *len, delta, p2, one.f, wp_w.f * kPow10[-kappa]);
return;
}
}
}
static __inline void Grisu2(double value, char* buffer, int* length, int* K) {
const DiyFp v = DiyFp_from_double(value);
DiyFp c_mk;
DiyFp W;
DiyFp w_m, w_p;
DiyFp Wp;
DiyFp Wm;
NormalizedBoundaries(v, &w_m, &w_p);
c_mk = GetCachedPower(w_p.e, K);
W = DiyFp_multiply(Normalize(v), c_mk);
Wp = DiyFp_multiply(w_p, c_mk);
Wm = DiyFp_multiply(w_m, c_mk);
Wm.f++;
Wp.f--;
DigitGen(W, Wp, Wp.f - Wm.f, buffer, length, K);
}
static __inline const char* GetDigitsLut(void) {
static const char cDigitsLut[200] = {
'0', '0', '0', '1', '0', '2', '0', '3', '0', '4', '0', '5', '0', '6', '0', '7', '0', '8', '0', '9',
'1', '0', '1', '1', '1', '2', '1', '3', '1', '4', '1', '5', '1', '6', '1', '7', '1', '8', '1', '9',
'2', '0', '2', '1', '2', '2', '2', '3', '2', '4', '2', '5', '2', '6', '2', '7', '2', '8', '2', '9',
'3', '0', '3', '1', '3', '2', '3', '3', '3', '4', '3', '5', '3', '6', '3', '7', '3', '8', '3', '9',
'4', '0', '4', '1', '4', '2', '4', '3', '4', '4', '4', '5', '4', '6', '4', '7', '4', '8', '4', '9',
'5', '0', '5', '1', '5', '2', '5', '3', '5', '4', '5', '5', '5', '6', '5', '7', '5', '8', '5', '9',
'6', '0', '6', '1', '6', '2', '6', '3', '6', '4', '6', '5', '6', '6', '6', '7', '6', '8', '6', '9',
'7', '0', '7', '1', '7', '2', '7', '3', '7', '4', '7', '5', '7', '6', '7', '7', '7', '8', '7', '9',
'8', '0', '8', '1', '8', '2', '8', '3', '8', '4', '8', '5', '8', '6', '8', '7', '8', '8', '8', '9',
'9', '0', '9', '1', '9', '2', '9', '3', '9', '4', '9', '5', '9', '6', '9', '7', '9', '8', '9', '9'
};
return cDigitsLut;
}
static __inline void WriteExponent(int K, char* buffer) {
if (K < 0) {
*buffer++ = '-';
K = -K;
}
else {
*buffer++ = '+';
}
if (K >= 100) {
char* d;
*buffer++ = '0' + (char )(K / 100);
K %= 100;
d = (char*)GetDigitsLut() + K * 2;
*buffer++ = d[0];
*buffer++ = d[1];
}
else if (K >= 10) {
const char* d = GetDigitsLut() + K * 2;
*buffer++ = d[0];
*buffer++ = d[1];
}
else
*buffer++ = '0' + (char )(K);
*buffer = '\0';
}
static __inline void Prettify(char* buffer, int length, int k) {
int i;
const int kk = length + k; /* 10^(kk-1) <= v < 10^kk */
if (length <= kk && kk <= 17) {
/* 1234e7 -> 12340000000 */
for (i = length; i < kk; i++)
buffer[i] = '0';
buffer[kk] = '\0';
}
else if (0 < kk && kk <= 17) {
/* 1234e-2 -> 12.34 */
memmove(&buffer[kk + 1], &buffer[kk], length - kk);
buffer[kk] = '.';
buffer[length + 1] = '\0';
}
else if (-6 < kk && kk <= 0) {
/* 1234e-6 -> 0.001234 */
const int offset = 2 - kk;
memmove(&buffer[offset], &buffer[0], length);
buffer[0] = '0';
buffer[1] = '.';
for (i = 2; i < offset; i++)
buffer[i] = '0';
buffer[length + offset] = '\0';
}
else if (length == 1) {
/* 1E30 */
buffer[1] = 'E';
WriteExponent(kk - 1, &buffer[2]);
}
else {
/* 1234E30 -> 1.234E33 */
memmove(&buffer[2], &buffer[1], length - 1);
buffer[1] = '.';
buffer[length + 1] = 'E';
WriteExponent(kk - 1, &buffer[0 + length + 2]);
}
}
void emyg_dtoa (double value, char* buffer) {
int length, K;
/* Not handling NaN and inf */
assert(!isnan(value));
assert(!isinf(value));
if (value == 0) {
buffer[0] = '0';
buffer[1] = '\0';
}
else {
if (value < 0) {
*buffer++ = '-';
value = -value;
}
Grisu2(value, buffer, &length, &K);
Prettify(buffer, length, K);
}
}

26
third_party/dtoa/emyg_dtoa.h vendored Normal file
View File

@ -0,0 +1,26 @@
/* emyg_dtoa.h
** Copyright (C) 2015 Doug Currie
** based on dtoa_milo.h
** Copyright (C) 2014 Milo Yip
**
** Permission is hereby granted, free of charge, to any person obtaining a copy
** of this software and associated documentation files (the "Software"), to deal
** in the Software without restriction, including without limitation the rights
** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
** copies of the Software, and to permit persons to whom the Software is
** furnished to do so, subject to the following conditions:
**
** The above copyright notice and this permission notice shall be included in
** all copies or substantial portions of the Software.
**
** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
** THE SOFTWARE.
*/
/* Source from https://github.com/miloyip/dtoa-benchmark */
void emyg_dtoa (double value, char* buffer);

2
third_party/md5/Makefile vendored
View File

@ -1,6 +1,6 @@
###############################################################################
#
# Simplied Makefile to build the openwall md5 library for the libxlsxwriter.
# Simplied Makefile to build the openwall md5 library for libxlsxwriter.
#
# Keep the output quiet by default.