script/manual-test-parse-number-f64.cc

// Copyright 2020 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// ----------------

// manual-test-parse-number-f64.c tests Wuffs' parse_number_f64 function. The
// https://github.com/nigeltao/parse-number-fxx-test-data repository contains
// the data files, containing one test case per line, like:
//
// 3C00 3F800000 3FF0000000000000 1
// 3D00 3FA00000 3FF4000000000000 1.25
// 3D9A 3FB33333 3FF6666666666666 1.4
// 57B7 42F6E979 405EDD2F1A9FBE77 123.456
// 622A 44454000 4088A80000000000 789
// 7C00 7F800000 7FF0000000000000 123.456e789

#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>

// Wuffs ships as a "single file C library" or "header file library" as per
// https://github.com/nothings/stb/blob/master/docs/stb_howto.txt
//
// To use that single file as a "foo.c"-like implementation, instead of a
// "foo.h"-like header, #define WUFFS_IMPLEMENTATION before #include'ing or
// compiling it.
#define WUFFS_IMPLEMENTATION

// Defining the WUFFS_CONFIG__STATIC_FUNCTIONS macro is optional, but when
// combined with WUFFS_IMPLEMENTATION, it demonstrates making all of Wuffs'
// functions have static storage.
//
// This can help the compiler ignore or discard unused code, which can produce
// faster compiles and smaller binaries. Other motivations are discussed in the
// "ALLOW STATIC IMPLEMENTATION" section of
// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt
#define WUFFS_CONFIG__STATIC_FUNCTIONS

// Defining the WUFFS_CONFIG__MODULE* macros are optional, but it lets users of
// release/c/etc.c choose which parts of Wuffs to build. That file contains the
// entire Wuffs standard library, implementing a variety of codecs and file
// formats. Without this macro definition, an optimizing compiler or linker may
// very well discard Wuffs code for unused codecs, but listing the Wuffs
// modules we use makes that process explicit. Preprocessing means that such
// code simply isn't compiled.
#define WUFFS_CONFIG__MODULES
#define WUFFS_CONFIG__MODULE__BASE

// If building this program in an environment that doesn't easily accommodate
// relative includes, you can use the script/inline-c-relative-includes.go
// program to generate a stand-alone C++ file.
#include "../release/c/wuffs-unsupported-snapshot.c"

// Uncomment one or all of these to use the
//  - github.com/lemire/fast_double_parser
//  - github.com/lemire/fast_float
// libraries. These header-only libraries are C++, not C.
//
// #define USE_LEMIRE_FAST_DOUBLE_PARSER
// #define USE_LEMIRE_FAST_FLOAT

#ifdef USE_LEMIRE_FAST_DOUBLE_PARSER
#include "/the/path/to/fast_double_parser/include/fast_double_parser.h"
#endif
#ifdef USE_LEMIRE_FAST_FLOAT
#include "/the/path/to/fast_float/include/fast_float/fast_float.h"
#endif

const uint8_t hex[256] = {
    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,  // 0x00-0x07
    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,  // 0x08-0x0F
    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,  // 0x10-0x17
    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,  // 0x18-0x1F
    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,  // 0x20-0x27
    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,  // 0x28-0x2F
    0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7,  // 0x30-0x37 0-7
    0x8, 0x9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,  // 0x38-0x3F 8-9

    0x0, 0xA, 0xB, 0xC, 0xD, 0xE, 0xF, 0x0,  // 0x40-0x47 A-F
    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,  // 0x48-0x4F
    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,  // 0x50-0x57
    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,  // 0x58-0x5F
    0x0, 0xA, 0xB, 0xC, 0xD, 0xE, 0xF, 0x0,  // 0x60-0x67 a-f
    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,  // 0x68-0x6F
    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,  // 0x70-0x77
    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,  // 0x78-0x7F

    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,  // 0x80-0x87
    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,  // 0x88-0x8F
    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,  // 0x90-0x97
    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,  // 0x98-0x9F
    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,  // 0xA0-0xA7
    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,  // 0xA8-0xAF
    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,  // 0xB0-0xB7
    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,  // 0xB8-0xBF

    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,  // 0xC0-0xC7
    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,  // 0xC8-0xCF
    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,  // 0xD0-0xD7
    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,  // 0xD8-0xDF
    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,  // 0xE0-0xE7
    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,  // 0xE8-0xEF
    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,  // 0xF0-0xF7
    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,  // 0xF8-0xFF
};

#ifndef SRC_BUFFER_ARRAY_SIZE
#define SRC_BUFFER_ARRAY_SIZE (64 * 1024 * 1024)
#endif

uint8_t g_src_buffer_array[SRC_BUFFER_ARRAY_SIZE];

wuffs_base__io_buffer g_src;

const char* g_filename;
FILE* g_file;
uint64_t g_line;

const char*  //
read_src() {
  if (g_src.meta.closed) {
    return "main: internal error: read requested on a closed source";
  }
  wuffs_base__io_buffer__compact(&g_src);
  if (g_src.meta.wi >= g_src.data.len) {
    return "main: g_src buffer is full";
  }
  size_t n = fread(g_src.data.ptr + g_src.meta.wi, sizeof(uint8_t),
                   g_src.data.len - g_src.meta.wi, g_file);
  g_src.meta.wi += n;
  g_src.meta.closed = feof(g_file);
  if ((n == 0) && !g_src.meta.closed) {
    return "main: read error";
  }
  return NULL;
}

void  //
fail_parse(const char* impl, const char* z) {
  fprintf(stderr, "main: %s could not parse \"%s\" at %s:%" PRIu64 "\n", impl,
          z, g_filename, g_line);
}

