.appveyor.yml

@@ -22,9 +22,9 @@ build_script:
   - mkdir build
   - cd build
   - cmake --version
-  - cmake %CMAKE_ARGS% ..
+  - cmake %CMAKE_ARGS% --parallel ..
   - cmake ..
-  - cmake --build . --config %Configuration% --verbose 
+  - cmake --build . --config %Configuration% --verbose --parallel
 
 for:
 -
@@ -33,7 +33,7 @@ for:
       - job_name: VS2019ARM
 
   test_script:
-    - ctest --output-on-failure -C %Configuration% --verbose %CTEST_ARGS%
+    - ctest --output-on-failure -C %Configuration% --verbose %CTEST_ARGS% --parallel
 
 clone_folder: c:\projects\fast_double_parser
 

.clusterfuzzlite/Dockerfile

@@ -1,6 +0,0 @@
-FROM gcr.io/oss-fuzz-base/base-builder
-RUN apt-get update && apt-get install -y make autoconf automake libtool
-
-COPY . $SRC/fast_double_parser
-COPY .clusterfuzzlite/build.sh $SRC/build.sh
-WORKDIR $SRC/fast_double_parser

.clusterfuzzlite/README.md

@@ -1,3 +0,0 @@
-# ClusterFuzzLite set up
-
-This folder contains a fuzzing set for [ClusterFuzzLite](https://google.github.io/clusterfuzzlite).

.clusterfuzzlite/build.sh

@@ -1,7 +0,0 @@
-#!/bin/bash -eu
-
-# Copy all fuzzer executable to $OUT/
-$CXX $CFLAGS $LIB_FUZZING_ENGINE \
-  $SRC/fast_double_parser/.clusterfuzzlite/parse_number_fuzzer.cpp \
-  -o $OUT/parse_number_fuzzer \
-  -I$SRC/fast_double_parser/include

.clusterfuzzlite/parse_number_fuzzer.cpp

@@ -1,11 +0,0 @@
-#include <fast_double_parser.h>
-#include <string>
-
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
-  std::string fuzz_input(reinterpret_cast<const char *>(data), size);
-
-  double x;
-  fast_double_parser::parse_number(fuzz_input.c_str(), &x);
-
-  return 0;
-}

.clusterfuzzlite/project.yaml

@@ -1 +0,0 @@
-language: c++

.github/workflows/cflite_pr.yml

@@ -1,30 +0,0 @@
-name: ClusterFuzzLite PR fuzzing
-on:
-  workflow_dispatch:
-  pull_request:
-    branches: [ main ]
-permissions: read-all
-jobs:
-  PR:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        sanitizer: [address]
-    steps:
-    - name: Build Fuzzers (${{ matrix.sanitizer }})
-      id: build
-      uses: google/clusterfuzzlite/actions/build_fuzzers@v1
-      with:
-        sanitizer: ${{ matrix.sanitizer }}
-        language: c++
-        bad-build-check: false
-    - name: Run Fuzzers (${{ matrix.sanitizer }})
-      id: run
-      uses: google/clusterfuzzlite/actions/run_fuzzers@v1
-      with:
-        github-token: ${{ secrets.GITHUB_TOKEN }}
-        fuzz-seconds: 100
-        mode: 'code-change'
-        report-unreproducible-crashes: false
-        sanitizer: ${{ matrix.sanitizer }}

.github/workflows/codeql.yml

@@ -1,41 +0,0 @@
-name: "CodeQL"
-
-on:
-  push:
-    branches: [ "master" ]
-  pull_request:
-    branches: [ "master" ]
-  schedule:
-    - cron: "1 8 * * 3"
-
-jobs:
-  analyze:
-    name: Analyze
-    runs-on: ubuntu-latest
-    permissions:
-      actions: read
-      contents: read
-      security-events: write
-
-    strategy:
-      fail-fast: false
-      matrix:
-        language: [ cpp ]
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-
-      - name: Initialize CodeQL
-        uses: github/codeql-action/init@v2
-        with:
-          languages: ${{ matrix.language }}
-          queries: +security-and-quality
-
-      - name: Autobuild
-        uses: github/codeql-action/autobuild@v2
-
-      - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v2
-        with:
-          category: "/language:${{ matrix.language }}"

.github/workflows/mingw-ci.yml

@@ -0,0 +1,49 @@
+name: MinGW32-CI
+
+on: [push, pull_request]
+
+# Important: scoop will either install 32-bit GCC or 64-bit GCC, not both.
+
+# It is important to build static libraries because cmake is not smart enough under Windows/mingw to take care of the path. So
+# with a dynamic library, you could get failures due to the fact that the EXE can't find its DLL.
+
+jobs:
+  ci:
+    name: windows-gcc
+    runs-on: windows-2016
+
+    env:
+      CMAKE_GENERATOR: Ninja
+      CC: gcc
+      CXX: g++
+
+    steps: # To reproduce what is below, start a powershell with administrative rights, using scoop *is* a good idea
+      - uses: actions/checkout@v2
+
+      - uses: actions/cache@v2 # we cache the scoop setup with 32-bit GCC
+        id: cache
+        with:
+          path: |
+            C:\ProgramData\scoop
+          key: scoop32 # static key: should be good forever
+      - name: Setup Windows # This should almost never run if the cache works.
+        if: steps.cache.outputs.cache-hit != 'true'
+        shell: powershell
+        run: |
+          Invoke-Expression (New-Object System.Net.WebClient).DownloadString('https://get.scoop.sh')
+          scoop install sudo --global
+          sudo scoop install git --global
+          sudo scoop install ninja --global
+          sudo scoop install cmake --global
+          sudo scoop install gcc --arch 32bit --global
+          $env:path
+          Write-Host 'Everything has been installed, you are good!'
+      - name: Build and Test 32-bit x86
+        shell: powershell
+        run: |
+          $ENV:PATH="C:\ProgramData\scoop\shims;C:\ProgramData\scoop\apps\gcc\current\bin;C:\ProgramData\scoop\apps\ninja\current;$ENV:PATH"
+          mkdir build32
+          cd build32
+          cmake  ..
+          cmake --build .   --verbose
+          ctest -j4 --output-on-failure

