From bda599d0330956d9856cb87bd8e3921af886eacf Mon Sep 17 00:00:00 2001 From: John McNamara Date: Sun, 11 Jul 2021 13:40:35 +0100 Subject: [PATCH] Added optional third party dtoa library. 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 --- .travis.yml | 2 +- CMakeLists.txt | 16 +- License.txt | 45 +- Makefile | 5 +- docs/src/getting_started.dox | 20 + docs/src/working_with_memory.dox | 12 +- examples/Makefile | 3 + include/xlsxwriter/third_party/emyg_dtoa.h | 26 ++ include/xlsxwriter/utility.h | 10 +- src/Makefile | 15 +- src/utility.c | 25 +- src/worksheet.c | 6 +- test/functional/src/Makefile | 6 +- test/functional/src/test_data08.c | 2 +- test/functional/src/test_types11.c | 34 ++ test/functional/test_types.py | 3 + test/functional/xlsx_files/types11.xlsx | Bin 0 -> 7175 bytes test/unit/Makefile | 5 - test/unit/Makefile.unit | 7 +- third_party/dtoa/Makefile | 42 ++ third_party/dtoa/emyg_dtoa.c | 461 +++++++++++++++++++++ third_party/dtoa/emyg_dtoa.h | 26 ++ third_party/md5/Makefile | 2 +- 23 files changed, 711 insertions(+), 62 deletions(-) create mode 100644 include/xlsxwriter/third_party/emyg_dtoa.h create mode 100644 test/functional/src/test_types11.c create mode 100644 test/functional/xlsx_files/types11.xlsx create mode 100644 third_party/dtoa/Makefile create mode 100644 third_party/dtoa/emyg_dtoa.c create mode 100644 third_party/dtoa/emyg_dtoa.h diff --git a/.travis.yml b/.travis.yml index b36a3e17..fa023911 100644 --- a/.travis.yml +++ b/.travis.yml @@ -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' diff --git a/CMakeLists.txt b/CMakeLists.txt index 460bb6fd..66505b5b 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -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} "") diff --git a/License.txt b/License.txt index 976c067c..9e8732b3 100644 --- a/License.txt +++ b/License.txt @@ -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: @@ -135,18 +135,49 @@ Note, it is possible to compile libxlsxwriter without statically linking the [Tmpfileplus](http://www.di-mgt.com.au/c_function_to_create_temp_file.html) has the following license: - This Source Code Form is subject to the terms of the Mozilla Public - License, v. 2.0. If a copy of the MPL was not distributed with this - file, You can obtain one at http://mozilla.org/MPL/2.0/. + This Source Code Form is subject to the terms of the Mozilla Public + License, v. 2.0. If a copy of the MPL was not distributed with this + file, You can obtain one at http://mozilla.org/MPL/2.0/. - Copyright (c) 2012-16 David Ireland, DI Management Services Pty Ltd - . + Copyright (c) 2012-16 David Ireland, DI Management Services Pty Ltd + . 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: diff --git a/Makefile b/Makefile index e2a0de1c..7e7160fd 100644 --- a/Makefile +++ b/Makefile @@ -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 diff --git a/docs/src/getting_started.dox b/docs/src/getting_started.dox index f9fbf0bf..b60ea7be 100644 --- a/docs/src/getting_started.dox +++ b/docs/src/getting_started.dox @@ -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 diff --git a/docs/src/working_with_memory.dox b/docs/src/working_with_memory.dox index 13df6d32..ef326f04 100644 --- a/docs/src/working_with_memory.dox +++ b/docs/src/working_with_memory.dox @@ -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 diff --git a/examples/Makefile b/examples/Makefile index 403e8ccd..958723f3 100644 --- a/examples/Makefile +++ b/examples/Makefile @@ -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 diff --git a/include/xlsxwriter/third_party/emyg_dtoa.h b/include/xlsxwriter/third_party/emyg_dtoa.h new file mode 100644 index 00000000..3b96eca6 --- /dev/null +++ b/include/xlsxwriter/third_party/emyg_dtoa.h @@ -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); diff --git a/include/xlsxwriter/utility.h b/include/xlsxwriter/utility.h index f602aba7..19b98e75 100644 --- a/include/xlsxwriter/utility.h +++ b/include/xlsxwriter/utility.h @@ -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); diff --git a/src/Makefile b/src/Makefile index 9c39e757..96258ef9 100644 --- a/src/Makefile +++ b/src/Makefile @@ -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) diff --git a/src/utility.c b/src/utility.c index 2ab0e7fa..4fb21b35 100644 --- a/src/utility.c +++ b/src/utility.c @@ -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 diff --git a/src/worksheet.c b/src/worksheet.c index b660be88..8322cf46 100644 --- a/src/worksheet.c +++ b/src/worksheet.c @@ -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, - "%.16g", + "%.16G", range, style_index, cell->u.number); else fprintf(self->file, - "%.16g", range, cell->u.number); + "%.16G", range, cell->u.number); #endif } diff --git a/test/functional/src/Makefile b/test/functional/src/Makefile index ecc2d41c..9c1b02f1 100644 --- a/test/functional/src/Makefile +++ b/test/functional/src/Makefile @@ -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) diff --git a/test/functional/src/test_data08.c b/test/functional/src/test_data08.c index 2056b54b..06527885 100644 --- a/test/functional/src/test_data08.c +++ b/test/functional/src/test_data08.c @@ -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 diff --git a/test/functional/src/test_types11.c b/test/functional/src/test_types11.c new file mode 100644 index 00000000..0234b16d --- /dev/null +++ b/test/functional/src/test_types11.c @@ -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); +} diff --git a/test/functional/test_types.py b/test/functional/test_types.py index de6657ce..ba290013 100644 --- a/test/functional/test_types.py +++ b/test/functional/test_types.py @@ -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') diff --git a/test/functional/xlsx_files/types11.xlsx b/test/functional/xlsx_files/types11.xlsx new file mode 100644 index 0000000000000000000000000000000000000000..d1814aa23a22b0029f1fc21d9a8df44914b31605 GIT binary patch literal 7175 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 literal 0 HcmV?d00001 diff --git a/test/unit/Makefile b/test/unit/Makefile index 8dd55350..4c5f5692 100644 --- a/test/unit/Makefile +++ b/test/unit/Makefile @@ -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 diff --git a/test/unit/Makefile.unit b/test/unit/Makefile.unit index 0db99ea4..602ccc10 100644 --- a/test/unit/Makefile.unit +++ b/test/unit/Makefile.unit @@ -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. diff --git a/third_party/dtoa/Makefile b/third_party/dtoa/Makefile new file mode 100644 index 00000000..b58e9c30 --- /dev/null +++ b/third_party/dtoa/Makefile @@ -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 diff --git a/third_party/dtoa/emyg_dtoa.c b/third_party/dtoa/emyg_dtoa.c new file mode 100644 index 00000000..43621308 --- /dev/null +++ b/third_party/dtoa/emyg_dtoa.c @@ -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 +#include + +#if defined(_MSC_VER) +#include +#include +#include +#else +#include +#endif + +#include + +#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); + } +} diff --git a/third_party/dtoa/emyg_dtoa.h b/third_party/dtoa/emyg_dtoa.h new file mode 100644 index 00000000..3b96eca6 --- /dev/null +++ b/third_party/dtoa/emyg_dtoa.h @@ -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); diff --git a/third_party/md5/Makefile b/third_party/md5/Makefile index b6329700..6e7e0c37 100644 --- a/third_party/md5/Makefile +++ b/third_party/md5/Makefile @@ -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.