ra8_fs_utf.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <stdint.h>
 
#include "ra8_attributes.h"
#include "ra8_err.h"
#include "ra8_fs_fat_internal.h"
#include "ra8_fs_utf_internal.h"
 
/* Every UTF-8 name buffer in this module is sized from a UTF-16 unit cap times
 * the worst case per unit, plus a terminator. Asserting it here rather than
 * trusting the arithmetic in a comment is what stops the two drifting when one
 * of the unit caps moves: a name that fits on disk MUST fit in the buffer it is
 * handed back in, or the conversion reports ::k_ra8_err_no_mem for a name the
 * volume holds perfectly well. */
static_assert((uint32_t)k_lfn_utf8_cap ==
                (((uint32_t)k_utf8_max_per_unit * (uint32_t)k_lfn_write_max) + 1U),
              "k_lfn_utf8_cap must hold the longest VFAT long name in UTF-8");
static_assert((uint32_t)k_exfat_name_u8_cap ==
                (((uint32_t)k_utf8_max_per_unit * (uint32_t)k_exfat_name_cap) + 1U),
              "k_exfat_name_u8_cap must hold the longest exFAT name in UTF-8");
 
/* =============================================================================
 * UTF-8 -> UTF-16
 * =============================================================================
 */

RA8_INTERNAL
static uint8_t internal_utf8_lead(uint8_t b, uint32_t* out_len, uint32_t* out_cp)
{
  const uint32_t u = (uint32_t)b;
  if (u <= (uint32_t)k_utf_ascii_max) {
    *out_len = (uint32_t)k_utf_len_1;
    *out_cp  = u;
    return 1U;
  }
  if ((u & (uint32_t)k_utf_lead2_mask) == (uint32_t)k_utf_lead2_tag) {
    *out_len = (uint32_t)k_utf_len_2;
    *out_cp  = u & (uint32_t)k_utf_lead2_payload;
    return 1U;
  }
  if ((u & (uint32_t)k_utf_lead3_mask) == (uint32_t)k_utf_lead3_tag) {
    *out_len = (uint32_t)k_utf_len_3;
    *out_cp  = u & (uint32_t)k_utf_lead3_payload;
    return 1U;
  }
  if ((u & (uint32_t)k_utf_lead4_mask) == (uint32_t)k_utf_lead4_tag) {
    *out_len = (uint32_t)k_utf_len_4;
    *out_cp  = u & (uint32_t)k_utf_lead4_payload;
    return 1U;
  }
  return 0U;
}

RA8_INTERNAL
static uint8_t internal_utf8_tail(const char* in, uint32_t lead, uint32_t len, uint32_t* io_cp)
{
  for (uint32_t k = 1U; k < len; k++) {
    const uint32_t b = (uint32_t)(unsigned char)in[lead + k];
    if ((b & (uint32_t)k_utf_cont_mask) != (uint32_t)k_utf_cont_tag) {
      return 0U;
    }
    *io_cp = (*io_cp << (uint32_t)k_utf_cont_shift) | (b & (uint32_t)k_utf_cont_payload);
  }
  return 1U;
}

RA8_INTERNAL
static uint8_t internal_utf8_wellformed(uint32_t cp, uint32_t len)
{
  if (len == (uint32_t)k_utf_len_2) {
    return (cp >= (uint32_t)k_utf_min_2byte) ? 1U : 0U;
  }
  if (len == (uint32_t)k_utf_len_3) {
    if (cp < (uint32_t)k_utf_min_3byte) {
      return 0U;
    }
    /* CESU-8 / WTF-8 spell a surrogate as three bytes; UTF-8 never does. */
    if ((cp >= (uint32_t)k_utf_sur_hi_first) && (cp <= (uint32_t)k_utf_sur_last)) {
      return 0U;
    }
    return 1U;
  }
  if (len == (uint32_t)k_utf_len_4) {
    if (cp < (uint32_t)k_utf_min_4byte) {
      return 0U;
    }
    return (cp <= (uint32_t)k_utf_code_max) ? 1U : 0U;
  }
  return 1U; /* one-byte forms are ASCII by construction */
}