.github/workflows/mingw64-ci.yml

@@ -0,0 +1,49 @@
+name: MinGW64-CI
+
+on: [push, pull_request]
+
+# Important: scoop will either install 32-bit GCC or 64-bit GCC, not both.
+
+# It is important to build static libraries because cmake is not smart enough under Windows/mingw to take care of the path. So
+# with a dynamic library, you could get failures due to the fact that the EXE can't find its DLL.
+
+jobs:
+  ci:
+    name: windows-gcc
+    runs-on: windows-2016
+
+    env:
+      CMAKE_GENERATOR: Ninja
+      CC: gcc
+      CXX: g++
+
+    steps: # To reproduce what is below, start a powershell with administrative rights, using scoop *is* a good idea
+      - uses: actions/checkout@v2
+
+      - uses: actions/cache@v2 # we cache the scoop setup with 64-bit GCC
+        id: cache
+        with:
+          path: |
+            C:\ProgramData\scoop
+          key: scoop64 # static key: should be good forever
+      - name: Setup Windows # This should almost never run if the cache works.
+        if: steps.cache.outputs.cache-hit != 'true'
+        shell: powershell
+        run: |
+          Invoke-Expression (New-Object System.Net.WebClient).DownloadString('https://get.scoop.sh')
+          scoop install sudo --global
+          sudo scoop install git --global
+          sudo scoop install ninja --global
+          sudo scoop install cmake --global
+          sudo scoop install gcc --arch 64bit --global
+          $env:path
+          Write-Host 'Everything has been installed, you are good!'
+      - name: Build and Test 64-bit x64
+        shell: powershell
+        run: |
+          $ENV:PATH="C:\ProgramData\scoop\shims;C:\ProgramData\scoop\apps\gcc\current\bin;C:\ProgramData\scoop\apps\ninja\current;$ENV:PATH"
+          mkdir build64
+          cd build64
+          cmake  ..
+          cmake --build .   --verbose
+          ctest -j4 --output-on-failure

.github/workflows/msys2-clang.yml

@@ -29,7 +29,7 @@ jobs:
       CMAKE_GENERATOR: Ninja
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v2
       - uses: msys2/setup-msys2@v2
         with:
           update: true

.github/workflows/msys2.yml

@@ -29,7 +29,7 @@ jobs:
       CMAKE_GENERATOR: Ninja
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v2
       - uses: msys2/setup-msys2@v2
         with:
           update: true

.github/workflows/rhub.yml

@@ -7,7 +7,7 @@ jobs:
   ubuntu-build:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v2
       - name: start docker
         run: |
           docker run -w /src -dit --name rhub -v $PWD:/src rhub/rocker-gcc-san

.github/workflows/ubuntu18.yml

@@ -0,0 +1,20 @@
+name: Ubuntu 18.04 CI (GCC 7)
+
+on: [push, pull_request]
+
+jobs:
+  ubuntu-build:
+    runs-on: ubuntu-18.04
+    steps:
+      - uses: actions/checkout@v2
+      - name: Setup cmake
+        uses: jwlawson/actions-setup-cmake@v1.4
+        with:
+          cmake-version: '3.9.x'
+      - name: Use cmake
+        run: |
+          mkdir build &&
+          cd build &&
+          cmake  -DFAST_DOUBLE_BENCHMARKS=ON  .. &&
+          cmake --build . &&
+          ctest -j --output-on-failure

.github/workflows/ubuntu20.yml

@@ -1,15 +1,16 @@
-name: Ubuntu 22.04
+name: Ubuntu 20.04 CI (GCC 9)
 
 on: [push, pull_request]
 
 jobs:
   ubuntu-build:
-    runs-on: ubuntu-22.04
-    strategy:
-      matrix:
-        cxx: [g++-12, clang++-14]
+    runs-on: ubuntu-20.04
     steps:
-      - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # v4.1.4
+      - uses: actions/checkout@v2
+      - name: Setup cmake
+        uses: jwlawson/actions-setup-cmake@v1.4
+        with:
+          cmake-version: '3.9.x'
       - name: Use cmake
         run: |
           mkdir build &&

.github/workflows/vs16-ci.yml

