/*-------------------------------------------------------------------------

 *

 *    Utility functions for conversion procs.

 *

 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group

 * Portions Copyright (c) 1994, Regents of the University of California

 *

 * IDENTIFICATION

 *    src/backend/utils/mb/conv.c

 *

 *-------------------------------------------------------------------------

 */

#include "postgres.h"

#include "mb/pg_wchar.h"

/*

 * local2local: a generic single byte charset encoding

 * conversion between two ASCII-superset encodings.

 *

 * l points to the source string of length len

 * p is the output area (must be large enough!)

 * src_encoding is the PG identifier for the source encoding

 * dest_encoding is the PG identifier for the target encoding

 * tab holds conversion entries for the source charset

 * starting from 128 (0x80). each entry in the table holds the corresponding

 * code point for the target charset, or 0 if there is no equivalent code.

 *

 * Returns the number of input bytes consumed.  If noError is true, this can

 * be less than 'len'.

 */

int

local2local(const unsigned char *l,

      unsigned char *p,

      int len,

      int src_encoding,

      int dest_encoding,

      const unsigned char *tab,

      bool noError)

{

  const unsigned char *start = l;

  unsigned char c1,

        c2;

  while (len > 0)

  {

    c1 = *l;

    if (c1 == 0)

    {

      if (noError)

        break;

      report_invalid_encoding(src_encoding, (const char *) l, len);

    }

    if (!IS_HIGHBIT_SET(c1))

      *p++ = c1;

    else

    {

      c2 = tab[c1 - HIGHBIT];

      if (c2)

        *p++ = c2;

      else

      {

        if (noError)

          break;

        report_untranslatable_char(src_encoding, dest_encoding,

                       (const char *) l, len);

      }

    }

    l++;

    len--;

  }

  *p = '\0';

  return l - start;

}

/*

 * LATINn ---> MIC when the charset's local codes map directly to MIC

 *

 * l points to the source string of length len

 * p is the output area (must be large enough!)

 * lc is the mule character set id for the local encoding

 * encoding is the PG identifier for the local encoding

 *

 * Returns the number of input bytes consumed.  If noError is true, this can

 * be less than 'len'.

 */

int

latin2mic(const unsigned char *l, unsigned char *p, int len,

      int lc, int encoding, bool noError)

{

  const unsigned char *start = l;

  int     c1;

  while (len > 0)

  {

    c1 = *l;

    if (c1 == 0)

    {

      if (noError)

        break;

      report_invalid_encoding(encoding, (const char *) l, len);

    }

    if (IS_HIGHBIT_SET(c1))

      *p++ = lc;

    *p++ = c1;

    l++;

    len--;

  }

  *p = '\0';

  return l - start;

}

/*

 * MIC ---> LATINn when the charset's local codes map directly to MIC

 *

 * mic points to the source string of length len

 * p is the output area (must be large enough!)

 * lc is the mule character set id for the local encoding

 * encoding is the PG identifier for the local encoding

 *

 * Returns the number of input bytes consumed.  If noError is true, this can

 * be less than 'len'.

 */

int

mic2latin(const unsigned char *mic, unsigned char *p, int len,

      int lc, int encoding, bool noError)

{

  const unsigned char *start = mic;

  int     c1;

  while (len > 0)

  {

    c1 = *mic;

    if (c1 == 0)

    {

      if (noError)

        break;

      report_invalid_encoding(PG_MULE_INTERNAL, (const char *) mic, len);

    }

    if (!IS_HIGHBIT_SET(c1))

    {

      /* easy for ASCII */

      *p++ = c1;

      mic++;

      len--;

    }

    else

    {

      int     l = pg_mule_mblen(mic);

      if (len < l)

      {

        if (noError)

          break;

        report_invalid_encoding(PG_MULE_INTERNAL, (const char *) mic,

                    len);

      }

      if (l != 2 || c1 != lc || !IS_HIGHBIT_SET(mic[1]))

      {

        if (noError)

          break;

        report_untranslatable_char(PG_MULE_INTERNAL, encoding,

                       (const char *) mic, len);

      }

      *p++ = mic[1];

      mic += 2;

      len -= 2;

    }

  }

  *p = '\0';

  return mic - start;

}

