text: /*
   * conversion functions between pg_wchar and multibyte streams.
   * Tatsuo Ishii
   * src/backend/utils/mb/wchar.c
   *
   */
  /* can be used in either frontend or backend */
  #ifdef FRONTEND
  #include "postgres_fe.h"
  #ifndef Assert
  #define Assert(condition)
  #endif
  #else
  #include "postgres.h"
  #include "knl/knl_variable.h"
  #include "commands/copy.h"
  
  #endif
  
  #include "mb/pg_wchar.h"
  
  /*
   * conversion to pg_wchar is done by "table driven."
   * to add an encoding support, define mb2wchar_with_len(), mblen(), dsplen()
   * for the particular encoding. Note that if the encoding is only
   * supported in the client, you don't need to define
   * mb2wchar_with_len() function (SJIS is the case).
   *
   * These functions generally assume that their input is validly formed.
   * The "verifier" functions, further down in the file, have to be more
   * paranoid.  We expect that mblen() does not need to examine more than
   * the first byte of the character to discover the correct length.
   *
   * Note: for the display output of psql to work properly, the return values
   * of the dsplen functions must conform to the Unicode standard. In particular
   * the NUL character is zero width and control characters are generally
   * width -1. It is recommended that non-ASCII encodings refer their ASCII
   * subset to the ASCII routines to ensure consistency.
   */
  
  /*
   * SQL/ASCII
   */
  static int pg_ascii2wchar_with_len(const unsigned char* from, pg_wchar* to, int len)
  {
      int cnt = 0;
  
      while (len > 0 && *from) {
          *to++ = *from++;
          len--;
          cnt++;
      }
      *to = 0;
      return cnt;
  }
  
  static int pg_ascii_mblen(const unsigned char* s)
  {
      return 1;
  }
  
  static int pg_ascii_dsplen(const unsigned char* s)
  {
      if (*s == '\0') {
          return 0;
      }
      if (*s < 0x20 || *s == 0x7f) {
          return -1;
      }
  
      return 1;
  }
  
  /*
   * EUC
   */
  static int pg_euc2wchar_with_len(const unsigned char* from, pg_wchar* to, int len)
  {
      int cnt = 0;
  
      while (len > 0 && *from) {
          if (*from == SS2 && len >= 2) { // JIS X 0201 (so called "1 byte KANA")
              from++;
              *to = (SS2 << 8) | *from++;
              len -= 2;
          } else if (*from == SS3 && len >= 3) { // JIS X 0212 KANJI
              from++;
              *to = (SS3 << 16) | (*from++ << 8);
              *to |= *from++;
              len -= 3;
          } else if (IS_HIGHBIT_SET(*from) && len >= 2) { // JIS X 0208 KANJI
              *to = *from++ << 8;
              *to |= *from++;
              len -= 2;
          } else { // must be ASCII
              *to = *from++;
              len--;
          }
          to++;
          cnt++;
      }
      *to = 0;
      return cnt;
  }
  
  static inline int pg_euc_mblen(const unsigned char* s)
  {
      int len;
  
      if (*s == SS2) {
          len = 2;
      } else if (*s == SS3) {
          len = 3;
      } else if (IS_HIGHBIT_SET(*s)) {
          len = 2;
      } else {
          len = 1;
      }
  
      return len;
  }
  
  static inline int pg_euc_dsplen(const unsigned char* s)
  {
      int len;
  
      if (*s == SS2) {
          len = 2;
      } else if (*s == SS3) {
          len = 2;
      } else if (IS_HIGHBIT_SET(*s)) {
          len = 2;
      } else {
          len = pg_ascii_dsplen(s);
      }
  
      return len;
  }
  
  /*
   * EUC_JP
   */
  static int pg_eucjp2wchar_with_len(const unsigned char* from, pg_wchar* to, int len)
  {
      return pg_euc2wchar_with_len(from, to, len);
  }
  
  static int pg_eucjp_mblen(const unsigned char* s)
  {
      return pg_euc_mblen(s);
  }
  
  static int pg_eucjp_dsplen(const unsigned char* s)
  {
      int len;
  
      if (*s == SS2) {
          len = 1;
      } else if (*s == SS3) {
          len = 2;
      } else if (IS_HIGHBIT_SET(*s)) {
          len = 2;
      } else {
          len = pg_ascii_dsplen(s);
      }
  
      return len;
  }
  
  /*
   * EUC_KR
   */
  static int pg_euckr2wchar_with_len(const unsigned char* from, pg_wchar* to, int len)
  {
      return pg_euc2wchar_with_len(from, to, len);
  }
  
  static int pg_euckr_mblen(const unsigned char* s)
  {
      return pg_euc_mblen(s);
  }
  
  static int pg_euckr_dsplen(const unsigned char* s)
  {
      return pg_euc_dsplen(s);
  }
  
  /*
   * EUC_CN
   *
   */
  static int pg_euccn2wchar_with_len(const unsigned char* from, pg_wchar* to, int len)
  {
      int cnt = 0;
  
      while (len > 0 && *from) {
          if (*from == SS2 && len >= 3) { // code set 2 (unused?)
              from++;
              *to = (SS2 << 16) | (*from++ << 8);
              *to |= *from++;
              len -= 3;
          } else if (*from == SS3 && len >= 3) { // code set 3 (unused ?)
              from++;
              *to = (SS3 << 16) | (*from++ << 8);
              *to |= *from++;
              len -= 3;
          } else if (IS_HIGHBIT_SET(*from) && len >= 2) { // code set 1
              *to = *from++ << 8;
              *to |= *from++;
              len -= 2;
          } else {
              *to = *from++;
              len--;
          }
          to++;
          cnt++;
      }
      *to = 0;
      return cnt;
  }
  
  static int pg_euccn_mblen(const unsigned char* s)
  {
      int len;
  
      if (IS_HIGHBIT_SET(*s)) {
          len = 2;
      } else {
          len = 1;
      }
  
      return len;
  }
  
  static int pg_euccn_dsplen(const unsigned char* s)
  {
      int len;
  
      if (IS_HIGHBIT_SET(*s)) {
          len = 2;
      } else {
          len = pg_ascii_dsplen(s);
      }
  
      return len;
  }
  
  /*
   * EUC_TW
   *
   */
  static int pg_euctw2wchar_with_len(const unsigned char* from, pg_wchar* to, int len)
  {
      int cnt = 0;
  
      while (len > 0 && *from) {
          if (*from == SS2 && len >= 4) { // code set 2
              from++;
              *to = (((uint32)SS2) << 24) | (*from++ << 16);
              *to |= *from++ << 8;
              *to |= *from++;
              len -= 4;
          } else if (*from == SS3 && len >= 3) { // code set 3 (unused?)
              from++;
              *to = (SS3 << 16) | (*from++ << 8);
              *to |= *from++;
              len -= 3;
          } else if (IS_HIGHBIT_SET(*from) && len >= 2) { // code set 2
              *to = *from++ << 8;
              *to |= *from++;
              len -= 2;
          } else {
              *to = *from++;
              len--;
          }
          to++;
          cnt++;
      }
      *to = 0;
      return cnt;
  }
  
  static int pg_euctw_mblen(const unsigned char* s)
  {
      int len;
  
      if (*s == SS2) {
          len = 4;
      } else if (*s == SS3) {
          len = 3;
      } else if (IS_HIGHBIT_SET(*s)) {
          len = 2;
      } else {
          len = 1;
      }
  
      return len;
  }
  
  static int pg_euctw_dsplen(const unsigned char* s)
  {
      int len;
  
      if (*s == SS2) {
          len = 2;
      } else if (*s == SS3) {
          len = 2;
      } else if (IS_HIGHBIT_SET(*s)) {
          len = 2;
      } else {
          len = pg_ascii_dsplen(s);
      }
  
      return len;
  }
  
  /*
   * Convert pg_wchar to EUC_* encoding.
   * caller must allocate enough space for "to", including a trailing zero!
   * len: length of from.
   * "from" not necessarily null terminated.
   */
  static int pg_wchar2euc_with_len(const pg_wchar* from, unsigned char* to, int len)
  {
      int cnt = 0;
  
      while (len > 0 && *from) {
          unsigned char c;
  
          if ((c = (*from >> 24))) {
              *to++ = c;
              *to++ = (*from >> 16) & 0xff;
              *to++ = (*from >> 8) & 0xff;
              *to++ = *from & 0xff;
              cnt += 4;
          } else if ((c = (*from >> 16))) {
              *to++ = c;
              *to++ = (*from >> 8) & 0xff;
              *to++ = *from & 0xff;
              cnt += 3;
          } else if ((c = (*from >> 8))) {
              *to++ = c;
              *to++ = *from & 0xff;
              cnt += 2;
          } else {
              *to++ = *from;
              cnt++;
          }
          from++;
          len--;
      }
      *to = 0;
      return cnt;
  }
  
  /*
   * JOHAB
   */
  static int pg_johab_mblen(const unsigned char* s)
  {
      return pg_euc_mblen(s);
  }
  
  static int pg_johab_dsplen(const unsigned char* s)
  {
      return pg_euc_dsplen(s);
  }
  
  /*
   * convert UTF8 string to pg_wchar (UCS-4)
   * caller must allocate enough space for "to", including a trailing zero!
   * len: length of from.
   * "from" not necessarily null terminated.
   */
  static int pg_utf2wchar_with_len(const unsigned char* from, pg_wchar* to, int len)
  {
      int cnt = 0;
      uint32 c1, c2, c3, c4;
  
      while (len > 0 && *from) {
          if ((*from & 0x80) == 0) {
              *to = *from++;
              len--;
          } else if ((*from & 0xe0) == 0xc0) {
              if (len < 2) {
                  break; // drop trailing incomplete char
              }
              c1 = *from++ & 0x1f;
              c2 = *from++ & 0x3f;
              *to = (c1 << 6) | c2;
              len -= 2;
          } else if ((*from & 0xf0) == 0xe0) {
              if (len < 3) {
                  break; // drop trailing incomplete char
              }
              c1 = *from++ & 0x0f;
              c2 = *from++ & 0x3f;
              c3 = *from++ & 0x3f;
              *to = (c1 << 12) | (c2 << 6) | c3;
              len -= 3;
          } else if ((*from & 0xf8) == 0xf0) {
              if (len < 4) {
                  break; // drop trailing incomplete char
              }
              c1 = *from++ & 0x07;
              c2 = *from++ & 0x3f;
              c3 = *from++ & 0x3f;
              c4 = *from++ & 0x3f;
              *to = (c1 << 18) | (c2 << 12) | (c3 << 6) | c4;
              len -= 4;
          } else {
              // treat a bogus char as length 1; not ours to raise error
              *to = *from++;
              len--;
          }
          to++;
          cnt++;
      }
      *to = 0;
      return cnt;
  }
  
  /*
   * Map a Unicode code point to UTF-8.  utf8string must have 4 bytes of
   * space allocated.
   */
  unsigned char* unicode_to_utf8(pg_wchar c, unsigned char* utf8string)
  {
      if (c <= 0x7F) {
          utf8string[0] = c;
      } else if (c <= 0x7FF) {
          utf8string[0] = 0xC0 | ((c >> 6) & 0x1F);
          utf8string[1] = 0x80 | (c & 0x3F);
      } else if (c <= 0xFFFF) {
          utf8string[0] = 0xE0 | ((c >> 12) & 0x0F);
          utf8string[1] = 0x80 | ((c >> 6) & 0x3F);
          utf8string[2] = 0x80 | (c & 0x3F);
      } else {
          utf8string[0] = 0xF0 | ((c >> 18) & 0x07);
          utf8string[1] = 0x80 | ((c >> 12) & 0x3F);
          utf8string[2] = 0x80 | ((c >> 6) & 0x3F);
          utf8string[3] = 0x80 | (c & 0x3F);
      }
  
      return utf8string;
  }
  
  /*
   * Trivial conversion from pg_wchar to UTF-8.
   * caller should allocate enough space for "to"
   * len: length of from.
   * "from" not necessarily null terminated.
   */
  static int pg_wchar2utf_with_len(const pg_wchar* from, unsigned char* to, int len)
  {
      int cnt = 0;
  
      while (len > 0 && *from) {
          int char_len;
  
          unicode_to_utf8(*from, to);
          char_len = pg_utf_mblen(to);
          cnt += char_len;
          to += char_len;
          from++;
          len--;
      }
      *to = 0;
      return cnt;
  }
  
  /*
   * Return the byte length of a UTF8 character pointed to by s
   *
   * Note: in the current implementation we do not support UTF8 sequences
   * of more than 4 bytes; hence do NOT return a value larger than 4.
   * We return "1" for any leading byte that is either flat-out illegal or
   * indicates a length larger than we support.
   *
   * pg_utf2wchar_with_len(), utf8_to_unicode(), pg_utf8_islegal(), and perhaps
   * other places would need to be fixed to change this.
   */
  int pg_utf_mblen(const unsigned char* s)
  {
      int len;
  
      if ((*s & 0x80) == 0) {
          len = 1;
      } else if ((*s & 0xe0) == 0xc0) {
          len = 2;
      } else if ((*s & 0xf0) == 0xe0) {
          len = 3;
      } else if ((*s & 0xf8) == 0xf0) {
          len = 4;
      }
  #ifdef NOT_USED
      else if ((*s & 0xfc) == 0xf8) {
          len = 5;
      } else if ((*s & 0xfe) == 0xfc) {
          len = 6;
      }
  #endif
      else {
          len = 1;
      }
  
      return len;
  }
  
  /*
   * This is an implementation of wcwidth() and wcswidth() as defined in
   * "The Single UNIX Specification, Version 2, The Open Group, 1997"
   * <http://www.UNIX-systems.org/online.html>
   *
   * Markus Kuhn -- 2001-09-08 -- public domain
   *
   * customised for PostgreSQL
   *
   * original available at : http://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c
   */
  
  struct mbinterval {
      unsigned short first;
      unsigned short last;
  };
  
  /* auxiliary function for binary search in interval table */
  static int mbbisearch(pg_wchar ucs, const struct mbinterval* table, int max)
  {
      int min = 0;
      int mid;
  
      if (ucs < table[0].first || ucs > table[max].last) {
          return 0;
      }
  
      while (max >= min) {
          mid = (min + max) / 2;
          if (ucs > table[mid].last) {
              min = mid + 1;
          } else if (ucs < table[mid].first) {
              max = mid - 1;
          } else {
              return 1;
          }
      }
  
      return 0;
  }
  
  /* The following functions define the column width of an ISO 10646
   * character as follows:
   *
   *	  - The null character (U+0000) has a column width of 0.
   *
   *	  - Other C0/C1 control characters and DEL will lead to a return
   *		value of -1.
   *
   *	  - Non-spacing and enclosing combining characters (general
   *		category code Mn or Me in the Unicode database) have a
   *		column width of 0.
   *
   *	  - Other format characters (general category code Cf in the Unicode
   *		database) and ZERO WIDTH SPACE (U+200B) have a column width of 0.
   *
   *	  - Hangul Jamo medial vowels and final consonants (U+1160-U+11FF)
   *		have a column width of 0.
   *
   *	  - Spacing characters in the East Asian Wide (W) or East Asian
   *		FullWidth (F) category as defined in Unicode Technical
   *		Report #11 have a column width of 2.
   *
   *	  - All remaining characters (including all printable
   *		ISO 8859-1 and WGL4 characters, Unicode control characters,
   *		etc.) have a column width of 1.
   *
   * This implementation assumes that wchar_t characters are encoded
   * in ISO 10646.
   */
  
  static int ucs_wcwidth(pg_wchar ucs)
  {
      /* sorted list of non-overlapping intervals of non-spacing characters */
      static const struct mbinterval combining[] = {{0x0300, 0x034E},
          {0x0360, 0x0362},
          {0x0483, 0x0486},
          {0x0488, 0x0489},
          {0x0591, 0x05A1},
          {0x05A3, 0x05B9},
          {0x05BB, 0x05BD},
          {0x05BF, 0x05BF},
          {0x05C1, 0x05C2},
          {0x05C4, 0x05C4},
          {0x064B, 0x0655},
          {0x0670, 0x0670},
          {0x06D6, 0x06E4},
          {0x06E7, 0x06E8},
          {0x06EA, 0x06ED},
          {0x070F, 0x070F},
          {0x0711, 0x0711},
          {0x0730, 0x074A},
          {0x07A6, 0x07B0},
          {0x0901, 0x0902},
          {0x093C, 0x093C},
          {0x0941, 0x0948},
          {0x094D, 0x094D},
          {0x0951, 0x0954},
          {0x0962, 0x0963},
          {0x0981, 0x0981},
          {0x09BC, 0x09BC},
          {0x09C1, 0x09C4},
          {0x09CD, 0x09CD},
          {0x09E2, 0x09E3},
          {0x0A02, 0x0A02},
          {0x0A3C, 0x0A3C},
          {0x0A41, 0x0A42},
          {0x0A47, 0x0A48},
          {0x0A4B, 0x0A4D},
          {0x0A70, 0x0A71},
          {0x0A81, 0x0A82},
          {0x0ABC, 0x0ABC},
          {0x0AC1, 0x0AC5},
          {0x0AC7, 0x0AC8},
          {0x0ACD, 0x0ACD},
          {0x0B01, 0x0B01},
          {0x0B3C, 0x0B3C},
          {0x0B3F, 0x0B3F},
          {0x0B41, 0x0B43},
          {0x0B4D, 0x0B4D},
          {0x0B56, 0x0B56},
          {0x0B82, 0x0B82},
          {0x0BC0, 0x0BC0},
          {0x0BCD, 0x0BCD},
          {0x0C3E, 0x0C40},
          {0x0C46, 0x0C48},
          {0x0C4A, 0x0C4D},
          {0x0C55, 0x0C56},
          {0x0CBF, 0x0CBF},
          {0x0CC6, 0x0CC6},
          {0x0CCC, 0x0CCD},
          {0x0D41, 0x0D43},
          {0x0D4D, 0x0D4D},
          {0x0DCA, 0x0DCA},
          {0x0DD2, 0x0DD4},
          {0x0DD6, 0x0DD6},
          {0x0E31, 0x0E31},
          {0x0E34, 0x0E3A},
          {0x0E47, 0x0E4E},
          {0x0EB1, 0x0EB1},
          {0x0EB4, 0x0EB9},
          {0x0EBB, 0x0EBC},
          {0x0EC8, 0x0ECD},
          {0x0F18, 0x0F19},
          {0x0F35, 0x0F35},
          {0x0F37, 0x0F37},
          {0x0F39, 0x0F39},
          {0x0F71, 0x0F7E},
          {0x0F80, 0x0F84},
          {0x0F86, 0x0F87},
          {0x0F90, 0x0F97},
          {0x0F99, 0x0FBC},
          {0x0FC6, 0x0FC6},
          {0x102D, 0x1030},
          {0x1032, 0x1032},
          {0x1036, 0x1037},
          {0x1039, 0x1039},
          {0x1058, 0x1059},
          {0x1160, 0x11FF},
          {0x17B7, 0x17BD},
          {0x17C6, 0x17C6},
          {0x17C9, 0x17D3},
          {0x180B, 0x180E},
          {0x18A9, 0x18A9},
          {0x200B, 0x200F},
          {0x202A, 0x202E},
          {0x206A, 0x206F},
          {0x20D0, 0x20E3},
          {0x302A, 0x302F},
          {0x3099, 0x309A},
          {0xFB1E, 0xFB1E},
          {0xFE20, 0xFE23},
          {0xFEFF, 0xFEFF},
          {0xFFF9, 0xFFFB}};
  
      /* test for 8-bit control characters */
      if (ucs == 0) {
          return 0;
      }
  
      if (ucs < 0x20 || (ucs >= 0x7f && ucs < 0xa0) || ucs > 0x0010ffff) {
          return -1;
      }
  
      /* binary search in table of non-spacing characters */
      if (mbbisearch(ucs, combining, sizeof(combining) / sizeof(struct mbinterval) - 1)) {
          return 0;
      }
  
      /*
       * if we arrive here, ucs is not a combining or C0/C1 control character
       */
  
      return 1 +
             (int)(ucs >= 0x1100 &&
                 (ucs <= 0x115f || // Hangul Jamo init. consonants
                     (ucs >= 0x2e80 && ucs <= 0xa4cf && (ucs & ~0x0011) != 0x300a && ucs != 0x303f) || // CJK ... Yi
                     (ucs >= 0xac00 && ucs <= 0xd7a3) || // Hangul Syllables
                     (ucs >= 0xf900 && ucs <= 0xfaff) || // CJK Compatibility Ideographs
                     (ucs >= 0xfe30 && ucs <= 0xfe6f) || // CJK Compatibility Forms
                     (ucs >= 0xff00 && ucs <= 0xff5f) || // Fullwidth Forms
                     (ucs >= 0xffe0 && ucs <= 0xffe6) || (ucs >= 0x20000 && ucs <= 0x2ffff)));
  }
  
  /*
   * Convert a UTF-8 character to a Unicode code point.
   * This is a one-character version of pg_utf2wchar_with_len.
   *
   * No error checks here, c must point to a long-enough string.
   */
  pg_wchar utf8_to_unicode(const unsigned char* c)
  {
      if ((*c & 0x80) == 0) {
          return (pg_wchar)c[0];
      } else if ((*c & 0xe0) == 0xc0) {
          return (pg_wchar)(((c[0] & 0x1f) << 6) | (c[1] & 0x3f));
      } else if ((*c & 0xf0) == 0xe0) {
          return (pg_wchar)(((c[0] & 0x0f) << 12) | ((c[1] & 0x3f) << 6) | (c[2] & 0x3f));
      } else if ((*c & 0xf8) == 0xf0) {
          return (pg_wchar)(((c[0] & 0x07) << 18) | ((c[1] & 0x3f) << 12) | ((c[2] & 0x3f) << 6) | (c[3] & 0x3f));
      } else {
          // that is an invalid code on purpose
          return 0xffffffff;
      }
  }
  
  static int pg_utf_dsplen(const unsigned char* s)
  {
      return ucs_wcwidth(utf8_to_unicode(s));
  }
  
  /*
   * convert mule internal code to pg_wchar
   * caller should allocate enough space for "to"
   * len: length of from.
   * "from" not necessarily null terminated.
   */
  static int pg_mule2wchar_with_len(const unsigned char* from, pg_wchar* to, int len)
  {
      int cnt = 0;
  
      while (len > 0 && *from) {
          if (IS_LC1(*from) && len >= 2) {
              *to = *from++ << 16;
              *to |= *from++;
              len -= 2;
          } else if (IS_LCPRV1(*from) && len >= 3) {
              from++;
              *to = *from++ << 16;
              *to |= *from++;
              len -= 3;
          } else if (IS_LC2(*from) && len >= 3) {
              *to = *from++ << 16;
              *to |= *from++ << 8;
              *to |= *from++;
              len -= 3;
          } else if (IS_LCPRV2(*from) && len >= 4) {
              from++;
              *to = *from++ << 16;
              *to |= *from++ << 8;
              *to |= *from++;
              len -= 4;
          } else { // assume ASCII
              *to = (unsigned char)*from++;
              len--;
          }
          to++;
          cnt++;
      }
      *to = 0;
      return cnt;
  }
  
  /*
   * convert pg_wchar to mule internal code
   * caller should allocate enough space for "to"
   * len: length of from.
   * "from" not necessarily null terminated.
   */
  static int pg_wchar2mule_with_len(const pg_wchar* from, unsigned char* to, int len)
  {
      int cnt = 0;
  
      while (len > 0 && *from) {
          unsigned char lb;
  
          lb = (*from >> 16) & 0xff;
          if (IS_LC1(lb)) {
              *to++ = lb;
              *to++ = *from & 0xff;
              cnt += 2;
          } else if (IS_LC2(lb)) {
              *to++ = lb;
              *to++ = (*from >> 8) & 0xff;
              *to++ = *from & 0xff;
              cnt += 3;
          } else if (IS_LCPRV1_A_RANGE(lb)) {
              *to++ = LCPRV1_A;
              *to++ = lb;
              *to++ = *from & 0xff;
              cnt += 3;
          } else if (IS_LCPRV1_B_RANGE(lb)) {
              *to++ = LCPRV1_B;
              *to++ = lb;
              *to++ = *from & 0xff;
              cnt += 3;
          } else if (IS_LCPRV2_A_RANGE(lb)) {
              *to++ = LCPRV2_A;
              *to++ = lb;
              *to++ = (*from >> 8) & 0xff;
              *to++ = *from & 0xff;
              cnt += 4;
          } else if (IS_LCPRV2_B_RANGE(lb)) {
              *to++ = LCPRV2_B;
              *to++ = lb;
              *to++ = (*from >> 8) & 0xff;
              *to++ = *from & 0xff;
              cnt += 4;
          } else {
              *to++ = *from & 0xff;
              cnt += 1;
          }
          from++;
          len--;
      }
      *to = 0;
      return cnt;
  }
  
  int pg_mule_mblen(const unsigned char* s)
  {
      int len;
  
      if (IS_LC1(*s)) {
          len = 2;
      } else if (IS_LCPRV1(*s)) {
          len = 3;
      } else if (IS_LC2(*s)) {
          len = 3;
      } else if (IS_LCPRV2(*s)) {
          len = 4;
      } else {
          len = 1; /* assume ASCII */
      }
      return len;
  }
  
  static int pg_mule_dsplen(const unsigned char* s)
  {
      int len;
  
      if (IS_LC1(*s)) {
          len = 1;
      } else if (IS_LCPRV1(*s)) {
          len = 1;
      } else if (IS_LC2(*s)) {
          len = 2;
      } else if (IS_LCPRV2(*s)) {
          len = 2;
      } else {
          len = 1; /* assume ASCII */
      }
      return len;
  }
  
  /*
   * ISO8859-1
   */
  static int pg_latin12wchar_with_len(const unsigned char* from, pg_wchar* to, int len)
  {
      int cnt = 0;
  
      while (len > 0 && *from) {
          *to++ = *from++;
          len--;
          cnt++;
      }
      *to = 0;
      return cnt;
  }
  
  /*
   * Trivial conversion from pg_wchar to single byte encoding. Just ignores
   * high bits.
   * caller should allocate enough space for "to"
   * len: length of from.
   * "from" not necessarily null terminated.
   */
  static int pg_wchar2single_with_len(const pg_wchar* from, unsigned char* to, int len)
  {
      int cnt = 0;
  
      while (len > 0 && *from) {
          *to++ = *from++;
          len--;
          cnt++;
      }
      *to = 0;
      return cnt;
  }
  
  static int pg_latin1_mblen(const unsigned char* s)
  {
      return 1;
  }
  
  static int pg_latin1_dsplen(const unsigned char* s)
  {
      return pg_ascii_dsplen(s);
  }
  
  /*
   * SJIS
   */
  static int pg_sjis_mblen(const unsigned char* s)
  {
      int len;
  
      if (*s >= 0xa1 && *s <= 0xdf) {
          len = 1; // 1 byte kana?
      } else if (IS_HIGHBIT_SET(*s)) {
          len = 2; // kanji?
      } else {
          len = 1; // should be ASCII
      }
      return len;
  }
  
  static int pg_sjis_dsplen(const unsigned char* s)
  {
      int len;
  
      if (*s >= 0xa1 && *s <= 0xdf) {
          len = 1; // 1 byte kana?
      } else if (IS_HIGHBIT_SET(*s)) {
          len = 2; // kanji?
      } else {
          len = pg_ascii_dsplen(s); // should be ASCII
      }
      return len;
  }
  
  /*
   * Big5
   */
  static int pg_big5_mblen(const unsigned char* s)
  {
      int len;
  
      if (IS_HIGHBIT_SET(*s)) {
          len = 2; /* kanji? */
      } else {
          len = 1; /* should be ASCII */
      }
      return len;
  }
  
  static int pg_big5_dsplen(const unsigned char* s)
  {
      int len;
  
      if (IS_HIGHBIT_SET(*s)) {
          len = 2; /* kanji? */
      } else {
          len = pg_ascii_dsplen(s); /* should be ASCII */
      }
      return len;
  }
  
  /*
   * GBK
   */
  // Trivial conversion from GBK to pg_wchar.
  // caller should allocate enough space for "to"
  // len: length of from.
  // "from" not necessarily null terminated.
  static int pg_gbk2wchar_with_len(const unsigned char* from, pg_wchar* to, int len)
  {
      int cnt = 0;
  
      while (len > 0 && *from) {
          if (IS_HIGHBIT_SET(*from)) { // kanji?
              *to = *(short*)from;
              to++;
              from += 2;
              len -= 2;
          } else { // should be ASCII
              *to++ = *from++;
              len--;
          }
          cnt++;
      }
      *to = 0;
      return cnt;
  }
  
  // Trivial conversion from pg_wchar to GBK.
  // caller should allocate enough space for "to"
  // len: length of from.
  // "from" not necessarily null terminated.
  static int pg_wchar2gbk_with_len(const pg_wchar* from, unsigned char* to, int len)
  {
      int cnt = 0;
  
      while (len > 0 && *from) {
          const unsigned char* wchar = (const unsigned char*)from;
          if (IS_HIGHBIT_SET(*wchar)) { // kanji?
              *to = *(char*)from;
              from++;
              to += 2;
              len -= 2;
          } else { // should be ASCII
              *to++ = *from++;
              len--;
          }
          cnt++;
      }
      *to = 0;
      return cnt;
  }
  
  static int pg_gbk_mblen(const unsigned char* s)
  {
      int len;
  
      if (IS_HIGHBIT_SET(*s)) {
          len = 2; /* kanji? */
      } else {
          len = 1; /* should be ASCII */
      }
      return len;
  }
  
  static int pg_gbk_dsplen(const unsigned char* s)
  {
      int len;
  
      if (IS_HIGHBIT_SET(*s)) {
          len = 2; /* kanji? */
      } else {
          len = pg_ascii_dsplen(s); /* should be ASCII */
      }
      return len;
  }
  
  /*
   * UHC
   */
  static int pg_uhc_mblen(const unsigned char* s)
  {
      int len;
  
      if (IS_HIGHBIT_SET(*s)) {
          len = 2; /* 2byte? */
      } else {
          len = 1; /* should be ASCII */
      }
      return len;
  }
  
  static int pg_uhc_dsplen(const unsigned char* s)
  {
      int len;
  
      if (IS_HIGHBIT_SET(*s)) {
          len = 2; /* 2byte? */
      } else {
          len = pg_ascii_dsplen(s); /* should be ASCII */
      }
      return len;
  }
  
  /*
   *	* GB18030
   *	 * Added by Bill Huang <bhuang@redhat.com>,<bill_huanghb@ybb.ne.jp>
   *	  */
  static int pg_gb180302wchar_with_len(const unsigned char* from, pg_wchar* to, int len)
  {
      int cnt = 0;
      while (len > 0) {
          if (*from <= 0x7f) { /* ASCII */
              *to = *from++;
              --len;
          } else if (IS_HIGHBIT_SET(*from) &&
                      (*(from + 1) >= 0x30 && *(from + 1) < 0x40)) {
              if (len < 4) {
                  break;            /* drop trailing incomplete char */
              }
              *to  = *from++ << 24;
              *to |= *from++ << 16;
              *to |= *from++ << 8;
              *to |= *from++;
              len -= 4;
          } else {
              if (len < 2) {
                  break;
              }
              *to  = *from++ << 8;
              *to |= *from++;
              len -= 2;
          }
          ++to;
          ++cnt;
      }
      *to = 0;
      return cnt;
  }
  
  static int pg_wchar2gb18030_with_len(const pg_wchar* from, unsigned char* to, int len)
  {
      int cnt = 0;
      while (len > 0 && *from) {
          unsigned char c;
          if ((c = (*from >> 24))) {
              *to++ = c;
              *to++ = (*from >> 16) & 0xff;
              *to++ = (*from >> 8) & 0xff;
              *to++ = *from & 0xff;
              cnt += 4;
          } else if ((c = (*from >> 8))) {
              *to++ = c;
              *to++ = *from & 0xff;
              cnt += 2;
          } else {
              *to++ = *from;
              cnt++;
          }
          from++;
          len--;
      }
      *to = 0;
      return cnt;
  }
  
  static int pg_gb18030_mblen(const unsigned char* s)
  {
      int len;
  
      if (!IS_HIGHBIT_SET(*s)) {
          len = 1; /* ASCII */
      } else {
          if ((*(s + 1) >= 0x40 && *(s + 1) <= 0x7e) || (*(s + 1) >= 0x80 && *(s + 1) <= 0xfe)) {
              len = 2;
          } else if (*(s + 1) >= 0x30 && *(s + 1) <= 0x39) {
              len = 4;
          } else {
              len = 2;
          }
      }
      return len;
  }
  
  static int pg_gb18030_dsplen(const unsigned char* s)
  {
      int len;
  
      if (IS_HIGHBIT_SET(*s)) {
          len = 2;
      } else {
          len = pg_ascii_dsplen(s); /* ASCII */
      }
      return len;
  }
  
  /*
   * -------------------------------------------------------------------
   * multibyte sequence validators
   *
   * These functions accept "s", a pointer to the first byte of a string,
   * and "len", the remaining length of the string.  If there is a validly
   * encoded character beginning at *s, return its length in bytes; else
   * return -1.
   *
   * The functions can assume that len > 0 and that *s != '\0', but they must
   * test for and reject zeroes in any additional bytes of a multibyte character.
   *
   * Note that this definition allows the function for a single-byte
   * encoding to be just "return 1".
   * -------------------------------------------------------------------
   */
  
  static int pg_ascii_verifier(const unsigned char* s, int len)
  {
      return 1;
  }
  
  #define IS_EUC_RANGE_VALID(c) ((c) >= 0xa1 && (c) <= 0xfe)
  
  static int pg_eucjp_verifier(const unsigned char* s, int len)
  {
      int l;
      unsigned char c1, c2;
  
      c1 = *s++;
  
      switch (c1) {
          case SS2: /* JIS X 0201 */
              l = 2;
              if (l > len) {
                  return -1;
              }
  
              c2 = *s++;
              if (c2 < 0xa1 || c2 > 0xdf) {
                  return -1;
              }
  
              break;
  
          case SS3: /* JIS X 0212 */
              l = 3;
              if (l > len) {
                  return -1;
              }
  
              c2 = *s++;
              if (!IS_EUC_RANGE_VALID(c2)) {
                  return -1;
              }
  
              c2 = *s++;
              if (!IS_EUC_RANGE_VALID(c2)) {
                  return -1;
              }
              break;
  
          default:
              if (IS_HIGHBIT_SET(c1)) { // JIS X 0208?
                  l = 2;
                  if (l > len) {
                      return -1;
                  }
                  if (!IS_EUC_RANGE_VALID(c1)) {
                      return -1;
                  }
                  c2 = *s++;
                  if (!IS_EUC_RANGE_VALID(c2)) {
                      return -1;
                  }
              } else { // must be ASCII
                  l = 1;
              }
              break;
      }
  
      return l;
  }
  
  static int pg_euckr_verifier(const unsigned char* s, int len)
  {
      int l;
      unsigned char c1, c2;
  
      c1 = *s++;
  
      if (IS_HIGHBIT_SET(c1)) {
          l = 2;
          if (l > len) {
              return -1;
          }
          if (!IS_EUC_RANGE_VALID(c1)) {
              return -1;
          }
          c2 = *s++;
          if (!IS_EUC_RANGE_VALID(c2)) {
              return -1;
          }
      } else { // must be ASCII
          l = 1;
      }
  
      return l;
  }
  
  /* EUC-CN byte sequences are exactly same as EUC-KR */
  #define pg_euccn_verifier pg_euckr_verifier
  
  static int pg_euctw_verifier(const unsigned char* s, int len)
  {
      int l;
      unsigned char c1, c2;
  
      c1 = *s++;
  
      switch (c1) {
          case SS2: /* CNS 11643 Plane 1-7 */
              l = 4;
              if (l > len) {
                  return -1;
              }
  
              c2 = *s++;
              if (c2 < 0xa1 || c2 > 0xa7) {
                  return -1;
              }
  
              c2 = *s++;
              if (!IS_EUC_RANGE_VALID(c2)) {
                  return -1;
              }
  
              c2 = *s++;
              if (!IS_EUC_RANGE_VALID(c2)) {
                  return -1;
              }
              break;
  
          case SS3: /* unused */
              return -1;
  
          default:
              if (IS_HIGHBIT_SET(c1)) { // CNS 11643 Plane 1
                  l = 2;
                  if (l > len) {
                      return -1;
                  }
                  // no further range check on c1?
                  c2 = *s++;
                  if (!IS_EUC_RANGE_VALID(c2)) {
                      return -1;
                  }
              } else { // must be ASCII
                  l = 1;
              }
              break;
      }
      return l;
  }
  
  static int pg_johab_verifier(const unsigned char* s, int len)
  {
      int l, mbl;
      unsigned char c;
  
      l = mbl = pg_johab_mblen(s);
  
      if (len < l) {
          return -1;
      }
  
  
      if (!IS_HIGHBIT_SET(*s)) {
          return mbl;
      }
  
  
      while (--l > 0) {
          c = *++s;
          if (!IS_EUC_RANGE_VALID(c)) {
              return -1;
          }
      }
      return mbl;
  }
  
  static int pg_mule_verifier(const unsigned char* s, int len)
  {
      int l, mbl;
      unsigned char c;
  
      l = mbl = pg_mule_mblen(s);
  
      if (len < l) {
          return -1;
      }
  
      while (--l > 0) {
          c = *++s;
          if (!IS_HIGHBIT_SET(c)) {
              return -1;
          }
      }
      return mbl;
  }
  
  static int pg_latin1_verifier(const unsigned char* s, int len)
  {
      return 1;
  }
  
  static int pg_sjis_verifier(const unsigned char* s, int len)
  {
      int l, mbl;
      unsigned char c1, c2;
  
      l = mbl = pg_sjis_mblen(s);
  
      if (len < l) {
          return -1;
      }
  
      // pg_sjis_mblen already verified it
      if (l == 1) {
          return mbl;
      }
  
  
      c1 = *s++;
      c2 = *s;
      if (!ISSJISHEAD(c1) || !ISSJISTAIL(c2)) {
          return -1;
      }
  
      return mbl;
  }
  
  static int pg_big5_verifier(const unsigned char* s, int len)
  {
      int l, mbl;
  
      l = mbl = pg_big5_mblen(s);
  
      if (len < l) {
          return -1;
      }
  
  
      while (--l > 0) {
          if (*++s == '\0') {
              return -1;
          }
      }
  
      return mbl;
  }
  
  static int pg_gbk_verifier(const unsigned char* s, int len)
  {
      int l, mbl;
  
      l = mbl = pg_gbk_mblen(s);
  
      if (len < l) {
          return -1;
      }
  
      if (!pg_gbk_islegal(s, l)) {
          return -1;
      }
  
      while (--l > 0) {
          if (*++s == '\0') {
              return -1;
          }
      }
  
      return mbl;
  }
  
  // check if the input character which is declared as GBK is legal
  bool pg_gbk_islegal(const unsigned char* source, int length)
  {
      switch (length) {
          default:
              // reject lengths > 2
              return false;
          case 2:
              if (source[0] < 0x81 || source[0] > 0xFE || source[1] < 0x40 || source[1] > 0xFE || source[1] == 0x7F) {
                  return false;
              }
              break;
              // FALL THRU
          case 1:
              if (*source > 0x7F) {
                  return false;
              }
              break;
      }
      return true;
  }
  
  static int pg_uhc_verifier(const unsigned char* s, int len)
  {
      int l, mbl;
  
      l = mbl = pg_uhc_mblen(s);
  
      if (len < l) {
          return -1;
      }
  
      while (--l > 0) {
          if (*++s == '\0') {
              return -1;
          }
      }
  
      return mbl;
  }
  
  static int pg_gb18030_verifier(const unsigned char* s, int len)
  {
      int l, mbl;
  
      l = mbl = pg_gb18030_mblen(s);
  
      if (len < l) {
          return -1;
      }
  
      while (--l > 0) {
          if (*++s == '\0') {
              return -1;
          }
      }
  
      return mbl;
  }
  
  static int pg_utf8_verifier(const unsigned char* s, int len)
  {
      int l = pg_utf_mblen(s);
  
      if (len < l) {
          return -1;
      }
  
      if (!pg_utf8_islegal(s, l)) {
          return -1;
      }
  
      return l;
  }
  
  /*
   * Check for validity of a single UTF-8 encoded character
   *
   * This directly implements the rules in RFC3629.  The bizarre-looking
   * restrictions on the second byte are meant to ensure that there isn't
   * more than one encoding of a given Unicode character point; that is,
   * you may not use a longer-than-necessary byte sequence with high order
   * zero bits to represent a character that would fit in fewer bytes.
   * To do otherwise is to create security hazards (eg, create an apparent
   * non-ASCII character that decodes to plain ASCII).
   *
   * length is assumed to have been obtained by pg_utf_mblen(), and the
   * caller must have checked that that many bytes are present in the buffer.
   */
  bool pg_utf8_islegal(const unsigned char* source, int length)
  {
      unsigned char a;
  
      switch (length) {
          default:
              /* reject lengths 5 and 6 for now */
              return false;
          case 4:
              a = source[3];
              if (a < 0x80 || a > 0xBF) {
                  return false;
              }
              /* FALL THRU */
          case 3:
              a = source[2];
              if (a < 0x80 || a > 0xBF) {
                  return false;
              }
              /* FALL THRU */
          case 2:
              a = source[1];
              switch (*source) {
                  case 0xE0:
                      if (a < 0xA0 || a > 0xBF) {
                          return false;
                      }
                      break;
                  case 0xED:
                      if (a < 0x80 || a > 0x9F) {
                          return false;
                      }
                      break;
                  case 0xF0:
                      if (a < 0x90 || a > 0xBF) {
                          return false;
                      }
                      break;
                  case 0xF4:
                      if (a < 0x80 || a > 0x8F) {
                          return false;
                      }
                      break;
                  default:
                      if (a < 0x80 || a > 0xBF) {
                          return false;
                      }
                      break;
              }
              /* FALL THRU */
          case 1:
              a = *source;
              if (a >= 0x80 && a < 0xC2) {
                  return false;
              }
              if (a > 0xF4) {
                  return false;
              }
              break;
      }
      return true;
  }
  
  #ifndef FRONTEND
  
  /*
   * Generic character incrementer function.
   *
   * Not knowing anything about the properties of the encoding in use, we just
   * keep incrementing the last byte until we get a validly-encoded result,
   * or we run out of values to try.	We don't bother to try incrementing
   * higher-order bytes, so there's no growth in runtime for wider characters.
   * (If we did try to do that, we'd need to consider the likelihood that 255
   * is not a valid final byte in the encoding.)
   */
  static bool pg_generic_charinc(unsigned char* charptr, int len)
  {
      unsigned char* lastbyte = charptr + len - 1;
      mbverifier mbverify;
  
      /* We can just invoke the character verifier directly. */
      mbverify = pg_wchar_table[GetDatabaseEncoding()].mbverify;
  
      while (*lastbyte < (unsigned char)255) {
          (*lastbyte)++;
          if ((*mbverify)(charptr, len) == len) {
              return true;
          }
      }
  
      return false;
  }
  
  /*
   * UTF-8 character incrementer function.
   *
   * For a one-byte character less than 0x7F, we just increment the byte.
   *
   * For a multibyte character, every byte but the first must fall between 0x80
   * and 0xBF; and the first byte must be between 0xC0 and 0xF4.	We increment
   * the last byte that's not already at its maximum value.  If we can't find a
   * byte that's less than the maximum allowable value, we simply fail.  We also
   * need some special-case logic to skip regions used for surrogate pair
   * handling, as those should not occur in valid UTF-8.
   *
   * Note that we don't reset lower-order bytes back to their minimums, since
   * we can't afford to make an exhaustive search (see make_greater_string).
   */
  static bool pg_utf8_increment(unsigned char* charptr, int length)
  {
      unsigned char a;
      unsigned char limit;
  
      switch (length) {
          default:
              /* reject lengths 5 and 6 for now */
              return false;
          case 4:
              a = charptr[3];
              if (a < 0xBF) {
                  charptr[3]++;
                  break;
              }
              /* FALL THRU */
          case 3:
              a = charptr[2];
              if (a < 0xBF) {
                  charptr[2]++;
                  break;
              }
              /* FALL THRU */
          case 2:
              a = charptr[1];
              switch (*charptr) {
                  case 0xED:
                      limit = 0x9F;
                      break;
                  case 0xF4:
                      limit = 0x8F;
                      break;
                  default:
                      limit = 0xBF;
                      break;
              }
              if (a < limit) {
                  charptr[1]++;
                  break;
              }
              /* FALL THRU */
          case 1:
              a = *charptr;
              if (a == 0x7F || a == 0xDF || a == 0xEF || a == 0xF4) {
                  return false;
              }
              charptr[0]++;
              break;
      }
  
      return true;
  }
  
  /*
   * EUC-JP character incrementer function.
   *
   * If the sequence starts with SS2 (0x8e), it must be a two-byte sequence
   * representing JIS X 0201 characters with the second byte ranging between
   * 0xa1 and 0xdf.  We just increment the last byte if it's less than 0xdf,
   * and otherwise rewrite the whole sequence to 0xa1 0xa1.
   *
   * If the sequence starts with SS3 (0x8f), it must be a three-byte sequence
   * in which the last two bytes range between 0xa1 and 0xfe.  The last byte
   * is incremented if possible, otherwise the second-to-last byte.
   *
   * If the sequence starts with a value other than the above and its MSB
   * is set, it must be a two-byte sequence representing JIS X 0208 characters
   * with both bytes ranging between 0xa1 and 0xfe.  The last byte is
   * incremented if possible, otherwise the second-to-last byte.
   *
   * Otherwise, the sequence is a single-byte ASCII character. It is
   * incremented up to 0x7f.
   */
  static bool pg_eucjp_increment(unsigned char* charptr, int length)
  {
      unsigned char c1, c2;
      int i;
  
      c1 = *charptr;
  
      switch (c1) {
          case SS2: /* JIS X 0201 */
              if (length != 2) {
                  return false;
              }
              c2 = charptr[1];
  
              if (c2 >= 0xdf) {
                  charptr[0] = charptr[1] = 0xa1;
              } else if (c2 < 0xa1) {
                  charptr[1] = 0xa1;
              } else {
                  charptr[1]++;
              }
              break;
  
          case SS3: /* JIS X 0212 */
              if (length != 3) {
                  return false;
              }
              for (i = 2; i > 0; i--) {
                  c2 = charptr[i];
                  if (c2 < 0xa1) {
                      charptr[i] = 0xa1;
                      return true;
                  } else if (c2 < 0xfe) {
                      charptr[i]++;
                      return true;
                  }
              }
  
              /* Out of 3-byte code region */
              return false;
  
          default:
              // JIS X 0208?
              if (IS_HIGHBIT_SET(c1)) {
                  if (length != 2) {
                      return false;
                  }
                  for (i = 1; i >= 0; i--) {
                      c2 = charptr[i];
                      if (c2 < 0xa1) {
                          charptr[i] = 0xa1;
                          return true;
                      } else if (c2 < 0xfe) {
                          charptr[i]++;
                          return true;
                      }
                  }
  
                  /* Out of 2 byte code region */
                  return false;
              } else { /* ASCII, single byte */
                  if (c1 > 0x7e) {
                      return false;
                  }
                  (*charptr)++;
              }
              break;
      }
  
      return true;
  }
  #endif /* !FRONTEND */
  
  /*
   * -------------------------------------------------------------------
   * encoding info table
   * XXX must be sorted by the same order as enum pg_enc (in mb/pg_wchar.h)
   * -------------------------------------------------------------------
   */
  pg_wchar_tbl pg_wchar_table[] = {
      {pg_ascii2wchar_with_len, pg_wchar2single_with_len, pg_ascii_mblen, pg_ascii_dsplen, pg_ascii_verifier, 1}, /* PG_SQL_ASCII
                                                                                                                   */
      {pg_eucjp2wchar_with_len, pg_wchar2euc_with_len, pg_eucjp_mblen, pg_eucjp_dsplen, pg_eucjp_verifier, 3}, /* PG_EUC_JP
                                                                                                                */
      {pg_euccn2wchar_with_len, pg_wchar2euc_with_len, pg_euccn_mblen, pg_euccn_dsplen, pg_euccn_verifier, 2}, /* PG_EUC_CN
                                                                                                                */
      {pg_euckr2wchar_with_len, pg_wchar2euc_with_len, pg_euckr_mblen, pg_euckr_dsplen, pg_euckr_verifier, 3}, /* PG_EUC_KR
                                                                                                                */
      {pg_euctw2wchar_with_len, pg_wchar2euc_with_len, pg_euctw_mblen, pg_euctw_dsplen, pg_euctw_verifier, 4}, /* PG_EUC_TW
                                                                                                                */
      {pg_eucjp2wchar_with_len, pg_wchar2euc_with_len, pg_eucjp_mblen, pg_eucjp_dsplen, pg_eucjp_verifier, 3}, /* PG_EUC_JIS_2004
                                                                                                                */
      {pg_gbk2wchar_with_len, pg_wchar2gbk_with_len, pg_gbk_mblen, pg_gbk_dsplen, pg_gbk_verifier, 2},  /* PG_GBK */
      {pg_utf2wchar_with_len, pg_wchar2utf_with_len, pg_utf_mblen, pg_utf_dsplen, pg_utf8_verifier, 4}, /* PG_UTF8 */
      {pg_mule2wchar_with_len, pg_wchar2mule_with_len, pg_mule_mblen, pg_mule_dsplen, pg_mule_verifier, 4}, /* PG_MULE_INTERNAL
                                                                                                             */
      {pg_latin12wchar_with_len,
          pg_wchar2single_with_len,
          pg_latin1_mblen,
          pg_latin1_dsplen,
          pg_latin1_verifier,
          1}, /* PG_LATIN1 */
      {pg_latin12wchar_with_len,
          pg_wchar2single_with_len,
          pg_latin1_mblen,
          pg_latin1_dsplen,
          pg_latin1_verifier,
          1}, /* PG_LATIN2 */
      {pg_latin12wchar_with_len,
          pg_wchar2single_with_len,
          pg_latin1_mblen,
          pg_latin1_dsplen,
          pg_latin1_verifier,
          1}, /* PG_LATIN3 */
      {pg_latin12wchar_with_len,
          pg_wchar2single_with_len,
          pg_latin1_mblen,
          pg_latin1_dsplen,
          pg_latin1_verifier,
          1}, /* PG_LATIN4 */
      {pg_latin12wchar_with_len,
          pg_wchar2single_with_len,
          pg_latin1_mblen,
          pg_latin1_dsplen,
          pg_latin1_verifier,
          1}, /* PG_LATIN5 */
      {pg_latin12wchar_with_len,
          pg_wchar2single_with_len,
          pg_latin1_mblen,
          pg_latin1_dsplen,
          pg_latin1_verifier,
          1}, /* PG_LATIN6 */
      {pg_latin12wchar_with_len,
          pg_wchar2single_with_len,
          pg_latin1_mblen,
          pg_latin1_dsplen,
          pg_latin1_verifier,
          1}, /* PG_LATIN7 */
      {pg_latin12wchar_with_len,
          pg_wchar2single_with_len,
          pg_latin1_mblen,
          pg_latin1_dsplen,
          pg_latin1_verifier,
          1}, /* PG_LATIN8 */
      {pg_latin12wchar_with_len,
          pg_wchar2single_with_len,
          pg_latin1_mblen,
          pg_latin1_dsplen,
          pg_latin1_verifier,
          1}, /* PG_LATIN9 */
      {pg_latin12wchar_with_len,
          pg_wchar2single_with_len,
          pg_latin1_mblen,
          pg_latin1_dsplen,
          pg_latin1_verifier,
          1}, /* PG_LATIN10 */
      {pg_latin12wchar_with_len,
          pg_wchar2single_with_len,
          pg_latin1_mblen,
          pg_latin1_dsplen,
          pg_latin1_verifier,
          1}, /* PG_WIN1256 */
      {pg_latin12wchar_with_len,
          pg_wchar2single_with_len,
          pg_latin1_mblen,
          pg_latin1_dsplen,
          pg_latin1_verifier,
          1}, /* PG_WIN1258 */
      {pg_latin12wchar_with_len,
          pg_wchar2single_with_len,
          pg_latin1_mblen,
          pg_latin1_dsplen,
          pg_latin1_verifier,
          1}, /* PG_WIN866 */
      {pg_latin12wchar_with_len,
          pg_wchar2single_with_len,
          pg_latin1_mblen,
          pg_latin1_dsplen,
          pg_latin1_verifier,
          1}, /* PG_WIN874 */
      {pg_latin12wchar_with_len,
          pg_wchar2single_with_len,
          pg_latin1_mblen,
          pg_latin1_dsplen,
          pg_latin1_verifier,
          1}, /* PG_KOI8R */
      {pg_latin12wchar_with_len,
          pg_wchar2single_with_len,
          pg_latin1_mblen,
          pg_latin1_dsplen,
          pg_latin1_verifier,
          1}, /* PG_WIN1251 */
      {pg_latin12wchar_with_len,
          pg_wchar2single_with_len,
          pg_latin1_mblen,
          pg_latin1_dsplen,
          pg_latin1_verifier,
          1}, /* PG_WIN1252 */
      {pg_latin12wchar_with_len,
          pg_wchar2single_with_len,
          pg_latin1_mblen,
          pg_latin1_dsplen,
          pg_latin1_verifier,
          1}, /* ISO-8859-5 */
      {pg_latin12wchar_with_len,
          pg_wchar2single_with_len,
          pg_latin1_mblen,
          pg_latin1_dsplen,
          pg_latin1_verifier,
          1}, /* ISO-8859-6 */
      {pg_latin12wchar_with_len,
          pg_wchar2single_with_len,
          pg_latin1_mblen,
          pg_latin1_dsplen,
          pg_latin1_verifier,
          1}, /* ISO-8859-7 */
      {pg_latin12wchar_with_len,
          pg_wchar2single_with_len,
          pg_latin1_mblen,
          pg_latin1_dsplen,
          pg_latin1_verifier,
          1}, /* ISO-8859-8 */
      {pg_latin12wchar_with_len,
          pg_wchar2single_with_len,
          pg_latin1_mblen,
          pg_latin1_dsplen,
          pg_latin1_verifier,
          1}, /* PG_WIN1250 */
      {pg_latin12wchar_with_len,
          pg_wchar2single_with_len,
          pg_latin1_mblen,
          pg_latin1_dsplen,
          pg_latin1_verifier,
          1}, /* PG_WIN1253 */
      {pg_latin12wchar_with_len,
          pg_wchar2single_with_len,
          pg_latin1_mblen,
          pg_latin1_dsplen,
          pg_latin1_verifier,
          1}, /* PG_WIN1254 */
      {pg_latin12wchar_with_len,
          pg_wchar2single_with_len,
          pg_latin1_mblen,
          pg_latin1_dsplen,
          pg_latin1_verifier,
          1}, /* PG_WIN1255 */
      {pg_latin12wchar_with_len,
          pg_wchar2single_with_len,
          pg_latin1_mblen,
          pg_latin1_dsplen,
          pg_latin1_verifier,
          1}, /* PG_WIN1257 */
      {pg_latin12wchar_with_len,
          pg_wchar2single_with_len,
          pg_latin1_mblen,
          pg_latin1_dsplen,
          pg_latin1_verifier,
          1},                                                              /* PG_KOI8U */
      {pg_gb180302wchar_with_len,
          pg_wchar2gb18030_with_len,
          pg_gb18030_mblen,
          pg_gb18030_dsplen,
          pg_gb18030_verifier,
          4},                                                              /* PG_GB18030 */
      {0, 0, pg_sjis_mblen, pg_sjis_dsplen, pg_sjis_verifier, 2},          /* PG_SJIS */
      {0, 0, pg_big5_mblen, pg_big5_dsplen, pg_big5_verifier, 2},          /* PG_BIG5 */
      {0, 0, pg_uhc_mblen, pg_uhc_dsplen, pg_uhc_verifier, 2},             /* PG_UHC */
      {0, 0, pg_johab_mblen, pg_johab_dsplen, pg_johab_verifier, 3},       /* PG_JOHAB */
      {0, 0, pg_sjis_mblen, pg_sjis_dsplen, pg_sjis_verifier, 2}           /* PG_SHIFT_JIS_2004 */
  };
  
  /* returns the byte length of a word for mule internal code */
  int pg_mic_mblen(const unsigned char* mbstr)
  {
      return pg_mule_mblen(mbstr);
  }
  
  /*
   * Returns the byte length of a multibyte character.
   */
  int pg_encoding_mblen(int encoding, const char* mbstr)
  {
      Assert(PG_VALID_ENCODING(encoding));
  
      return ((encoding >= 0 && (size_t)encoding < sizeof(pg_wchar_table) / sizeof(pg_wchar_tbl))
                  ? ((*pg_wchar_table[encoding].mblen)((const unsigned char*)mbstr))
                  : ((*pg_wchar_table[PG_SQL_ASCII].mblen)((const unsigned char*)mbstr)));
  }
  
  /*
   * Returns the display length of a multibyte character.
   */
  int pg_encoding_dsplen(int encoding, const char* mbstr)
  {
      Assert(PG_VALID_ENCODING(encoding));
  
      return ((encoding >= 0 && (size_t)encoding < sizeof(pg_wchar_table) / sizeof(pg_wchar_tbl))
                  ? ((*pg_wchar_table[encoding].dsplen)((const unsigned char*)mbstr))
                  : ((*pg_wchar_table[PG_SQL_ASCII].dsplen)((const unsigned char*)mbstr)));
  }
  
  /*
   * Verify the first multibyte character of the given string.
   * Return its byte length if good, -1 if bad.  (See comments above for
   * full details of the mbverify API.)
   */
  int pg_encoding_verifymb(int encoding, const char* mbstr, int len)
  {
      Assert(PG_VALID_ENCODING(encoding));
  
      return ((encoding >= 0 && (size_t)encoding < sizeof(pg_wchar_table) / sizeof(pg_wchar_tbl))
                  ? ((*pg_wchar_table[encoding].mbverify)((const unsigned char*)mbstr, len))
                  : ((*pg_wchar_table[PG_SQL_ASCII].mbverify)((const unsigned char*)mbstr, len)));
  }
  
  /*
   * fetch maximum length of a given encoding
   */
  int pg_encoding_max_length(int encoding)
  {
      Assert(PG_VALID_ENCODING(encoding));
  
      return pg_wchar_table[encoding].maxmblen;
  }
  
  #ifdef WIN32
  #ifndef FRONTEND
  
  /*
   * fetch maximum length of the encoding for the current database
   */
  int pg_database_encoding_max_length(void)
  {
      return pg_wchar_table[GetDatabaseEncoding()].maxmblen;
  }
  
  /*
   * Verify mbstr to make sure that it is validly encoded in the current
   * database encoding.  Otherwise same as pg_verify_mbstr().
   */
  bool pg_verifymbstr(const char* mbstr, int len, bool noError)
  {
      return pg_verify_mbstr_len(GetDatabaseEncoding(), mbstr, len, noError) >= 0;
  }
  #endif
  #else
  int pg_database_encoding_max_length(void)
  {
      return pg_wchar_table[GetDatabaseEncoding()].maxmblen;
  }
  
  /*
   * Verify mbstr to make sure that it is validly encoded in the current
   * database encoding.  Otherwise same as pg_verify_mbstr().
   */
  bool pg_verifymbstr(const char* mbstr, int len, bool noError)
  {
      return pg_verify_mbstr_len(GetDatabaseEncoding(), mbstr, len, noError) >= 0;
  }
  #endif
  
  #ifndef FRONTEND
  /*
   * get the character incrementer for the encoding for the current database
   */
  mbcharacter_incrementer pg_database_encoding_character_incrementer(void)
  {
      /*
       * Eventually it might be best to add a field to pg_wchar_table[], but for
       * now we just use a switch.
       */
      switch (GetDatabaseEncoding()) {
          case PG_UTF8:
              return pg_utf8_increment;
  
          case PG_EUC_JP:
              return pg_eucjp_increment;
  
          default:
              return pg_generic_charinc;
      }
  }
  
  /*
   * Verify mbstr to make sure that it is validly encoded in the specified
   * encoding.
   */
  bool pg_verify_mbstr(int encoding, const char* mbstr, int len, bool noError)
  {
      return pg_verify_mbstr_len(encoding, mbstr, len, noError) >= 0;
  }
  
  #endif // FRONTEND
  
  /*
   * Verify mbstr to make sure that it is validly encoded in the specified
   * encoding.
   *
   * mbstr is not necessarily zero terminated; length of mbstr is
   * specified by len.
   *
   * If OK, return length of string in the encoding.
   * If a problem is found, return -1 when noError is
   * true; when noError is false, ereport() a descriptive message.
   */
  int pg_verify_mbstr_len(int encoding, const char* mbstr, int len, bool noError)
  {
      mbverifier mbverify;
      int mb_len;
  #ifndef FRONTEND
      bool bulkload_illegal_chars_conversion = false;
  #endif
  
      Assert(PG_VALID_ENCODING(encoding));
  
  #ifndef FRONTEND
      if (u_sess->cmd_cxt.bulkload_compatible_illegal_chars) {
          bulkload_illegal_chars_conversion = true;
      } else if (u_sess->mb_cxt.insertValuesBind_compatible_illegal_chars) {
          bulkload_illegal_chars_conversion = true;
      }
  #endif
  
      /*
       * In single-byte encodings, we need only reject nulls (\0).
       */
      if (pg_encoding_max_length(encoding) <= 1) {
          const char* nullpos = (char*)memchr(mbstr, 0, len);
  
          if (nullpos == NULL) {
              return len;
          }
          if (noError) {
              return -1;
          }
  #ifndef FRONTEND
          if (bulkload_illegal_chars_conversion) {
              char* curpos = (char*)nullpos;
              int left_len = len - (nullpos - mbstr);
  
              /*
               * check whether '\0' exists char by char.
               */
              while (left_len > 0) {
                  if ('\0' == *curpos) {
                      *curpos = ' ';
                  }
  
                  curpos++;
                  left_len--;
              }
  
              return len;
          } else {
              report_invalid_encoding(encoding, nullpos, 1);
          }
  #else
          report_invalid_encoding(encoding, nullpos, 1);
  #endif
      }
  
      /* fetch function pointer just once */
      mbverify = pg_wchar_table[encoding].mbverify;
  
      mb_len = 0;
  
      while (len > 0) {
          int l;
  
          /* fast path for ASCII-subset characters */
          if (!IS_HIGHBIT_SET(*mbstr)) {
              if (*mbstr != '\0') {
                  mb_len++;
                  mbstr++;
                  len--;
                  continue;
              }
              if (noError) {
                  return -1;
              }
  #ifndef FRONTEND
              if (bulkload_illegal_chars_conversion) {
                  *(char*)mbstr = ' ';
                  mb_len++;
                  mbstr++;
                  len--;
                  continue;
              } else {
                  report_invalid_encoding(encoding, mbstr, len);
              }
  #else
              report_invalid_encoding(encoding, mbstr, len);
  #endif
          }
  
          l = (*mbverify)((const unsigned char*)mbstr, len);
  
          if (l < 0) {
              if (noError) {
                  return -1;
              }
  #ifndef FRONTEND
              if (bulkload_illegal_chars_conversion) {
                  /*
                   * use '?' as illegal chars conversion
                   */
                  *(char*)mbstr = '?';
  
                  mbstr++;
                  len--;
                  mb_len++;
                  continue;
              } else {
                  report_invalid_encoding(encoding, mbstr, len);
              }
  #else
              report_invalid_encoding(encoding, mbstr, len);
  #endif
          }
  
          mbstr += l;
          len -= l;
          mb_len++;
      }
      return mb_len;
  }
  
  #ifdef FRONTEND
  void report_invalid_encoding(int, const char*, int)
  {
  
  }
  #endif // FRONTEND
  
  #ifndef FRONTEND
  
  /*
   * check_encoding_conversion_args: check arguments of a conversion function
   *
   * "expected" arguments can be either an encoding ID or -1 to indicate that
   * the caller will check whether it accepts the ID.
   *
   * Note: the errors here are not really user-facing, so elog instead of
   * ereport seems sufficient.  Also, we trust that the "expected" encoding
   * arguments are valid encoding IDs, but we don't trust the actuals.
   */
  void check_encoding_conversion_args(
      int src_encoding, int dest_encoding, int len, int expected_src_encoding, int expected_dest_encoding)
  {
      if (!PG_VALID_ENCODING(src_encoding)) {
          ereport(ERROR, (errcode(ERRCODE_SYSTEM_ERROR), errmsg("invalid source encoding ID: %d", src_encoding)));
      }
  
      if (src_encoding != expected_src_encoding && expected_src_encoding >= 0) {
          ereport(ERROR,
              (errcode(ERRCODE_SYSTEM_ERROR),
                  errmsg("expected source encoding \"%s\", but got \"%s\"",
                      pg_enc2name_tbl[expected_src_encoding].name,
                      pg_enc2name_tbl[src_encoding].name)));
      }
  
      if (!PG_VALID_ENCODING(dest_encoding)) {
          ereport(ERROR, (errcode(ERRCODE_SYSTEM_ERROR), errmsg("invalid destination encoding ID: %d", dest_encoding)));
      }
  
      if (dest_encoding != expected_dest_encoding && expected_dest_encoding >= 0) {
          ereport(ERROR,
              (errcode(ERRCODE_SYSTEM_ERROR),
                  errmsg("expected destination encoding \"%s\", but got \"%s\"",
                      pg_enc2name_tbl[expected_dest_encoding].name,
                      pg_enc2name_tbl[dest_encoding].name)));
      }
  
      if (len < 0) {
          ereport(ERROR, (errcode(ERRCODE_SYSTEM_ERROR), errmsg("encoding conversion length must not be negative")));
      }
  }
  
  /*
   * report_invalid_encoding: complain about invalid multibyte character
   *
   * note: len is remaining length of string, not length of character;
   * len must be greater than zero, as we always examine the first byte.
   */
  void report_invalid_encoding(int encoding, const char* mbstr, int len)
  {
      int l = pg_encoding_mblen(encoding, mbstr);
      char buf[8 * 5 + 1];
      char* p = buf;
      int j, jlimit;
      int rc = -1;
      int bufLen = sizeof(buf);
      
      jlimit = Min(l, len);
      jlimit = Min(jlimit, 8); /* prevent buffer overrun */
  
      for (j = 0; j < jlimit; j++) {
          rc = sprintf_s(p, bufLen, "0x%02x", (unsigned char)mbstr[j]);
          securec_check_ss(rc, "\0", "\0");
          p += rc;
          bufLen -= rc;
          if (j < jlimit - 1) {
              rc = sprintf_s(p, bufLen, " ");
              securec_check_ss(rc, "\0", "\0");
              p += rc;
              bufLen -= rc;
          }
      }
  
      ereport(ERROR,
          (errcode(ERRCODE_CHARACTER_NOT_IN_REPERTOIRE),
              errmsg("invalid byte sequence for encoding \"%s\": %s", pg_enc2name_tbl[encoding].name, buf)));
  }
  
  /*
   * report_untranslatable_char: complain about untranslatable character
   *
   * note: len is remaining length of string, not length of character;
   * len must be greater than zero, as we always examine the first byte.
   */
  void report_untranslatable_char(int src_encoding, int dest_encoding, const char* mbstr, int len)
  {
      int l = pg_encoding_mblen(src_encoding, mbstr);
      char buf[8 * 5 + 1];
      char* p = buf;
      int j, jlimit;
  
      jlimit = Min(l, len);
      jlimit = Min(jlimit, 8); /* prevent buffer overrun */
  
      for (j = 0; j < jlimit; j++) {
          p += sprintf_s(p, sizeof(buf), "0x%02x", (unsigned char)mbstr[j]);
          if (j < jlimit - 1) {
              p += sprintf_s(p, sizeof(buf), " ");
          }
      }
  
      /* omit untranslatable character error, report it in log
       * just works for local ->utf8 encoding translation.
       */
      if (u_sess->attr.attr_common.omit_encoding_error && (PG_UTF8 == dest_encoding)) {
          ereport(LOG,
              (errcode(ERRCODE_UNTRANSLATABLE_CHARACTER),
                  errmsg("character with byte sequence %s in encoding \"%s\" has no equivalent in encoding \"%s\"",
                      buf,
                      pg_enc2name_tbl[src_encoding].name,
                      pg_enc2name_tbl[dest_encoding].name)));
      } else {
          ereport(ERROR,
              (errcode(ERRCODE_UNTRANSLATABLE_CHARACTER),
                  errmsg("character with byte sequence %s in encoding \"%s\" has no equivalent in encoding \"%s\"",
                      buf,
                      pg_enc2name_tbl[src_encoding].name,
                      pg_enc2name_tbl[dest_encoding].name)));
      }
  }
  
  /*
   * add_invalid_encoding: add invalid encoding info to current CopyState illegal_chars_error list;
   *
   * note: len is remaining length of string, not length of character;
   * len must be greater than zero, as we always examine the first byte.
   *
   */
  void add_invalid_encoding(int encoding, const char* mbstr, int len, List** err_info_list, int err_offset)
  {
      return;
      int l = pg_encoding_mblen(encoding, mbstr);
      char buf[40];
      char* p = buf;
      int j, jlimit;
      int rc = -1;
      int buf_left_size = sizeof(buf);
  
      if (u_sess->mb_cxt.insertValuesBind_compatible_illegal_chars) {
          return;
      }
  
      Assert(err_info_list);
  
      jlimit = Min(l, len);
      jlimit = Min(jlimit, 8); /* prevent buffer overrun */
  
      for (j = 0; j < jlimit; j++) {
          rc = sprintf_s(p, buf_left_size, "0x%02x", (unsigned char)mbstr[j]);
          securec_check_ss(rc, "\0", "\0");
  
          p += rc;
          buf_left_size -= rc;
  
          if (j < jlimit - 1) {
              rc = sprintf_s(p, buf_left_size, " ");
              securec_check_ss(rc, "\0", "\0");
  
              p += rc;
              buf_left_size -= rc;
          }
      }
  
      IllegalCharErrInfo* errInfo = (IllegalCharErrInfo*)palloc0(sizeof(IllegalCharErrInfo));
      errInfo->err_info = (char*)palloc0(sizeof(buf));
      /*
       * record the original invalid encoding info.
       */
      rc = memcpy_s(errInfo->err_info, sizeof(buf), buf, sizeof(buf));
      securec_check(rc, "", "");
      /*
       * record the original or converted invalid encoding offset and encoding.
       */
      errInfo->err_offset = err_offset;
      errInfo->dest_encoding = encoding;
      /*
       * repocrd the original error code.
       */
      errInfo->err_code = ERRCODE_CHARACTER_NOT_IN_REPERTOIRE;
      *err_info_list = lappend(*err_info_list, errInfo);
  
      return;
  }
  
  /*
   * add_untranslatable_char: add untranslatable character to current CopyState illegal_chars_error list;
   *
   * note: len is remaining length of string, not length of character;
   * len must be greater than zero, as we always examine the first byte.
   */
  void add_untranslatable_char(
      int src_encoding, int dest_encoding, const char* mbstr, int len, List** err_info_list, int err_offset)
  {
      return;
      int l = pg_encoding_mblen(src_encoding, mbstr);
      char buf[40];
      char* p = buf;
      int j, jlimit;
      int rc = -1;
      int buf_left_size = sizeof(buf);
  
      if (u_sess->mb_cxt.insertValuesBind_compatible_illegal_chars) {
          return;
      }
      Assert(err_info_list);
  
      jlimit = Min(l, len);
      jlimit = Min(jlimit, 8); /* prevent buffer overrun */
  
      for (j = 0; j < jlimit; j++) {
          rc = sprintf_s(p, buf_left_size, "0x%02x", (unsigned char)mbstr[j]);
          securec_check_ss(rc, "\0", "\0");
  
          p += rc;
          buf_left_size -= rc;
  
          if (j < jlimit - 1) {
              rc = sprintf_s(p, buf_left_size, " ");
              securec_check_ss(rc, "\0", "\0");
  
              p += rc;
              buf_left_size -= rc;
          }
      }
  
      /* omit untranslatable character error, report it in log
       * just works for local ->utf8 encoding translation.
       */
      if (u_sess->attr.attr_common.omit_encoding_error && (PG_UTF8 == dest_encoding)) {
          ereport(LOG,
              (errcode(ERRCODE_UNTRANSLATABLE_CHARACTER),
                  errmsg("character with byte sequence %s in encoding \"%s\" has no equivalent in encoding \"%s\"",
                      buf,
                      pg_enc2name_tbl[src_encoding].name,
                      pg_enc2name_tbl[dest_encoding].name)));
      }
  
      IllegalCharErrInfo* errInfo = (IllegalCharErrInfo*)palloc0(sizeof(IllegalCharErrInfo));
      errInfo->err_info = (char*)palloc0(sizeof(buf));
  
      /*
       * record the original invalid encoding info.
       */
      rc = memcpy_s(errInfo->err_info, sizeof(buf), buf, sizeof(buf));
      securec_check(rc, "", "");
      /*
       * record the original or converted invalid encoding position and encodings.
       */
      errInfo->err_offset = err_offset;
      errInfo->src_encoding = src_encoding;
      errInfo->dest_encoding = dest_encoding;
      /*
       * repocrd the original error code.
       */
      errInfo->err_code = ERRCODE_UNTRANSLATABLE_CHARACTER;
      *err_info_list = lappend(*err_info_list, errInfo);
  
      return;
  }
  
  #endif /* !FRONTEND */
  