@@ -0,0 +1,24 @@
+name: VS16-CI
+
+on: [push, pull_request]
+
+jobs:
+  ci:
+    name: windows-vs16
+    runs-on: windows-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: 'Run CMake with VS16'
+      uses: lukka/run-cmake@v2
+      with:
+        cmakeListsOrSettingsJson: CMakeListsTxtAdvanced
+        cmakeListsTxtPath: '${{ github.workspace }}/CMakeLists.txt'
+        buildDirectory: "${{ github.workspace }}/../../_temp/windows"
+        cmakeBuildType: Release
+        buildWithCMake: true
+        cmakeGenerator: VS16Win64
+        buildWithCMakeArgs:  --config Release  
+
+    - name: 'Run CTest'
+      run: ctest -C Release    --output-on-failure
+      working-directory: "${{ github.workspace }}/../../_temp/windows"

.github/workflows/vs16-clang-ci.yml

@@ -0,0 +1,25 @@
+name: VS16-CLANG-CI
+
+on: [push, pull_request]
+
+jobs:
+  ci:
+    name: windows-vs16
+    runs-on: windows-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: 'Run CMake with VS16'
+      uses: lukka/run-cmake@v2
+      with:
+        cmakeListsOrSettingsJson: CMakeListsTxtAdvanced
+        cmakeListsTxtPath: '${{ github.workspace }}/CMakeLists.txt'
+        buildDirectory: "${{ github.workspace }}/../../_temp/windows"
+        cmakeBuildType: Release
+        buildWithCMake: true
+        cmakeGenerator: VS16Win64
+        cmakeAppendedArgs:  -T ClangCL
+        buildWithCMakeArgs:  --config Release  
+
+    - name: 'Run CTest'
+      run: ctest -C Release   --output-on-failure
+      working-directory: "${{ github.workspace }}/../../_temp/windows"

.github/workflows/vs16-ninja-ci.yml

@@ -0,0 +1,25 @@
+name: VS16-Ninja-CI
+
+on: [push, pull_request]
+
+jobs:
+  ci:
+    name: windows-vs16
+    runs-on: windows-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: 'Run CMake with VS16'
+      uses: lukka/run-cmake@v2
+      with:
+        cmakeListsOrSettingsJson: CMakeListsTxtAdvanced
+        cmakeListsTxtPath: '${{ github.workspace }}/CMakeLists.txt'
+        buildDirectory: "${{ github.workspace }}/../../_temp/windows"
+        cmakeBuildType: Release
+        buildWithCMake: true
+        cmakeGenerator: VS16Win64
+        cmakeAppendedArgs:  -G Ninja
+        buildWithCMakeArgs: --config Release  
+
+    - name: 'Run CTest'
+      run: ctest -C Release   --output-on-failure
+      working-directory: "${{ github.workspace }}/../../_temp/windows"

.github/workflows/vs17-ci.yml

@@ -1,37 +0,0 @@
-name: VS17-CI
-
-on: [push, pull_request]
-
-jobs:
-  ci:
-    if: >-
-      ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
-      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
-    name: windows-vs17
-    runs-on: windows-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - {gen: Visual Studio 17 2022, arch: Win32}
-          - {gen: Visual Studio 17 2022, arch: Win32}
-          - {gen: Visual Studio 17 2022, arch: x64}
-          - {gen: Visual Studio 17 2022, arch: x64}
-    steps:
-    - name: checkout
-      uses: actions/checkout@v3
-    - name: Configure
-      run: |
-        cmake -G "${{matrix.gen}}" -A ${{matrix.arch}}  -B build
-    - name: Build Debug
-      run: cmake --build build --config Debug --verbose
-    - name: Build Release
-      run: cmake --build build --config Release --verbose
-    - name: Run Release tests
-      run: |
-        cd build
-        ctest -C Release  --output-on-failure
-    - name: Run Debug tests
-      run: |
-        cd build
-        ctest -C Debug --output-on-failure

.github/workflows/vs17-clang-ci.yml

@@ -1,37 +0,0 @@
-name: VS17-CLANG-CI
-
-on: [push, pull_request]
-
-jobs:
-  ci:
-    if: >-
-      ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
-      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
-    name: windows-vs17
-    runs-on: windows-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - {gen: Visual Studio 17 2022, arch: Win32}
-          - {gen: Visual Studio 17 2022, arch: Win32}
-          - {gen: Visual Studio 17 2022, arch: x64}
-          - {gen: Visual Studio 17 2022, arch: x64}
-    steps:
-    - name: checkout
-      uses: actions/checkout@v3
-    - name: Configure
-      run: |
-        cmake -G "${{matrix.gen}}" -A ${{matrix.arch}}  -T ClangCL -B build
-    - name: Build Debug
-      run: cmake --build build --config Debug --verbose
-    - name: Build Release
-      run: cmake --build build --config Release --verbose
-    - name: Run Release tests
-      run: |
-        cd build
-        ctest -C Release  --output-on-failure
-    - name: Run Debug tests
-      run: |
-        cd build
-        ctest -C Debug --output-on-failure

.gitignore

@@ -44,7 +44,3 @@
 /fast_double_parser.cxxflags
 /fast_double_parser.files
 /fast_double_parser.includes
-
-# Visual Studio
-/.vs
-/out

BUILD.bazel