/*

 * latin2mic_with_table: a generic single byte charset encoding

 * conversion from a local charset to the mule internal code.

 *

 * l points to the source string of length len

 * p is the output area (must be large enough!)

 * lc is the mule character set id for the local encoding

 * encoding is the PG identifier for the local encoding

 * tab holds conversion entries for the local charset

 * starting from 128 (0x80). each entry in the table holds the corresponding

 * code point for the mule encoding, or 0 if there is no equivalent code.

 *

 * Returns the number of input bytes consumed.  If noError is true, this can

 * be less than 'len'.

 */

int

latin2mic_with_table(const unsigned char *l,

           unsigned char *p,

           int len,

           int lc,

           int encoding,

           const unsigned char *tab,

           bool noError)

{

  const unsigned char *start = l;

  unsigned char c1,

        c2;

  while (len > 0)

  {

    c1 = *l;

    if (c1 == 0)

    {

      if (noError)

        break;

      report_invalid_encoding(encoding, (const char *) l, len);

    }

    if (!IS_HIGHBIT_SET(c1))

      *p++ = c1;

    else

    {

      c2 = tab[c1 - HIGHBIT];

      if (c2)

      {

        *p++ = lc;

        *p++ = c2;

      }

      else

      {

        if (noError)

          break;

        report_untranslatable_char(encoding, PG_MULE_INTERNAL,

                       (const char *) l, len);

      }

    }

    l++;

    len--;

  }

  *p = '\0';

  return l - start;

}

/*

 * mic2latin_with_table: a generic single byte charset encoding

 * conversion from the mule internal code to a local charset.

 *

 * mic points to the source string of length len

 * p is the output area (must be large enough!)

 * lc is the mule character set id for the local encoding

 * encoding is the PG identifier for the local encoding

 * tab holds conversion entries for the mule internal code's second byte,

 * starting from 128 (0x80). each entry in the table holds the corresponding

 * code point for the local charset, or 0 if there is no equivalent code.

 *

 * Returns the number of input bytes consumed.  If noError is true, this can

 * be less than 'len'.

 */

int

mic2latin_with_table(const unsigned char *mic,

           unsigned char *p,

           int len,

           int lc,

           int encoding,

           const unsigned char *tab,

           bool noError)

{

  const unsigned char *start = mic;

  unsigned char c1,

        c2;

  while (len > 0)

  {

    c1 = *mic;

    if (c1 == 0)

    {

      if (noError)

        break;

      report_invalid_encoding(PG_MULE_INTERNAL, (const char *) mic, len);

    }

    if (!IS_HIGHBIT_SET(c1))

    {

      /* easy for ASCII */

      *p++ = c1;

      mic++;

      len--;

    }

    else

    {

      int     l = pg_mule_mblen(mic);

      if (len < l)

      {

        if (noError)

          break;

        report_invalid_encoding(PG_MULE_INTERNAL, (const char *) mic,

                    len);

      }

      if (l != 2 || c1 != lc || !IS_HIGHBIT_SET(mic[1]) ||

        (c2 = tab[mic[1] - HIGHBIT]) == 0)

      {

        if (noError)

          break;

        report_untranslatable_char(PG_MULE_INTERNAL, encoding,

                       (const char *) mic, len);

        break;     /* keep compiler quiet */

      }

      *p++ = c2;

      mic += 2;

      len -= 2;

    }

  }

  *p = '\0';

  return mic - start;

}

/*

 * comparison routine for bsearch()

 * this routine is intended for combined UTF8 -> local code

 */

static int

compare3(const void *p1, const void *p2)

{

  uint32    s1,

        s2,

        d1,

        d2;

  s1 = *(const uint32 *) p1;

  s2 = *((const uint32 *) p1 + 1);

  d1 = ((const pg_utf_to_local_combined *) p2)->utf1;

  d2 = ((const pg_utf_to_local_combined *) p2)->utf2;

  return (s1 > d1 || (s1 == d1 && s2 > d2)) ? 1 : ((s1 == d1 && s2 == d2) ? 0 : -1);

}

/*

 * comparison routine for bsearch()

 * this routine is intended for local code -> combined UTF8

 */

static int

compare4(const void *p1, const void *p2)

{

  uint32    v1,

        v2;

  v1 = *(const uint32 *) p1;

  v2 = ((const pg_local_to_utf_combined *) p2)->code;

  return (v1 > v2) ? 1 : ((v1 == v2) ? 0 : -1);

}

/*

 * store 32bit character representation into multibyte stream

 */

static inline unsigned char *

store_coded_char(unsigned char *dest, uint32 code)

