/*
 * Copyright 2016 WebAssembly Community Group participants
 *
 * 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
 *
 *     http://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.
 */

#include "literal.h"

#include <assert.h>
#include <errno.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>

#define HEX_DIGIT_BITS 4

/* The PLUS_ONE values are used because normal IEEE floats have an implicit
 * leading one, so they have an additional bit of precision. */

#define F32_SIGN_SHIFT 31
#define F32_SIG_BITS 23
#define F32_SIG_MASK 0x7fffff
#define F32_SIG_PLUS_ONE_BITS 24
#define F32_SIG_PLUS_ONE_MASK 0xffffff
#define F32_EXP_MASK 0xff
#define F32_MIN_EXP -127
#define F32_MAX_EXP 128
#define F32_EXP_BIAS 127
#define F32_QUIET_NAN_TAG 0x400000

#define F64_SIGN_SHIFT 63
#define F64_SIG_BITS 52
#define F64_SIG_MASK 0xfffffffffffffULL
#define F64_SIG_PLUS_ONE_BITS 53
#define F64_SIG_PLUS_ONE_MASK 0x1fffffffffffffULL
#define F64_EXP_MASK 0x7ff
#define F64_MIN_EXP -1023
#define F64_MAX_EXP 1024
#define F64_EXP_BIAS 1023
#define F64_QUIET_NAN_TAG 0x8000000000000ULL