@@ -1,22 +0,0 @@
-cc_library(
-    name = "fast_double_parser",
-    hdrs = ["include/fast_double_parser.h"],
-    strip_include_prefix = "include",
-    visibility = ["//visibility:public"],
-)
-
-cc_test(
-    name = "unit",
-    srcs = ["tests/unit.cpp"],
-    deps = [":fast_double_parser"],
-)
-
-cc_binary(
-    name = "benchmark",
-    srcs = ["benchmarks/benchmark.cpp"],
-    deps = [
-        ":fast_double_parser",
-        "@abseil-cpp//absl/strings",
-        "@double-conversion",
-    ],
-)

CMakeLists.txt

@@ -1,7 +1,6 @@
-cmake_minimum_required(VERSION 3.11)
 cmake_policy(SET CMP0048 NEW)
-
 project(fast_double_parser LANGUAGES CXX VERSION 0.0.0.0)
+cmake_minimum_required(VERSION 3.9)
 set(CMAKE_CXX_STANDARD 11)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 if (NOT CMAKE_BUILD_TYPE)
@@ -20,82 +19,53 @@ set(benchmark_src benchmarks/benchmark.cpp)
 
 
 add_library(fast_double_parser INTERFACE)
-target_include_directories(fast_double_parser
-    INTERFACE
-        $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>
-        $<INSTALL_INTERFACE:include>
-)
+target_include_directories(fast_double_parser INTERFACE include/)
 
-include(GNUInstallDirs)
-install(FILES ${headers} DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}")
-install(TARGETS fast_double_parser EXPORT fast_double_parser-targets)
-install(
-    EXPORT fast_double_parser-targets
-    DESTINATION "share/fast_double_parser"
-    NAMESPACE fast_double_parser::
-)
 
-include(CMakePackageConfigHelpers)
-configure_package_config_file(
-  "${CMAKE_CURRENT_SOURCE_DIR}/fast_double_parser-config.cmake.in"
-  "${CMAKE_CURRENT_BINARY_DIR}/fast_double_parser-config.cmake"
-  INSTALL_DESTINATION "share/fast_double_parser"
-)
-install(
-  FILES "${CMAKE_CURRENT_BINARY_DIR}/fast_double_parser-config.cmake"
-  DESTINATION "share/fast_double_parser"
-)
-
-option(BUILD_TESTING "Build unit tests" ON)
-if(BUILD_TESTING)
-    add_executable(unit ${unit_src} ${bogus_src} ${rebogus_src})
-
-    if(FAST_DOUBLE_PARSER_SANITIZE)
-      target_compile_options(unit PUBLIC -fsanitize=address -fno-omit-frame-pointer -fsanitize=undefined -fno-sanitize-recover=all)
-      target_link_options(unit PUBLIC -fsanitize=address -fno-omit-frame-pointer -fsanitize=undefined -fno-sanitize-recover=all)
-      # Ubuntu bug for GCC 5.0+ (safe for all versions)
-      if (CMAKE_COMPILER_IS_GNUCC AND NOT APPLE)
-        target_link_libraries(unit PUBLIC -fuse-ld=gold)
-      endif()
-    endif()
-    target_link_libraries(unit PRIVATE fast_double_parser)
-
-    enable_testing()
-    add_test(unit unit)
+add_executable(unit ${unit_src} ${bogus_src} ${rebogus_src})
+if(FAST_DOUBLE_PARSER_SANITIZE)
+  target_compile_options(unit PUBLIC -fsanitize=address -fno-omit-frame-pointer -fsanitize=undefined -fno-sanitize-recover=all)
+  target_link_options(unit PUBLIC -fsanitize=address -fno-omit-frame-pointer -fsanitize=undefined -fno-sanitize-recover=all)
+  # Ubuntu bug for GCC 5.0+ (safe for all versions)
+  if (CMAKE_COMPILER_IS_GNUCC)
+    target_link_libraries(unit PUBLIC -fuse-ld=gold)
+  endif()
 endif()
 
-option(FAST_DOUBLE_BENCHMARKS "include benchmarks" OFF)
+target_link_libraries(unit  PUBLIC fast_double_parser)
 
 
 
+enable_testing()
+add_test(unit unit)
+
+option(FAST_DOUBLE_BENCHMARKS "Sanitize addresses" OFF)
+
+
+
+function(initialize_submodule DIRECTORY)
+  if(NOT EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${DIRECTORY}/.git)
+    find_package(Git QUIET REQUIRED)
+    message(STATUS "${CMAKE_CURRENT_SOURCE_DIR}/${DIRECTORY}/.git does not exist. Initializing ${DIRECTORY} submodule ...")
+    execute_process(COMMAND ${GIT_EXECUTABLE} submodule update --init ${CMAKE_CURRENT_SOURCE_DIR}/${DIRECTORY}
+                    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+                    RESULT_VARIABLE GIT_EXIT_CODE)
+    if(NOT GIT_EXIT_CODE EQUAL "0")
+      message(FATAL_ERROR "${GIT_EXECUTABLE} submodule update --init dependencies/${DIRECTORY} failed with exit code ${GIT_EXIT_CODE}, please checkout submodules")
+    endif()
+  endif()
+endfunction(initialize_submodule)
+
 if(FAST_DOUBLE_BENCHMARKS)
+  initialize_submodule(benchmarks/dependencies/abseil-cpp)
+  initialize_submodule(benchmarks/dependencies/double-conversion)
 