{

  if (code & 0xff000000)

    *dest++ = code >> 24;

  if (code & 0x00ff0000)

    *dest++ = code >> 16;

  if (code & 0x0000ff00)

    *dest++ = code >> 8;

  if (code & 0x000000ff)

    *dest++ = code;

  return dest;

}

/*

 * Convert a character using a conversion radix tree.

 *

 * 'l' is the length of the input character in bytes, and b1-b4 are

 * the input character's bytes.

 */

static inline uint32

pg_mb_radix_conv(const pg_mb_radix_tree *rt,

         int l,

         unsigned char b1,

         unsigned char b2,

         unsigned char b3,

         unsigned char b4)

{

  if (l == 4)

  {

    /* 4-byte code */

    /* check code validity */

    if (b1 < rt->b4_1_lower || b1 > rt->b4_1_upper ||

      b2 < rt->b4_2_lower || b2 > rt->b4_2_upper ||

      b3 < rt->b4_3_lower || b3 > rt->b4_3_upper ||

      b4 < rt->b4_4_lower || b4 > rt->b4_4_upper)

      return 0;

    /* perform lookup */

    if (rt->chars32)

    {

      uint32    idx = rt->b4root;

      idx = rt->chars32[b1 + idx - rt->b4_1_lower];

      idx = rt->chars32[b2 + idx - rt->b4_2_lower];

      idx = rt->chars32[b3 + idx - rt->b4_3_lower];

      return rt->chars32[b4 + idx - rt->b4_4_lower];

    }

    else

    {

      uint16    idx = rt->b4root;

      idx = rt->chars16[b1 + idx - rt->b4_1_lower];

      idx = rt->chars16[b2 + idx - rt->b4_2_lower];

      idx = rt->chars16[b3 + idx - rt->b4_3_lower];

      return rt->chars16[b4 + idx - rt->b4_4_lower];

    }

  }

  else if (l == 3)

  {

    /* 3-byte code */

    /* check code validity */

    if (b2 < rt->b3_1_lower || b2 > rt->b3_1_upper ||

      b3 < rt->b3_2_lower || b3 > rt->b3_2_upper ||

      b4 < rt->b3_3_lower || b4 > rt->b3_3_upper)

      return 0;

    /* perform lookup */

    if (rt->chars32)

    {

      uint32    idx = rt->b3root;

      idx = rt->chars32[b2 + idx - rt->b3_1_lower];

      idx = rt->chars32[b3 + idx - rt->b3_2_lower];

      return rt->chars32[b4 + idx - rt->b3_3_lower];

    }

    else

    {

      uint16    idx = rt->b3root;

      idx = rt->chars16[b2 + idx - rt->b3_1_lower];

      idx = rt->chars16[b3 + idx - rt->b3_2_lower];

      return rt->chars16[b4 + idx - rt->b3_3_lower];

    }

  }

  else if (l == 2)

  {

    /* 2-byte code */

    /* check code validity - first byte */

    if (b3 < rt->b2_1_lower || b3 > rt->b2_1_upper ||

      b4 < rt->b2_2_lower || b4 > rt->b2_2_upper)

      return 0;

    /* perform lookup */

    if (rt->chars32)

    {

      uint32    idx = rt->b2root;

      idx = rt->chars32[b3 + idx - rt->b2_1_lower];

      return rt->chars32[b4 + idx - rt->b2_2_lower];

    }

    else

    {

      uint16    idx = rt->b2root;

      idx = rt->chars16[b3 + idx - rt->b2_1_lower];

      return rt->chars16[b4 + idx - rt->b2_2_lower];

    }

  }

  else if (l == 1)

  {

    /* 1-byte code */

    /* check code validity - first byte */

    if (b4 < rt->b1_lower || b4 > rt->b1_upper)

      return 0;

    /* perform lookup */

    if (rt->chars32)

      return rt->chars32[b4 + rt->b1root - rt->b1_lower];

    else

      return rt->chars16[b4 + rt->b1root - rt->b1_lower];

  }

  return 0;         /* shouldn't happen */

}