namespace wabt {

static const char s_hex_digits[] = "0123456789abcdef";

Result parse_hexdigit(char c, uint32_t* out) {
  if (static_cast<unsigned int>(c - '0') <= 9) {
    *out = c - '0';
    return Result::Ok;
  } else if (static_cast<unsigned int>(c - 'a') <= 6) {
    *out = 10 + (c - 'a');
    return Result::Ok;
  } else if (static_cast<unsigned int>(c - 'A') <= 6) {
    *out = 10 + (c - 'A');
    return Result::Ok;
  }
  return Result::Error;
}

/* return 1 if the non-NULL-terminated string starting with |start| and ending
 with |end| starts with the NULL-terminated string |prefix|. */
static bool string_starts_with(const char* start,
                               const char* end,
                               const char* prefix) {
  while (start < end && *prefix) {
    if (*start != *prefix)
      return false;
    start++;
    prefix++;
  }
  return *prefix == 0;
}

Result parse_uint64(const char* s, const char* end, uint64_t* out) {
  if (s == end)
    return Result::Error;
  uint64_t value = 0;
  if (*s == '0' && s + 1 < end && s[1] == 'x') {
    s += 2;
    if (s == end)
      return Result::Error;
    for (; s < end; ++s) {
      uint32_t digit;
      if (WABT_FAILED(parse_hexdigit(*s, &digit)))
        return Result::Error;
      uint64_t old_value = value;
      value = value * 16 + digit;
      /* check for overflow */
      if (old_value > value)
        return Result::Error;
    }
  } else {
    for (; s < end; ++s) {
      uint32_t digit = (*s - '0');
      if (digit > 9)
        return Result::Error;
      uint64_t old_value = value;
      value = value * 10 + digit;
      /* check for overflow */
      if (old_value > value)
        return Result::Error;
    }
  }
  if (s != end)
    return Result::Error;
  *out = value;
  return Result::Ok;
}

Result parse_int64(const char* s,
                   const char* end,
                   uint64_t* out,
                   ParseIntType parse_type) {
  bool has_sign = false;
  if (*s == '-' || *s == '+') {
    if (parse_type == ParseIntType::UnsignedOnly)
      return Result::Error;
    if (*s == '-')
      has_sign = true;
    s++;
  }
  uint64_t value = 0;
  Result result = parse_uint64(s, end, &value);
  if (has_sign) {
    /* abs(INT64_MIN) == INT64_MAX + 1 */
    if (value > static_cast<uint64_t>(INT64_MAX) + 1)
      return Result::Error;
    value = UINT64_MAX - value + 1;
  }
  *out = value;
  return result;
}

Result parse_int32(const char* s,
                   const char* end,
                   uint32_t* out,
                   ParseIntType parse_type) {
  uint64_t value;
  bool has_sign = false;
  if (*s == '-' || *s == '+') {
    if (parse_type == ParseIntType::UnsignedOnly)
      return Result::Error;
    if (*s == '-')
      has_sign = true;
    s++;
  }
  if (WABT_FAILED(parse_uint64(s, end, &value)))
    return Result::Error;

  if (has_sign) {
    /* abs(INT32_MIN) == INT32_MAX + 1 */
    if (value > static_cast<uint64_t>(INT32_MAX) + 1)
      return Result::Error;
    value = UINT32_MAX - value + 1;
  } else {
    if (value > static_cast<uint64_t>(UINT32_MAX))
      return Result::Error;
  }
  *out = static_cast<uint32_t>(value);
  return Result::Ok;
}

/* floats */
static uint32_t make_float(bool sign, int exp, uint32_t sig) {
  assert(exp >= F32_MIN_EXP && exp <= F32_MAX_EXP);
  assert(sig <= F32_SIG_MASK);
  return (static_cast<uint32_t>(sign) << F32_SIGN_SHIFT) |
         (static_cast<uint32_t>(exp + F32_EXP_BIAS) << F32_SIG_BITS) | sig;
}

static uint32_t shift_float_and_round_to_nearest(uint32_t significand,
                                                 int shift) {
  assert(shift > 0);
  /* round ties to even */
  if (significand & (1U << shift))
    significand += 1U << (shift - 1);
  significand >>= shift;
  return significand;
}

static Result parse_float_nan(const char* s,
                              const char* end,
                              uint32_t* out_bits) {
  bool is_neg = false;
  if (*s == '-') {
    is_neg = true;
    s++;
  } else if (*s == '+') {
    s++;
  }
  assert(string_starts_with(s, end, "nan"));
  s += 3;

  uint32_t tag;
  if (s != end) {
    tag = 0;
    assert(string_starts_with(s, end, ":0x"));
    s += 3;

    for (; s < end; ++s) {
      uint32_t digit;
      if (WABT_FAILED(parse_hexdigit(*s, &digit)))
        return Result::Error;
      tag = tag * 16 + digit;
      /* check for overflow */
      if (tag > F32_SIG_MASK)
        return Result::Error;
    }

    /* NaN cannot have a zero tag, that is reserved for infinity */
    if (tag == 0)
      return Result::Error;
  } else {
    tag = F32_QUIET_NAN_TAG;
  }

  *out_bits = make_float(is_neg, F32_MAX_EXP, tag);
  return Result::Ok;
}

static void parse_float_hex(const char* s,
                            const char* end,
                            uint32_t* out_bits) {
  bool is_neg = false;
  if (*s == '-') {
    is_neg = true;
    s++;
  } else if (*s == '+') {
    s++;
  }
  assert(string_starts_with(s, end, "0x"));
  s += 2;

  /* loop over the significand; everything up to the 'p'.
   this code is a bit nasty because we want to support extra zeroes anywhere
   without having to use many significand bits.
   e.g.
   0x00000001.0p0 => significand = 1, significand_exponent = 0
   0x10000000.0p0 => significand = 1, significand_exponent = 28
   0x0.000001p0 => significand = 1, significand_exponent = -24
   */
  bool seen_dot = false;
  uint32_t significand = 0;
  /* how much to shift |significand| if a non-zero value is appended */
  int significand_shift = 0;
  int significand_bits = 0;     /* bits of |significand| */
  int significand_exponent = 0; /* exponent adjustment due to dot placement */
  for (; s < end; ++s) {
    uint32_t digit;
    if (*s == '.') {
      if (significand != 0)
        significand_exponent += significand_shift;
      significand_shift = 0;
      seen_dot = true;
      continue;
    } else if (WABT_FAILED(parse_hexdigit(*s, &digit))) {
      break;
    }
    significand_shift += HEX_DIGIT_BITS;
    if (digit != 0 && (significand == 0 ||
                       significand_bits + significand_shift <=
                           F32_SIG_BITS + 1 + HEX_DIGIT_BITS)) {
      if (significand != 0)
        significand <<= significand_shift;
      if (seen_dot)
        significand_exponent -= significand_shift;
      significand += digit;
      significand_shift = 0;
      significand_bits += HEX_DIGIT_BITS;
    }
  }

  if (!seen_dot)
    significand_exponent += significand_shift;

  if (significand == 0) {
    /* 0 or -0 */
    *out_bits = make_float(is_neg, F32_MIN_EXP, 0);
    return;
  }

  int exponent = 0;
  bool exponent_is_neg = false;
  if (s < end) {
    assert(*s == 'p');
    s++;
    /* exponent is always positive, but significand_exponent is signed.
     significand_exponent_add is negated if exponent will be negative, so it  can
     be easily summed to see if the exponent is too large (see below) */
    int significand_exponent_add = 0;
    if (*s == '-') {
      exponent_is_neg = true;
      significand_exponent_add = -significand_exponent;
      s++;
    } else if (*s == '+') {
      s++;
      significand_exponent_add = significand_exponent;
    }

    for (; s < end; ++s) {
      uint32_t digit = (*s - '0');
      assert(digit <= 9);
      exponent = exponent * 10 + digit;
      if (exponent + significand_exponent_add >= F32_MAX_EXP)
        break;
    }
  }

  if (exponent_is_neg)
    exponent = -exponent;

  significand_bits = sizeof(uint32_t) * 8 - wabt_clz_u32(significand);
  /* -1 for the implicit 1 bit of the significand */
  exponent += significand_exponent + significand_bits - 1;

  if (exponent >= F32_MAX_EXP) {
    /* inf or -inf */
    *out_bits = make_float(is_neg, F32_MAX_EXP, 0);
  } else if (exponent <= F32_MIN_EXP) {
    /* maybe subnormal */
    if (significand_bits > F32_SIG_BITS) {
      significand = shift_float_and_round_to_nearest(
          significand, significand_bits - F32_SIG_BITS);
    } else if (significand_bits < F32_SIG_BITS) {
      significand <<= (F32_SIG_BITS - significand_bits);
    }

    int shift = F32_MIN_EXP - exponent;
    if (shift < F32_SIG_BITS) {
      if (shift) {
        significand =
            shift_float_and_round_to_nearest(significand, shift) & F32_SIG_MASK;
      }
      exponent = F32_MIN_EXP;

      if (significand != 0) {
        *out_bits = make_float(is_neg, exponent, significand);
        return;
      }
    }

    /* not subnormal, too small; return 0 or -0 */
    *out_bits = make_float(is_neg, F32_MIN_EXP, 0);
  } else {
    /* normal value */
    if (significand_bits > F32_SIG_PLUS_ONE_BITS) {
      significand = shift_float_and_round_to_nearest(
          significand, significand_bits - F32_SIG_PLUS_ONE_BITS);
      if (significand > F32_SIG_PLUS_ONE_MASK)
        exponent++;
    } else if (significand_bits < F32_SIG_PLUS_ONE_BITS) {
      significand <<= (F32_SIG_PLUS_ONE_BITS - significand_bits);
    }

    *out_bits = make_float(is_neg, exponent, significand & F32_SIG_MASK);
  }
}

static void parse_float_infinity(const char* s,
                                 const char* end,
                                 uint32_t* out_bits) {
  bool is_neg = false;
  if (*s == '-') {
    is_neg = true;
    s++;
  } else if (*s == '+') {
    s++;
  }
  assert(string_starts_with(s, end, "infinity"));
  *out_bits = make_float(is_neg, F32_MAX_EXP, 0);
}

Result parse_float(LiteralType literal_type,
                   const char* s,
                   const char* end,
                   uint32_t* out_bits) {
#if COMPILER_IS_MSVC
  if (literal_type == LiteralType::Int && string_starts_with(s, end, "0x"))
  {
    // Some MSVC crt implementation of strtof doesn't support hex strings
    literal_type = LiteralType::Hexfloat;
  }
#endif
  switch (literal_type) {
    case LiteralType::Int:
    case LiteralType::Float: {
      errno = 0;
      char* endptr;
      float value;
      value = strtof(s, &endptr);
      if (endptr != end ||
          ((value == 0 || value == HUGE_VALF || value == -HUGE_VALF) &&
           errno != 0))
        return Result::Error;

      memcpy(out_bits, &value, sizeof(value));
      return Result::Ok;
    }

    case LiteralType::Hexfloat:
      parse_float_hex(s, end, out_bits);
      return Result::Ok;

    case LiteralType::Infinity:
      parse_float_infinity(s, end, out_bits);
      return Result::Ok;

    case LiteralType::Nan:
      return parse_float_nan(s, end, out_bits);

    default:
      assert(0);
      return Result::Error;
  }
}

void write_float_hex(char* out, size_t size, uint32_t bits) {
  /* 1234567890123456 */
  /* -0x#.######p-### */
  /* -nan:0x###### */
  /* -infinity */
  char buffer[WABT_MAX_FLOAT_HEX];
  char* p = buffer;
  bool is_neg = (bits >> F32_SIGN_SHIFT);
  int exp = ((bits >> F32_SIG_BITS) & F32_EXP_MASK) - F32_EXP_BIAS;
  uint32_t sig = bits & F32_SIG_MASK;

  if (is_neg)
    *p++ = '-';
  if (exp == F32_MAX_EXP) {
    /* infinity or nan */
    if (sig == 0) {
      strcpy(p, "infinity");
      p += 8;
    } else {
      strcpy(p, "nan");
      p += 3;
      if (sig != F32_QUIET_NAN_TAG) {
        strcpy(p, ":0x");
        p += 3;
        /* skip leading zeroes */
        int num_nybbles = sizeof(uint32_t) * 8 / 4;
        while ((sig & 0xf0000000) == 0) {
          sig <<= 4;
          num_nybbles--;
        }
        while (num_nybbles) {
          uint32_t nybble = (sig >> (sizeof(uint32_t) * 8 - 4)) & 0xf;
          *p++ = s_hex_digits[nybble];
          sig <<= 4;
          --num_nybbles;
        }
      }
    }
  } else {
    bool is_zero = sig == 0 && exp == F32_MIN_EXP;
    strcpy(p, "0x");
    p += 2;
    *p++ = is_zero ? '0' : '1';

    /* shift sig up so the top 4-bits are at the top of the uint32 */
    sig <<= sizeof(uint32_t) * 8 - F32_SIG_BITS;

    if (sig) {
      if (exp == F32_MIN_EXP) {
        /* subnormal; shift the significand up, and shift out the implicit 1 */
        uint32_t leading_zeroes = wabt_clz_u32(sig);
        if (leading_zeroes < 31)
          sig <<= leading_zeroes + 1;
        else
          sig = 0;
        exp -= leading_zeroes;
      }

      *p++ = '.';
      while (sig) {
        uint32_t nybble = (sig >> (sizeof(uint32_t) * 8 - 4)) & 0xf;
        *p++ = s_hex_digits[nybble];
        sig <<= 4;
      }
    }
    *p++ = 'p';
    if (is_zero) {
      strcpy(p, "+0");
      p += 2;
    } else {
      if (exp < 0) {
        *p++ = '-';
        exp = -exp;
      } else {
        *p++ = '+';
      }
      if (exp >= 100)
        *p++ = '1';
      if (exp >= 10)
        *p++ = '0' + (exp / 10) % 10;
      *p++ = '0' + exp % 10;
    }
  }

  size_t len = p - buffer;
  if (len >= size)
    len = size - 1;
  memcpy(out, buffer, len);
  out[len] = '\0';
}

/* doubles */
static uint64_t make_double(bool sign, int exp, uint64_t sig) {
  assert(exp >= F64_MIN_EXP && exp <= F64_MAX_EXP);
  assert(sig <= F64_SIG_MASK);
  return (static_cast<uint64_t>(sign) << F64_SIGN_SHIFT) |
         (static_cast<uint64_t>(exp + F64_EXP_BIAS) << F64_SIG_BITS) | sig;
}

static uint64_t shift_double_and_round_to_nearest(uint64_t significand,
                                                  int shift) {
  assert(shift > 0);
  /* round ties to even */
  if (significand & (static_cast<uint64_t>(1) << shift))
    significand += static_cast<uint64_t>(1) << (shift - 1);
  significand >>= shift;
  return significand;
}

static Result parse_double_nan(const char* s,
                               const char* end,
                               uint64_t* out_bits) {
  bool is_neg = false;
  if (*s == '-') {
    is_neg = true;
    s++;
  } else if (*s == '+') {
    s++;
  }
  assert(string_starts_with(s, end, "nan"));
  s += 3;

  uint64_t tag;
  if (s != end) {
    tag = 0;
    if (!string_starts_with(s, end, ":0x"))
      return Result::Error;
    s += 3;

    for (; s < end; ++s) {
      uint32_t digit;
      if (WABT_FAILED(parse_hexdigit(*s, &digit)))
        return Result::Error;
      tag = tag * 16 + digit;
      /* check for overflow */
      if (tag > F64_SIG_MASK)
        return Result::Error;
    }

    /* NaN cannot have a zero tag, that is reserved for infinity */
    if (tag == 0)
      return Result::Error;
  } else {
    tag = F64_QUIET_NAN_TAG;
  }

  *out_bits = make_double(is_neg, F64_MAX_EXP, tag);
  return Result::Ok;
}

static void parse_double_hex(const char* s,
                             const char* end,
                             uint64_t* out_bits) {
  bool is_neg = false;
  if (*s == '-') {
    is_neg = true;
    s++;
  } else if (*s == '+') {
    s++;
  }
  assert(string_starts_with(s, end, "0x"));
  s += 2;

  /* see the similar comment in parse_float_hex */
  bool seen_dot = false;
  uint64_t significand = 0;
  /* how much to shift |significand| if a non-zero value is appended */
  int significand_shift = 0;
  int significand_bits = 0;     /* bits of |significand| */
  int significand_exponent = 0; /* exponent adjustment due to dot placement */
  for (; s < end; ++s) {
    uint32_t digit;
    if (*s == '.') {
      if (significand != 0)
        significand_exponent += significand_shift;
      significand_shift = 0;
      seen_dot = true;
      continue;
    } else if (WABT_FAILED(parse_hexdigit(*s, &digit))) {
      break;
    }
    significand_shift += HEX_DIGIT_BITS;
    if (digit != 0 && (significand == 0 ||
                       significand_bits + significand_shift <=
                           F64_SIG_BITS + 1 + HEX_DIGIT_BITS)) {
      if (significand != 0)
        significand <<= significand_shift;
      if (seen_dot)
        significand_exponent -= significand_shift;
      significand += digit;
      significand_shift = 0;
      significand_bits += HEX_DIGIT_BITS;
    }
  }

  if (!seen_dot)
    significand_exponent += significand_shift;

  if (significand == 0) {
    /* 0 or -0 */
    *out_bits = make_double(is_neg, F64_MIN_EXP, 0);
    return;
  }

  int exponent = 0;
  bool exponent_is_neg = false;
  if (s < end) {
    assert(*s == 'p');
    s++;

    /* exponent is always positive, but significand_exponent is signed.
     significand_exponent_add is negated if exponent will be negative, so it  can
     be easily summed to see if the exponent is too large (see below) */
    int significand_exponent_add = 0;
    if (*s == '-') {
      exponent_is_neg = true;
      significand_exponent_add = -significand_exponent;
      s++;
    } else if (*s == '+') {
      s++;
      significand_exponent_add = significand_exponent;
    }

    for (; s < end; ++s) {
      uint32_t digit = (*s - '0');
      assert(digit <= 9);
      exponent = exponent * 10 + digit;
      if (exponent + significand_exponent_add >= F64_MAX_EXP)
        break;
    }
  }

  if (exponent_is_neg)
    exponent = -exponent;

  significand_bits = sizeof(uint64_t) * 8 - wabt_clz_u64(significand);
  /* -1 for the implicit 1 bit of the significand */
  exponent += significand_exponent + significand_bits - 1;

  if (exponent >= F64_MAX_EXP) {
    /* inf or -inf */
    *out_bits = make_double(is_neg, F64_MAX_EXP, 0);
  } else if (exponent <= F64_MIN_EXP) {
    /* maybe subnormal */
    if (significand_bits > F64_SIG_BITS) {
      significand = shift_double_and_round_to_nearest(
          significand, significand_bits - F64_SIG_BITS);
    } else if (significand_bits < F64_SIG_BITS) {
      significand <<= (F64_SIG_BITS - significand_bits);
    }

    int shift = F64_MIN_EXP - exponent;
    if (shift < F64_SIG_BITS) {
      if (shift) {
        significand = shift_double_and_round_to_nearest(significand, shift) &
                      F64_SIG_MASK;
      }
      exponent = F64_MIN_EXP;

      if (significand != 0) {
        *out_bits = make_double(is_neg, exponent, significand);
        return;
      }
    }

    /* not subnormal, too small; return 0 or -0 */
    *out_bits = make_double(is_neg, F64_MIN_EXP, 0);
  } else {
    /* normal value */
    if (significand_bits > F64_SIG_PLUS_ONE_BITS) {
      significand = shift_double_and_round_to_nearest(
          significand, significand_bits - F64_SIG_PLUS_ONE_BITS);
      if (significand > F64_SIG_PLUS_ONE_MASK)
        exponent++;
    } else if (significand_bits < F64_SIG_PLUS_ONE_BITS) {
      significand <<= (F64_SIG_PLUS_ONE_BITS - significand_bits);
    }

    *out_bits = make_double(is_neg, exponent, significand & F64_SIG_MASK);
  }
}

static void parse_double_infinity(const char* s,
                                  const char* end,
                                  uint64_t* out_bits) {
  bool is_neg = false;
  if (*s == '-') {
    is_neg = true;
    s++;
  } else if (*s == '+') {
    s++;
  }
  assert(string_starts_with(s, end, "infinity"));
  *out_bits = make_double(is_neg, F64_MAX_EXP, 0);
}

Result parse_double(LiteralType literal_type,
                    const char* s,
                    const char* end,
                    uint64_t* out_bits) {

#if COMPILER_IS_MSVC
  if (literal_type == LiteralType::Int && string_starts_with(s, end, "0x"))
  {
    // Some MSVC crt implementation of strtod doesn't support hex strings
    literal_type = LiteralType::Hexfloat;
  }
#endif
  switch (literal_type) {
    case LiteralType::Int:
    case LiteralType::Float: {
      errno = 0;
      char* endptr;
      double value;
      value = strtod(s, &endptr);
      if (endptr != end ||
          ((value == 0 || value == HUGE_VAL || value == -HUGE_VAL) &&
           errno != 0))
        return Result::Error;

      memcpy(out_bits, &value, sizeof(value));
      return Result::Ok;
    }

    case LiteralType::Hexfloat:
      parse_double_hex(s, end, out_bits);
      return Result::Ok;

    case LiteralType::Infinity:
      parse_double_infinity(s, end, out_bits);
      return Result::Ok;

    case LiteralType::Nan:
      return parse_double_nan(s, end, out_bits);

    default:
      assert(0);
      return Result::Error;
  }
}

void write_double_hex(char* out, size_t size, uint64_t bits) {
  /* 123456789012345678901234 */
  /* -0x#.#############p-#### */
  /* -nan:0x############# */
  /* -infinity */
  char buffer[WABT_MAX_DOUBLE_HEX];
  char* p = buffer;
  bool is_neg = (bits >> F64_SIGN_SHIFT);
  int exp = ((bits >> F64_SIG_BITS) & F64_EXP_MASK) - F64_EXP_BIAS;
  uint64_t sig = bits & F64_SIG_MASK;

  if (is_neg)
    *p++ = '-';
  if (exp == F64_MAX_EXP) {
    /* infinity or nan */
    if (sig == 0) {
      strcpy(p, "infinity");
      p += 8;
    } else {
      strcpy(p, "nan");
      p += 3;
      if (sig != F64_QUIET_NAN_TAG) {
        strcpy(p, ":0x");
        p += 3;
        /* skip leading zeroes */
        int num_nybbles = sizeof(uint64_t) * 8 / 4;
        while ((sig & 0xf000000000000000ULL) == 0) {
          sig <<= 4;
          num_nybbles--;
        }
        while (num_nybbles) {
          uint32_t nybble = (sig >> (sizeof(uint64_t) * 8 - 4)) & 0xf;
          *p++ = s_hex_digits[nybble];
          sig <<= 4;
          --num_nybbles;
        }
      }
    }
  } else {
    bool is_zero = sig == 0 && exp == F64_MIN_EXP;
    strcpy(p, "0x");
    p += 2;
    *p++ = is_zero ? '0' : '1';

    /* shift sig up so the top 4-bits are at the top of the uint32 */
    sig <<= sizeof(uint64_t) * 8 - F64_SIG_BITS;

    if (sig) {
      if (exp == F64_MIN_EXP) {
        /* subnormal; shift the significand up, and shift out the implicit 1 */
        uint32_t leading_zeroes = wabt_clz_u64(sig);
        if (leading_zeroes < 63)
          sig <<= leading_zeroes + 1;
        else
          sig = 0;
        exp -= leading_zeroes;
      }

      *p++ = '.';
      while (sig) {
        uint32_t nybble = (sig >> (sizeof(uint64_t) * 8 - 4)) & 0xf;
        *p++ = s_hex_digits[nybble];
        sig <<= 4;
      }
    }
    *p++ = 'p';
    if (is_zero) {
      strcpy(p, "+0");
      p += 2;
    } else {
      if (exp < 0) {
        *p++ = '-';
        exp = -exp;
      } else {
        *p++ = '+';
      }
      if (exp >= 1000)
        *p++ = '1';
      if (exp >= 100)
        *p++ = '0' + (exp / 100) % 10;
      if (exp >= 10)
        *p++ = '0' + (exp / 10) % 10;
      *p++ = '0' + exp % 10;
    }
  }

  size_t len = p - buffer;
  if (len >= size)
    len = size - 1;
  memcpy(out, buffer, len);
  out[len] = '\0';
}

}  // namespace wabt