-    include(FetchContent)
-    include(ExternalProject)
+  add_subdirectory(benchmarks/dependencies/abseil-cpp)
+  add_subdirectory(benchmarks/dependencies/double-conversion)
 
-    set(ABSL_ENABLE_INSTALL ON)
-    set(ABSL_RUN_TEST OFF CACHE INTERNAL "")
-    set(ABSL_USE_GOOGLETEST_HEAD OFF CACHE INTERNAL "")
 
-    FetchContent_Declare(abseil 
-         GIT_REPOSITORY https://github.com/abseil/abseil-cpp.git 
-         GIT_TAG "20210324.2")
-    FetchContent_GetProperties(abseil)
-    if(NOT abseil_POPULATED)
-        set(BUILD_TESTING OFF)
-        FetchContent_Populate(abseil)
-        add_subdirectory(${abseil_SOURCE_DIR} ${abseil_BINARY_DIR})
-        set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${abseil_SOURCE_DIR}/absl/copts)
-        include(${abseil_SOURCE_DIR}/absl/copts/AbseilConfigureCopts.cmake)
-    endif()
 
-    FetchContent_Declare(doubleconversion 
-        GIT_REPOSITORY https://github.com/google/double-conversion.git 
-        GIT_TAG "v3.1.5")
-    FetchContent_GetProperties(doubleconversion)
-    FetchContent_MakeAvailable(doubleconversion)
-
-    add_executable(benchmark ${benchmark_src})
-    target_link_libraries(benchmark PUBLIC double-conversion absl::strings)
-    target_include_directories(benchmark PUBLIC include)
-endif(FAST_DOUBLE_BENCHMARKS)
+  add_executable(benchmark ${benchmark_src})
+  target_link_libraries(benchmark PUBLIC double-conversion absl_strings)
+  target_include_directories(benchmark PUBLIC include)
+endif(FAST_DOUBLE_BENCHMARKS)

MODULE.bazel

@@ -1,10 +0,0 @@
-"""fast_double_parser: 4x faster than strtod."""
-
-module(
-    name = "fast_double_parser",
-    version = "0.8.0",
-    compatibility_level = 0,
-)
-
-bazel_dep(name = "abseil-cpp", version = "20240722.0", dev_dependency = True)
-bazel_dep(name = "double-conversion", version = "3.3.0", dev_dependency = True)

README.md

@@ -1,20 +1,17 @@
 # fast_double_parser: 4x faster than strtod