/*

 * UTF8 ---> local code

 *

 * utf: input string in UTF8 encoding (need not be null-terminated)

 * len: length of input string (in bytes)

 * iso: pointer to the output area (must be large enough!)

      (output string will be null-terminated)

 * map: conversion map for single characters

 * cmap: conversion map for combined characters

 *      (optional, pass NULL if none)

 * cmapsize: number of entries in the conversion map for combined characters

 *      (optional, pass 0 if none)

 * conv_func: algorithmic encoding conversion function

 *      (optional, pass NULL if none)

 * encoding: PG identifier for the local encoding

 *

 * For each character, the cmap (if provided) is consulted first; if no match,

 * the map is consulted next; if still no match, the conv_func (if provided)

 * is applied.  An error is raised if no match is found.

 *

 * See pg_wchar.h for more details about the data structures used here.

 *

 * Returns the number of input bytes consumed.  If noError is true, this can

 * be less than 'len'.

 */

int

UtfToLocal(const unsigned char *utf, int len,

       unsigned char *iso,

       const pg_mb_radix_tree *map,

       const pg_utf_to_local_combined *cmap, int cmapsize,

       utf_local_conversion_func conv_func,

       int encoding, bool noError)

{

  uint32    iutf;

  int     l;

  const pg_utf_to_local_combined *cp;

  const unsigned char *start = utf;

  if (!PG_VALID_ENCODING(encoding))

    ereport(ERROR,

        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),

         errmsg("invalid encoding number: %d", encoding)));

  for (; len > 0; len -= l)

  {

    unsigned char b1 = 0;

    unsigned char b2 = 0;

    unsigned char b3 = 0;

    unsigned char b4 = 0;

    /* "break" cases all represent errors */

    if (*utf == '\0')

      break;

    l = pg_utf_mblen(utf);

    if (len < l)

      break;

    if (!pg_utf8_islegal(utf, l))

      break;

    if (l == 1)

    {

      /* ASCII case is easy, assume it's one-to-one conversion */

      *iso++ = *utf++;

      continue;

    }

    /* collect coded char of length l */

    if (l == 2)

    {

      b3 = *utf++;

      b4 = *utf++;

    }

    else if (l == 3)

    {

      b2 = *utf++;

      b3 = *utf++;

      b4 = *utf++;

    }

    else if (l == 4)

    {

      b1 = *utf++;

      b2 = *utf++;

      b3 = *utf++;

      b4 = *utf++;

    }

    else

    {

      elog(ERROR, "unsupported character length %d", l);

      iutf = 0;     /* keep compiler quiet */

    }

    iutf = (b1 << 24 | b2 << 16 | b3 << 8 | b4);

    /* First, try with combined map if possible */

    if (cmap && len > l)

    {

      const unsigned char *utf_save = utf;

      int     len_save = len;

      int     l_save = l;

      /* collect next character, same as above */

      len -= l;

      l = pg_utf_mblen(utf);

      if (len < l)

      {

        /* need more data to decide if this is a combined char */

        utf -= l_save;

        break;

      }

      if (!pg_utf8_islegal(utf, l))

      {

        if (!noError)

          report_invalid_encoding(PG_UTF8, (const char *) utf, len);

        utf -= l_save;

        break;

      }

      /* We assume ASCII character cannot be in combined map */

      if (l > 1)

      {

        uint32    iutf2;

        uint32    cutf[2];

        if (l == 2)

        {

          iutf2 = *utf++ << 8;

          iutf2 |= *utf++;

        }

        else if (l == 3)

        {

          iutf2 = *utf++ << 16;

          iutf2 |= *utf++ << 8;

          iutf2 |= *utf++;

        }

        else if (l == 4)

        {

          iutf2 = *utf++ << 24;

          iutf2 |= *utf++ << 16;

          iutf2 |= *utf++ << 8;

          iutf2 |= *utf++;

        }

        else

        {

          elog(ERROR, "unsupported character length %d", l);

          iutf2 = 0;  /* keep compiler quiet */

        }

        cutf[0] = iutf;

        cutf[1] = iutf2;

        cp = bsearch(cutf, cmap, cmapsize,

               sizeof(pg_utf_to_local_combined), compare3);

        if (cp)

        {

          iso = store_coded_char(iso, cp->code);

          continue;

        }

      }

      /* fail, so back up to reprocess second character next time */

      utf = utf_save;

      len = len_save;

      l = l_save;

    }

    /* Now check ordinary map */

    if (map)

    {

      uint32    converted = pg_mb_radix_conv(map, l, b1, b2, b3, b4);

      if (converted)

      {

        iso = store_coded_char(iso, converted);

        continue;

      }

    }

    /* if there's a conversion function, try that */

    if (conv_func)

    {

      uint32    converted = (*conv_func) (iutf);

      if (converted)

      {

        iso = store_coded_char(iso, converted);

        continue;

      }

    }

    /* failed to translate this character */

    utf -= l;

    if (noError)

      break;

    report_untranslatable_char(PG_UTF8, encoding,

                   (const char *) utf, len);

  }

  /* if we broke out of loop early, must be invalid input */

  if (len > 0 && !noError)

    report_invalid_encoding(PG_UTF8, (const char *) utf, len);

  *iso = '\0';

  return utf - start;

}

