view release on metacpan or  search on metacpan

deps/hiredis/ffc.h  view on Meta::CPAN

  // way around again. This is very uncommon.
  if (am.power2 < 0) {
    am = ffc_digit_comp(pns, am, vk);
  }
  ffc_debug("am post mantissa: %llu\n", am.mantissa);
  ffc_debug("am post power2:   %d\n", am.power2);
  ffc_am_to_float(pns.negative, am, value, vk);

  // Test for over/underflow.
  if ((pns.mantissa != 0 && am.mantissa == 0 && am.power2 == 0) ||
      am.power2 == ffc_const(vk, INFINITE_POWER)) {
    answer.outcome = FFC_OUTCOME_OUT_OF_RANGE;
  }
  return answer;
}

ffc_internal ffc_inline
ffc_result ffc_from_chars(char* first, char* last, ffc_parse_options options, ffc_value *value, ffc_value_kind vk) {

  // Alias for parity with cpp code, no feature macros to apply
  ffc_format const fmt = options.format;

  ffc_result answer;
  if ((uint64_t)(fmt & FFC_FORMAT_FLAG_SKIP_WHITE_SPACE)) {
    while ((first != last) && ffc_is_space(*first)) {
      first++;
    }
  }
  if (first == last) {
    answer.outcome = FFC_OUTCOME_INVALID_INPUT;
    answer.ptr = first;
    return answer;
  }
  uint64_t json_mode = (uint64_t)(fmt & FFC_FORMAT_FLAG_BASIC_JSON);
  ffc_parsed pns = ffc_parse_number_string(first, last, options, json_mode);

  #ifdef FFC_DEBUG
  ffc_dump_parsed(pns);
  #endif                          

  if (!pns.valid) {
    if ((uint64_t)(fmt & FFC_FORMAT_FLAG_NO_INFNAN)) {
      answer.outcome = FFC_OUTCOME_INVALID_INPUT;
      answer.ptr = first;
      return answer;
    } else {
      return ffc_parse_infnan(first, last, value, vk, fmt);
    }
  }

  // call overload that takes parsed_number_string directly.
  return ffc_from_chars_advanced(pns, value, vk);
}

/* extern FFC_IMPL_INLINE gives GCC the always_inline directive while also
 * requesting external linkage so non-FFC_IMPL TUs can link these symbols. */
extern FFC_IMPL_INLINE ffc_result ffc_from_chars_double_options(const char *start, const char *end, double* out, ffc_parse_options options) {
  // It would be UB to directly use *out as our ffc_value, even though its the same layout
  ffc_value out_value = {0};

  // The all-important call with a constant VALUE_KIND that should cascade in tons of inlining
  ffc_result result = ffc_from_chars((char*)start, (char*)end, options, &out_value, FFC_VALUE_KIND_DOUBLE);
  *out = out_value.d;
  return result;
}
extern FFC_IMPL_INLINE ffc_result ffc_from_chars_double(char const* first, char const* last, double* out) {
  ffc_parse_options options = ffc_parse_options_default();
  return ffc_from_chars_double_options(first, last, out, options);
}
ffc_result ffc_parse_double(size_t len, const char *s, double *out) {
  char *pend = (char*)(s + len);
  return ffc_from_chars_double(s, pend, out);
}
double ffc_parse_double_simple(size_t len, const char *s, ffc_outcome *outcome) {
  double out = 0.0;
  ffc_result result = ffc_parse_double(len, s, &out);
  if (outcome) {
    *outcome = result.outcome;
  }
  return out;
}

ffc_result ffc_from_chars_float_options(const char *start,  const char *end, float* out, ffc_parse_options options) {
  ffc_value out_value = {0};
  ffc_result result = ffc_from_chars((char*)start, (char*)end, options, &out_value, FFC_VALUE_KIND_FLOAT);
  *out = out_value.f;
  return result;
}
ffc_result ffc_from_chars_float(char const* first, char const* last, float* out) {
  ffc_parse_options options = ffc_parse_options_default();
  return ffc_from_chars_float_options(first, last, out, options);
}
ffc_result ffc_parse_float(size_t len, const char *s, float *out) {
  char *pend = (char*)(s + len);
  return ffc_from_chars_float(s, pend, out);
}
float ffc_parse_float_simple(size_t len, const char *s, ffc_outcome *outcome) {
  float out = 0.0;
  ffc_result result = ffc_parse_float(len, s, &out);
  if (outcome) {
    *outcome = result.outcome;
  }
  return out;
}

ffc_result ffc_parse_i64(size_t len, const char *input, int base, int64_t  *out) {
  char *pend = (char*)(input + len);
  ffc_int_value value_out = {0};
  ffc_result result = ffc_parse_int_string(input, pend, &value_out, FFC_INT_KIND_S64, ffc_parse_options_default(), base);
  *out = value_out.s64;
  return result;
}
ffc_result ffc_parse_u64(size_t len, const char *input, int base, uint64_t *out) {
  char *pend = (char*)(input + len);
  ffc_int_value value_out = {0};
  ffc_result result = ffc_parse_int_string(input, pend, &value_out, FFC_INT_KIND_U64, ffc_parse_options_default(), base);
  *out = value_out.u64;
  return result;
}
ffc_result ffc_parse_i32(size_t len, const char *input, int base, int32_t  *out) {
  char *pend = (char*)(input + len);