void  //
fail(const char* impl, const char* z, uint64_t have, uint64_t want) {
  fprintf(stderr, "main: %s mismatch at %s:%" PRIu64 "\n", impl, g_filename,
          g_line);
  fprintf(stderr, "src:  %s\n", z);
  fprintf(stderr, "have: 0x%016" PRIX64 " %f\n", have,
          wuffs_base__ieee_754_bit_representation__from_u64_to_f64(have));
  fprintf(stderr, "want: 0x%016" PRIX64 " %f\n", want,
          wuffs_base__ieee_754_bit_representation__from_u64_to_f64(want));
}

bool  //
process_line(wuffs_base__slice_u8 s) {
  if (s.len < 32) {
    fprintf(stderr, "main: short input at %s:%" PRIu64 "\n", g_filename,
            g_line);
    return false;
  } else if (s.len > 2048) {
    fprintf(stderr, "main: long input at %s:%" PRIu64 "\n", g_filename, g_line);
    return false;
  }
  uint64_t want = 0;
  for (int i = 14; i < 30; i++) {
    want = (want << 4) | hex[s.ptr[i]];
  }
  s.ptr += 31;
  s.len -= 31;

  // Convert ".123" to "0.123". Not all parsers like a leading dot.
  if (s.ptr[0] == '.') {
    s.ptr--;
    s.len++;
    s.ptr[0] = '0';
  }

  char z[2049];
  memcpy(&z[0], s.ptr, s.len);
  z[s.len] = 0;

  // Check libc's strtod.
  {
    double have_f64 = strtod(&z[0], NULL);
    uint64_t have =
        wuffs_base__ieee_754_bit_representation__from_f64_to_u64(have_f64);
    if (have != want) {
      fail("strtod", &z[0], have, want);
      return false;
    }
  }

#ifdef USE_LEMIRE_FAST_DOUBLE_PARSER
  // Check lemire/fast_double_parser's parse_number.
  //
  // https://github.com/lemire/fast_double_parser/blob/master/README.md says
  // "the parser will reject overly large values that would not fit in
  // binary64. It will not produce NaN or infinite values".
  if (want < 0x7FF0000000000000ul) {
    double have_f64;
    if (!fast_double_parser::decimal_separator_dot::parse_number(&z[0],
                                                                 &have_f64)) {
      fail_parse("lemire/fast_double_parser", &z[0]);
      return false;
    }
    uint64_t have =
        wuffs_base__ieee_754_bit_representation__from_f64_to_u64(have_f64);
    if (have != want) {
      fail("lemire/fast_double_parser", &z[0], have, want);
      return false;
    }
  }
#endif

#ifdef USE_LEMIRE_FAST_FLOAT
  // Check lemire/fast_float's from_chars.
  {
    double have_f64;
    fast_float::from_chars_result result = fast_float::from_chars(
        static_cast<char*>(static_cast<void*>(s.ptr)),
        static_cast<char*>(static_cast<void*>(s.ptr + s.len)), have_f64,
        fast_float::chars_format::general);
    if (result.ec != std::errc()) {
      fail_parse("lemire/fast_float", &z[0]);
      return false;
    }
    uint64_t have =
        wuffs_base__ieee_754_bit_representation__from_f64_to_u64(have_f64);
    if (have != want) {
      fail("lemire/fast_float", &z[0], have, want);
      return false;
    }
  }
#endif

  // Check Wuffs' wuffs_base__parse_number_f64.
  {
    wuffs_base__result_f64 res = wuffs_base__parse_number_f64(
        s, WUFFS_BASE__PARSE_NUMBER_XXX__DEFAULT_OPTIONS);
    if (res.status.repr) {
      fail_parse("wuffs", &z[0]);
      return false;
    }
    uint64_t have =
        wuffs_base__ieee_754_bit_representation__from_f64_to_u64(res.value);
    if (have != want) {
      fail("wuffs", &z[0], have, want);
      return false;
    }
  }

  return true;
}

bool  //
process_file(char* filename) {
  if (g_file) {
    fclose(g_file);
    g_file = NULL;
  }
  g_filename = filename;
  g_file = fopen(g_filename, "rb");
  if (!g_file) {
    fprintf(stderr, "main: could not open %s\n", g_filename);
    return false;
  }
  g_line = 0;
  g_src = wuffs_base__slice_u8__writer(
      wuffs_base__make_slice_u8(&g_src_buffer_array[0], SRC_BUFFER_ARRAY_SIZE));

  while (true) {
    for (size_t i = g_src.meta.ri; i < g_src.meta.wi; i++) {
      if (g_src.data.ptr[i] == '\n') {
        g_line++;
        if (!process_line(wuffs_base__make_slice_u8(
                &g_src.data.ptr[g_src.meta.ri], i - g_src.meta.ri))) {
          return false;
        }
        g_src.meta.ri = i + 1;
        continue;
      }
    }

    if (g_src.meta.closed) {
      if (g_src.meta.ri != g_src.meta.wi) {
        fprintf(stderr, "main: unexpected end-of-file\n");
        return false;
      }
      break;
    }

    const char* error_msg = read_src();
    if (error_msg) {
      fprintf(stderr, "%s\n", error_msg);
      return false;
    }
  }

  printf("%8" PRIu64 " OK in %s\n", g_line, g_filename);
  return true;
}

int  //
main(int argc, char** argv) {
  g_file = NULL;
  for (int argi = 1; argi < argc; argi++) {
    if (!process_file(argv[argi])) {
      return 1;
    }
  }
  return 0;
}