/*

 * local code ---> UTF8

 *

 * iso: input string in local encoding (need not be null-terminated)

 * len: length of input string (in bytes)

 * utf: pointer to the output area (must be large enough!)

      (output string will be null-terminated)

 * map: conversion map for single characters

 * cmap: conversion map for combined characters

 *      (optional, pass NULL if none)

 * cmapsize: number of entries in the conversion map for combined characters

 *      (optional, pass 0 if none)

 * conv_func: algorithmic encoding conversion function

 *      (optional, pass NULL if none)

 * encoding: PG identifier for the local encoding

 *

 * For each character, the map is consulted first; if no match, the cmap

 * (if provided) is consulted next; if still no match, the conv_func

 * (if provided) is applied.  An error is raised if no match is found.

 *

 * See pg_wchar.h for more details about the data structures used here.

 *

 * Returns the number of input bytes consumed.  If noError is true, this can

 * be less than 'len'.

 */

int

LocalToUtf(const unsigned char *iso, int len,

       unsigned char *utf,

       const pg_mb_radix_tree *map,

       const pg_local_to_utf_combined *cmap, int cmapsize,

       utf_local_conversion_func conv_func,

       int encoding,

       bool noError)

{

  uint32    iiso;

  int     l;

  const pg_local_to_utf_combined *cp;

  const unsigned char *start = iso;

  if (!PG_VALID_ENCODING(encoding))

    ereport(ERROR,

        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),

         errmsg("invalid encoding number: %d", encoding)));

  for (; len > 0; len -= l)

  {

    unsigned char b1 = 0;

    unsigned char b2 = 0;

    unsigned char b3 = 0;

    unsigned char b4 = 0;

    /* "break" cases all represent errors */

    if (*iso == '\0')

      break;

    if (!IS_HIGHBIT_SET(*iso))

    {

      /* ASCII case is easy, assume it's one-to-one conversion */

      *utf++ = *iso++;

      l = 1;

      continue;

    }

    l = pg_encoding_verifymbchar(encoding, (const char *) iso, len);

    if (l < 0)

      break;

    /* collect coded char of length l */

    if (l == 1)

      b4 = *iso++;

    else if (l == 2)

    {

      b3 = *iso++;

      b4 = *iso++;

    }

    else if (l == 3)

    {

      b2 = *iso++;

      b3 = *iso++;

      b4 = *iso++;

    }

    else if (l == 4)

    {

      b1 = *iso++;

      b2 = *iso++;

      b3 = *iso++;

      b4 = *iso++;

    }

    else

    {

      elog(ERROR, "unsupported character length %d", l);

      iiso = 0;     /* keep compiler quiet */

    }

    iiso = (b1 << 24 | b2 << 16 | b3 << 8 | b4);

    if (map)

    {

      uint32    converted = pg_mb_radix_conv(map, l, b1, b2, b3, b4);

      if (converted)

      {

        utf = store_coded_char(utf, converted);

        continue;

      }

      /* If there's a combined character map, try that */

      if (cmap)

      {

        cp = bsearch(&iiso, cmap, cmapsize,

               sizeof(pg_local_to_utf_combined), compare4);

        if (cp)

        {

          utf = store_coded_char(utf, cp->utf1);

          utf = store_coded_char(utf, cp->utf2);

          continue;

        }

      }

    }

    /* if there's a conversion function, try that */

    if (conv_func)

    {

      uint32    converted = (*conv_func) (iiso);

      if (converted)

      {

        utf = store_coded_char(utf, converted);

        continue;

      }

    }

    /* failed to translate this character */

    iso -= l;

    if (noError)

      break;

    report_untranslatable_char(encoding, PG_UTF8,

                   (const char *) iso, len);

  }

  /* if we broke out of loop early, must be invalid input */

  if (len > 0 && !noError)

    report_invalid_encoding(encoding, (const char *) iso, len);

  *utf = '\0';

  return iso - start;

}