RA8_INTERNAL
static ra8_err_t internal_utf8_next(const char* in, uint32_t* io_pos, uint32_t* out_cp)
{
  const uint32_t pos = *io_pos;
  uint32_t       len = 0U;
  uint32_t       cp  = 0U;
  if (internal_utf8_lead((uint8_t)(unsigned char)in[pos], &len, &cp) == 0U) {
    return k_ra8_err_invalid_arg;
  }
  if (internal_utf8_tail(in, pos, len, &cp) == 0U) {
    return k_ra8_err_invalid_arg;
  }
  if (internal_utf8_wellformed(cp, len) == 0U) {
    return k_ra8_err_invalid_arg;
  }
  *io_pos = pos + len;
  *out_cp = cp;
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_utf16_put(uint32_t cp, uint16_t* out, uint32_t cap, uint32_t* io_n)
{
  const uint32_t n = *io_n;
  /* One assignment of a single constant per arm, rather than a ternary whose
   * composite value MISRA 10.6 forbids assigning to the wider uint32_t. */
  uint32_t need = 1U;
  if (cp >= (uint32_t)k_utf_min_4byte) {
    need = 2U;
  }
  if ((n + need) > cap) {
    return k_ra8_err_no_mem;
  }
  if (need == 1U) {
    out[n] = (uint16_t)cp;
  } else {
    const uint32_t rest = cp - (uint32_t)k_utf_min_4byte;
    out[n]      = (uint16_t)((uint32_t)k_utf_sur_hi_first + (rest >> (uint32_t)k_utf_sur_shift));
    out[n + 1U] = (uint16_t)((uint32_t)k_utf_sur_lo_first + (rest & (uint32_t)k_utf_sur_mask));
  }
  *io_n = n + need;
  return k_ra8_ok;
}
 
/* `priv_utf8_to_utf16()`: see header for the documented contract. */
ra8_err_t priv_utf8_to_utf16(const char* in, uint16_t* out, uint32_t cap, uint32_t* out_units)
{
  if ((in == nullptr) || (out == nullptr) || (out_units == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  *out_units   = 0U;
  uint32_t pos = 0U;
  uint32_t n   = 0U;
  /* Bounded (NASA Rule 2): every pass either returns or appends at least one
   * unit, and ::priv_utf16_put refuses to grow past `cap`. */
  while (n <= cap) {
    if (in[pos] == '\0') {
      *out_units = n;
      return k_ra8_ok;
    }
    uint32_t  cp  = 0U;
    ra8_err_t err = internal_utf8_next(in, &pos, &cp);
    if (err != k_ra8_ok) {
      return err;
    }
    err = internal_utf16_put(cp, out, cap, &n);
    if (err != k_ra8_ok) {
      return err;
    }
  }
  /* Unreachable: the loop's only exits are the three returns above. This is the
   * Rule 2 bound's exit, not a fourth answer. */
  return k_ra8_err_no_mem; /* GCOVR_EXCL_LINE -- bounded-loop fallback after exhaustive returns */
}
 
/* =============================================================================
 * UTF-16 -> UTF-8
 * =============================================================================
 */

RA8_INTERNAL
static ra8_err_t
internal_utf16_take(const uint16_t* in, uint32_t units, uint32_t* io_i, uint32_t* out_cp)
{
  const uint32_t i  = *io_i;
  const uint32_t hi = (uint32_t)in[i];
  if ((hi < (uint32_t)k_utf_sur_hi_first) || (hi > (uint32_t)k_utf_sur_last)) {
    *out_cp = hi;
    *io_i   = i + 1U;
    return k_ra8_ok;
  }
  if (hi >= (uint32_t)k_utf_sur_lo_first) {
    return k_ra8_err_invalid_arg; /* a low surrogate with no high one before it */
  }
  if ((i + 1U) >= units) {
    return k_ra8_err_invalid_arg; /* a high surrogate at the end of the name */
  }
  const uint32_t lo = (uint32_t)in[i + 1U];
  if ((lo < (uint32_t)k_utf_sur_lo_first) || (lo > (uint32_t)k_utf_sur_last)) {
    return k_ra8_err_invalid_arg; /* a high surrogate followed by something else */
  }
  *out_cp = (uint32_t)k_utf_min_4byte +
            (((hi - (uint32_t)k_utf_sur_hi_first) << (uint32_t)k_utf_sur_shift) |
             (lo - (uint32_t)k_utf_sur_lo_first));
  *io_i   = i + 2U;
  return k_ra8_ok;
}

RA8_INTERNAL
static uint32_t internal_utf8_len_of(uint32_t cp)
{
  if (cp < (uint32_t)k_utf_min_2byte) {
    return (uint32_t)k_utf_len_1;
  }
  if (cp < (uint32_t)k_utf_min_3byte) {
    return (uint32_t)k_utf_len_2;
  }
  if (cp < (uint32_t)k_utf_min_4byte) {
    return (uint32_t)k_utf_len_3;
  }
  return (uint32_t)k_utf_len_4;
}

RA8_INTERNAL
static void internal_utf8_put_tail(char* out, uint32_t from, uint32_t len, uint32_t cp)
{
  uint32_t rest = cp;
  for (uint32_t k = len - 1U; k >= 1U; k--) {
    const uint32_t b = (uint32_t)k_utf_cont_tag | (rest & (uint32_t)k_utf_cont_payload);
    out[from + k]    = (char)(unsigned char)b;
    rest >>= (uint32_t)k_utf_cont_shift;
  }
}

RA8_INTERNAL
static ra8_err_t internal_utf8_put(uint32_t cp, char* out, uint32_t cap, uint32_t* io_n)
{
  const uint32_t n   = *io_n;
  const uint32_t len = internal_utf8_len_of(cp);
  if ((n + len + 1U) > cap) {
    return k_ra8_err_no_mem;
  }
  if (len == (uint32_t)k_utf_len_1) {
    out[n] = (char)(unsigned char)cp;
    *io_n  = n + len;
    return k_ra8_ok;
  }
  uint32_t lead_tag = (uint32_t)k_utf_lead4_tag;
  if (len == (uint32_t)k_utf_len_2) {
    lead_tag = (uint32_t)k_utf_lead2_tag;
  } else if (len == (uint32_t)k_utf_len_3) {
    lead_tag = (uint32_t)k_utf_lead3_tag;
  } else {
    /* four-byte lead: the initialiser above */
  }
  const uint32_t lead_bits = cp >> ((len - 1U) * (uint32_t)k_utf_cont_shift);
  out[n]                   = (char)(unsigned char)(lead_tag | lead_bits);
  internal_utf8_put_tail(out, n, len, cp);
  *io_n = n + len;
  return k_ra8_ok;
}
 
/* `priv_utf16_to_utf8()`: see header for the documented contract. */
ra8_err_t priv_utf16_to_utf8(const uint16_t* in, uint32_t units, char* out, uint32_t cap)
{
  if ((in == nullptr) || (out == nullptr) || (cap == 0U)) {
    return k_ra8_err_null_ptr;
  }
  out[0]     = '\0';
  uint32_t i = 0U;
  uint32_t n = 0U;
  while (i < units) {
    uint32_t  cp  = 0U;
    ra8_err_t err = internal_utf16_take(in, units, &i, &cp);
    if (err != k_ra8_ok) {
      return err;
    }
    err = internal_utf8_put(cp, out, cap, &n);
    if (err != k_ra8_ok) {
      out[0] = '\0';
      return err;
    }
  }
  out[n] = '\0';
  return k_ra8_ok;
}
 
/* =============================================================================
 * Folding and inspection
 * =============================================================================
 */
 
/* `priv_utf16_ieq()`: see header for the documented contract. */
uint8_t priv_utf16_ieq(const uint16_t* a, uint32_t an, const uint16_t* b, uint32_t bn)
{
  if (an != bn) {
    return 0U;
  }
  for (uint32_t i = 0U; i < an; i++) {
    if (priv_exfat_upcase_unit(a[i]) != priv_exfat_upcase_unit(b[i])) {
      return 0U;
    }
  }
  return 1U;
}
 
/* `priv_utf16_all_ascii()`: see header for the documented contract. */
uint8_t priv_utf16_all_ascii(const uint16_t* in, uint32_t units)
{
  for (uint32_t i = 0U; i < units; i++) {
    if ((uint32_t)in[i] > (uint32_t)k_utf_ascii_max) {
      return 0U;
    }
  }
  return 1U;
}