-![MSYS2-CI](https://github.com/lemire/fast_double_parser/workflows/MSYS2-CI/badge.svg)[![Ubuntu 22.04](https://github.com/lemire/fast_double_parser/actions/workflows/ubuntu.yml/badge.svg)](https://github.com/lemire/fast_double_parser/actions/workflows/ubuntu.yml)
-
-Unless you need support for [RFC 7159](https://tools.ietf.org/html/rfc7159) (JSON standard), we encourage users to adopt [fast_float](https://github.com/fastfloat/fast_float) library instead. It has more functionality.
+[![Build Status](https://cloud.drone.io/api/badges/lemire/fast_double_parser/status.svg)](https://cloud.drone.io/lemire/fast_double_parser) [![Build status](https://ci.appveyor.com/api/projects/status/y7215jgem4ggswnj/branch/master?svg=true)](https://ci.appveyor.com/project/lemire/fast-double-parser/branch/master)![VS16-CI](https://github.com/lemire/fast_double_parser/workflows/VS16-CI/badge.svg)![Ubuntu 18.04 CI (GCC 7)](https://github.com/lemire/fast_double_parser/workflows/Ubuntu%2018.04%20CI%20(GCC%207)/badge.svg)![VS16-Ninja-CI](https://github.com/lemire/fast_double_parser/workflows/VS16-Ninja-CI/badge.svg)![MSYS2-CI](https://github.com/lemire/fast_double_parser/workflows/MSYS2-CI/badge.svg)![VS16-CLANG-CI](https://github.com/lemire/fast_double_parser/workflows/VS16-CLANG-CI/badge.svg)![MinGW32-CI](https://github.com/lemire/fast_double_parser/workflows/MinGW32-CI/badge.svg)![MinGW64-CI](https://github.com/lemire/fast_double_parser/workflows/MinGW64-CI/badge.svg)![Ubuntu 20.04 CI (GCC 9)](https://github.com/lemire/fast_double_parser/workflows/Ubuntu%2020.04%20CI%20(GCC%209)/badge.svg)[![Build Status](https://api.cirrus-ci.com/github/lemire/fast_double_parser.svg)](https://cirrus-ci.com/github/lemire/fast_double_parser)
 
 
-Fast function to parse ASCII strings containing decimal numbers into double-precision (binary64) floating-point values.  That is, given the string "1.0e10", it should return a 64-bit floating-point value equal to 10000000000. We do not sacrifice accuracy. The function will match exactly (down the smallest bit) the result of a standard function like `strtod`.
+Fast function to parse strings containing decimal numbers into double-precision (binary64) floating-point values.  That is, given the string "1.0e10", it should return a 64-bit floating-point value equal to 10000000000. We do not sacrifice accuracy. The function will match exactly (down the smallest bit) the result of a standard function like `strtod`.
 
 We support all major compilers: Visual Studio, GNU GCC, LLVM Clang. We require C++11.
 
-The core of this library was ported to Go by Nigel Tao and is now a standard float-parsing routine in Go (`strconv.ParseFloat`). 
+The core of this library was ported to Go by Nigel Tao and is now a standard float-parsing routine in Go (`strconv.ParseFloat`).
 
 
 ## Reference
 
-- Daniel Lemire, [Number Parsing at a Gigabyte per Second](https://arxiv.org/abs/2101.11408), Software: Practice and Experience 51 (8), 2021.
-
+- Daniel Lemire, [Number Parsing at a Gigabyte per Second](https://arxiv.org/abs/2101.11408), arXiv:2101.11408
 
 
 ## Usage
@@ -30,13 +27,13 @@ The current API is simple enough:
 
 double x;
 char * string = ...
-const char * endptr = fast_double_parser::parse_number(string, &x);
+bool isok = fast_double_parser::parse_number(string, &x);
 ```
 
-You must check the value returned (`endptr`): if it is `nullptr`, then the function refused to parse the input.
+You must check the value returned (`isok`): if it is `nullptr`, then the function refused to parse the input.
 Otherwise, we return a pointer (`const char *`) to the end of the parsed string. The provided
 pointer (`string`) should point at the beginning of the number: if you must skip whitespace characters,
-it is your responsibility to do so.
+it is your responsability to do so.
 
 
 We expect string numbers to follow [RFC 7159](https://tools.ietf.org/html/rfc7159) (JSON standard). In particular,
@@ -47,13 +44,10 @@ It works much like the C standard function `strtod` expect that the parsing is l
 1/2 even if you are under a French system. Locale independence is by design (it is not a limitation). Like the standard C functions, it expects that the string
 representation of your number ends with a non-number character (e.g., a null character, a space, a colon, etc.). If you wish the specify the end point of the string, as is common in C++, please consider the [fast_float](https://github.com/lemire/fast_float) C++ library instead.
 
-
-We assume that the rounding mode is set to nearest, the default setting (`std::fegetround() == FE_TONEAREST`). It is uncommon to have a different setting.
-
 ## What if I prefer another API?
 
 The [fast_float](https://github.com/lemire/fast_float) offers an API resembling that of the C++17 `std::from_chars` functions. In particular, you can specify the beginning and the end of the string.
-Furthermore [fast_float](https://github.com/lemire/fast_float) supports both 32-bit and 64-bit floating-point numbers. The  [fast_float](https://github.com/lemire/fast_float) library is part of Apache Arrow, GCC 12, Safari/WebKit and other important systems.
+Furthermore [fast_float](https://github.com/lemire/fast_float) supports both 32-bit and 64-bit floating-point numbers. The  [fast_float](https://github.com/lemire/fast_float) library is part of Apache Arrow.
 
 ## Why should I expect this function to be faster?
 
@@ -160,7 +154,6 @@ double-conv    243.90 MB/s
 
 ## Ports and users
 
-- The algorithm is part of the [LLVM standard libraries](https://github.com/llvm/llvm-project/commit/87c016078ad72c46505461e4ff8bfa04819fe7ba). 
 - This library has been ported to Go and integrated in the Go standard library.
 - It is part of the [Microsoft LightGBM machine-learning framework](https://github.com/microsoft/LightGBM).
 - It is part of the database engine [noisepage](https://github.com/cmu-db/noisepage).
@@ -169,7 +162,6 @@ double-conv    243.90 MB/s
 - [There is a Rust port](https://github.com/ezrosent/frawk/tree/master/src/runtime/float_parse).
 - [There is a Java port](https://github.com/wrandelshofer/FastDoubleParser).
 - [There is a C# port](https://github.com/CarlVerret/csFastFloat).
-- [Bazel Central Registry](https://registry.bazel.build/modules/fast_double_parser).
 
 ## Credit
 

benchmarks/benchmark.cpp

@@ -20,7 +20,7 @@
 #include <vector>
 
 #include "double-conversion/ieee.h"
-#include "double-conversion/double-conversion.h"
+#include "double-conversion/string-to-double.h"
 
 double findmax_fast_double_parser(const std::vector<std::string>& s) {
   double answer = 0;

fast_double_parser-config.cmake.in

@@ -1,3 +0,0 @@
-@PACKAGE_INIT@
-
-include("${CMAKE_CURRENT_LIST_DIR}/fast_double_parser-targets.cmake")

include/fast_double_parser.h

@@ -190,26 +190,28 @@ really_inline value128 full_multiplication(uint64_t value1, uint64_t value2) {
   return answer;
 }
 
+
 /* result might be undefined when input_num is zero */
 inline int leading_zeroes(uint64_t input_num) {
 #ifdef _MSC_VER
   unsigned long leading_zero = 0;
   // Search the mask data from most significant bit (MSB)
   // to least significant bit (LSB) for a set bit (1).
-#ifdef _WIN64
   if (_BitScanReverse64(&leading_zero, input_num))
     return (int)(63 - leading_zero);
-#else
-  if (_BitScanReverse(&leading_zero, (uint32_t)(input_num >> 32)))
-    return (int)(63 - (leading_zero + 32));
-  if (_BitScanReverse(&leading_zero, (uint32_t)input_num))
-    return (int)(63 - leading_zero);
-#endif // _WIN64
+  else
+    return 64;
 #else
   return __builtin_clzll(input_num);
 #endif // _MSC_VER
 }
 
+// Precomputed powers of ten from 10^0 to 10^22. These
+// can be represented exactly using the double type.
+static const double power_of_ten[] = {
+    1e0,  1e1,  1e2,  1e3,  1e4,  1e5,  1e6,  1e7,  1e8,  1e9,  1e10, 1e11,
+    1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22};
+
 static inline bool is_integer(char c) {
   return (c >= '0' && c <= '9');
   // this gets compiled to (uint8_t)(c - '0') <= 9 on all decent compilers
@@ -227,28 +229,13 @@ static inline bool is_integer(char c) {
  * affect the binary significand.
  */ 
 
-// Attempts to compute i * 10^(power) exactly; and if "negative" is
-// true, negate the result.
-// This function will only work in some cases, when it does not work, success is
-// set to false. This should work *most of the time* (like 99% of the time).
-// We assume that power is in the [FASTFLOAT_SMALLEST_POWER,
-// FASTFLOAT_LARGEST_POWER] interval: the caller is responsible for this check.
-really_inline double compute_float_64(int64_t power, uint64_t i, bool negative,
-                                      bool *success) {
-
-  // Precomputed powers of ten from 10^0 to 10^22. These
-  // can be represented exactly using the double type.
-  static const double power_of_ten[] = {
-      1e0,  1e1,  1e2,  1e3,  1e4,  1e5,  1e6,  1e7,  1e8,  1e9,  1e10, 1e11,
-      1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22};
-
-  // The mantissas of powers of ten from -308 to 308, extended out to sixty four
-  // bits. The array contains the powers of ten approximated
-  // as a 64-bit mantissa. It goes from 10^FASTFLOAT_SMALLEST_POWER to
-  // 10^FASTFLOAT_LARGEST_POWER (inclusively).
-  // The mantissa is truncated, and
-  // never rounded up. Uses about 5KB.
-  static const uint64_t mantissa_64[] = {
+// The mantissas of powers of ten from -308 to 308, extended out to sixty four
+// bits. The array contains the powers of ten approximated
+// as a 64-bit mantissa. It goes from 10^FASTFLOAT_SMALLEST_POWER to 
+// 10^FASTFLOAT_LARGEST_POWER (inclusively). 
+// The mantissa is truncated, and
+// never rounded up. Uses about 5KB.
+static const uint64_t mantissa_64[] = {
     0xa5ced43b7e3e9188, 0xcf42894a5dce35ea,
     0x818995ce7aa0e1b2, 0xa1ebfb4219491a1f,
     0xca66fa129f9b60a6, 0xfd00b897478238d0,
@@ -566,10 +553,10 @@ really_inline double compute_float_64(int64_t power, uint64_t i, bool negative,
     0xbaa718e68396cffd, 0xe950df20247c83fd,
     0x91d28b7416cdd27e, 0xb6472e511c81471d,
     0xe3d8f9e563a198e5, 0x8e679c2f5e44ff8f};
-  // A complement to mantissa_64
-  // complete to a 128-bit mantissa.
-  // Uses about 5KB but is rarely accessed.
-  static const uint64_t mantissa_128[] = {
+// A complement to mantissa_64
+// complete to a 128-bit mantissa.
+// Uses about 5KB but is rarely accessed.
+const uint64_t mantissa_128[] = {
     0x419ea3bd35385e2d, 0x52064cac828675b9,
     0x7343efebd1940993, 0x1014ebe6c5f90bf8,
     0xd41a26e077774ef6, 0x8920b098955522b4,
@@ -888,6 +875,16 @@ really_inline double compute_float_64(int64_t power, uint64_t i, bool negative,
     0x4cdc331d57fa5441, 0xe0133fe4adf8e952,
     0x58180fddd97723a6, 0x570f09eaa7ea7648,};
 
+
+// Attempts to compute i * 10^(power) exactly; and if "negative" is
+// true, negate the result.
+// This function will only work in some cases, when it does not work, success is
+// set to false. This should work *most of the time* (like 99% of the time).
+// We assume that power is in the [FASTFLOAT_SMALLEST_POWER,
+// FASTFLOAT_LARGEST_POWER] interval: the caller is responsible for this check.
+really_inline double compute_float_64(int64_t power, uint64_t i, bool negative,
+                                      bool *success) {
+
   // we start with a fast path
   // It was described in
   // Clinger WD. How to read floating point numbers accurately.
@@ -1104,8 +1101,6 @@ static const char * parse_float_strtod(const char *ptr, double *outDouble) {
 #elif defined(_WIN32)
   static _locale_t c_locale = _create_locale(LC_ALL, "C");
   *outDouble = _strtod_l(ptr, &endptr, c_locale);
-#elif defined(__PASE__)
-  *outDouble = strtod(ptr, &endptr);
 #else
   static locale_t c_locale = newlocale(LC_ALL_MASK, "C", NULL);
   *outDouble = strtod_l(ptr, &endptr, c_locale);

tests/unit.cpp

@@ -226,16 +226,6 @@ void issue32() {
   std::cout << "zero maps to zero" << std::endl;
 }
 
-void negative_subsubnormal_to_negative_zero() {
-  std::string a = "-1e-999";
-  double x;
-  bool ok = fast_double_parser::parse_number(a.c_str(), &x);
-  if(!ok) throw std::runtime_error("could not parse -1e-999");
-  if(!std::signbit(x)) throw std::runtime_error("-1e-999 signbit is positive");
-  if(x != -0) throw std::runtime_error("-1e-999 is not -0");
-  std::cout << "-1e-999 parses to -0" << std::endl;
-}
-
 void issue50_fastpath() {
   std::string a = "-0.0";
   double x;
@@ -245,7 +235,6 @@ void issue50_fastpath() {
   std::cout << "-0.0 signbit is negative" << std::endl;
 }
 
-
 void issue50_off_fastpath() {
   std::string a = "-0.0e-22";
   double x;
@@ -274,27 +263,6 @@ void issue23_2() {
   std::cout << "can parse 5e0012" << std::endl;
 }
 
-void issue63() {
-  std::string a = "1-4-abc";
-  double x;
-  const char * ok = fast_double_parser::parse_number(a.c_str(), &x);
-  if(!ok) throw std::runtime_error("1-4-abc");
-  if(ok != a.c_str() + 1) throw std::runtime_error("does not point at the next number");
-  if(x != 1) throw std::runtime_error("cannot parse 1.");
-  std::cout << "1-4-abc" << std::endl;
-}
-
-void issue2093() {
-  std::string a = "0.95000000000000000000";
-  double x;
-  const char * ok = fast_double_parser::parse_number(a.c_str(), &x);
-  if(!ok) throw std::runtime_error("0.95000000000000000000");
-  if(x != 0.95) throw std::runtime_error("cannot parse 0.95000000000000000000.");
-  std::cout << "0.95000000000000000000" << std::endl;
-}
-
-
-
 inline void Assert(bool Assertion) {
   if (!Assertion)
     throw std::runtime_error("bug");
@@ -339,13 +307,11 @@ int main() {
     printf("Aborting further tests.");
     return EXIT_SUCCESS;
   } 
-  issue2093();
   Assert(basic_test_64bit("1090544144181609348835077142190",0x1.b8779f2474dfbp+99));
   Assert(basic_test_64bit("4503599627370496.5", 4503599627370496.5));
   Assert(basic_test_64bit("4503599627370497.5", 4503599627370497.5));
   Assert(basic_test_64bit("0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000044501477170144022721148195934182639518696390927032912960468522194496444440421538910330590478162701758282983178260792422137401728773891892910553144148156412434867599762821265346585071045737627442980259622449029037796981144446145705102663115100318287949527959668236039986479250965780342141637013812613333119898765515451440315261253813266652951306000184917766328660755595837392240989947807556594098101021612198814605258742579179000071675999344145086087205681577915435923018910334964869420614052182892431445797605163650903606514140377217442262561590244668525767372446430075513332450079650686719491377688478005309963967709758965844137894433796621993967316936280457084866613206797017728916080020698679408551343728867675409720757232455434770912461317493580281734466552734375", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000044501477170144022721148195934182639518696390927032912960468522194496444440421538910330590478162701758282983178260792422137401728773891892910553144148156412434867599762821265346585071045737627442980259622449029037796981144446145705102663115100318287949527959668236039986479250965780342141637013812613333119898765515451440315261253813266652951306000184917766328660755595837392240989947807556594098101021612198814605258742579179000071675999344145086087205681577915435923018910334964869420614052182892431445797605163650903606514140377217442262561590244668525767372446430075513332450079650686719491377688478005309963967709758965844137894433796621993967316936280457084866613206797017728916080020698679408551343728867675409720757232455434770912461317493580281734466552734375));
   Assert(basic_test_64bit("0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072008890245868760858598876504231122409594654935248025624400092282356951787758888037591552642309780950434312085877387158357291821993020294379224223559819827501242041788969571311791082261043971979604000454897391938079198936081525613113376149842043271751033627391549782731594143828136275113838604094249464942286316695429105080201815926642134996606517803095075913058719846423906068637102005108723282784678843631944515866135041223479014792369585208321597621066375401613736583044193603714778355306682834535634005074073040135602968046375918583163124224521599262546494300836851861719422417646455137135420132217031370496583210154654068035397417906022589503023501937519773030945763173210852507299305089761582519159720757232455434770912461317493580281734466552734375", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072008890245868760858598876504231122409594654935248025624400092282356951787758888037591552642309780950434312085877387158357291821993020294379224223559819827501242041788969571311791082261043971979604000454897391938079198936081525613113376149842043271751033627391549782731594143828136275113838604094249464942286316695429105080201815926642134996606517803095075913058719846423906068637102005108723282784678843631944515866135041223479014792369585208321597621066375401613736583044193603714778355306682834535634005074073040135602968046375918583163124224521599262546494300836851861719422417646455137135420132217031370496583210154654068035397417906022589503023501937519773030945763173210852507299305089761582519159720757232455434770912461317493580281734466552734375));
-  issue63();
   issue40();
   issue23();
   issue32();
@@ -394,7 +360,6 @@ int main() {
       throw std::runtime_error("fast_double_parser disagrees");
     }
   }
-  negative_subsubnormal_to_negative_zero();
   std::cout << std::endl;
   std::cout << "All ok" << std::endl;
   printf("Good!\n");