/src/tmux/utf8-combined.c

Source
/* $OpenBSD: utf8-combined.c,v 1.10 2026/06/09 11:49:36 nicm Exp $ */

/*
 * Copyright (c) 2023 Nicholas Marriott <nicholas.marriott@gmail.com>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
 * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/types.h>

#include <stdlib.h>
#include <string.h>
#include <wchar.h>

#include "tmux.h"

enum hanguljamo_subclass {
  HANGULJAMO_SUBCLASS_NOT_HANGULJAMO,
  HANGULJAMO_SUBCLASS_CHOSEONG,     // U+1100 - U+1112
  HANGULJAMO_SUBCLASS_OLD_CHOSEONG,   // U+1113 - U+115E
  HANGULJAMO_SUBCLASS_CHOSEONG_FILLER,    // U+115F
  HANGULJAMO_SUBCLASS_JUNGSEONG_FILLER,   // U+1160
  HANGULJAMO_SUBCLASS_JUNGSEONG,      // U+1161 - U+1175
  HANGULJAMO_SUBCLASS_OLD_JUNGSEONG,    // U+1176 - U+11A7
  HANGULJAMO_SUBCLASS_JONGSEONG,      // U+11A8 - U+11C2
  HANGULJAMO_SUBCLASS_OLD_JONGSEONG,    // U+11C3 - U+11FF
  HANGULJAMO_SUBCLASS_EXTENDED_OLD_CHOSEONG,  // U+A960 - U+A97C
  HANGULJAMO_SUBCLASS_EXTENDED_OLD_JUNGSEONG, // U+D7B0 - U+D7C6
  HANGULJAMO_SUBCLASS_EXTENDED_OLD_JONGSEONG  // U+D7CB - U+D7FB
};

enum hanguljamo_class {
  HANGULJAMO_CLASS_NOT_HANGULJAMO,
  HANGULJAMO_CLASS_CHOSEONG,
  HANGULJAMO_CLASS_JUNGSEONG,
  HANGULJAMO_CLASS_JONGSEONG
};

/* Has this got a zero width joiner at the end? */
int
utf8_has_zwj(const struct utf8_data *ud)
{
  if (ud->size < 3)
    return (0);
  return (memcmp(ud->data + ud->size - 3, "\342\200\215", 3) == 0);
}

/* Is this zero width joiner U+200D? */
int
utf8_is_zwj(const struct utf8_data *ud)
{
  if (ud->size != 3)
    return (0);
  return (memcmp(ud->data, "\342\200\215", 3) == 0);
}

/* Is this variation selector U+FE0F? */
int
utf8_is_vs(const struct utf8_data *ud)
{
  if (ud->size != 3)
    return (0);
  return (memcmp(ud->data, "\357\270\217", 3) == 0);
}

/* Is this Hangul filler U+3164? */
int
utf8_is_hangul_filler(const struct utf8_data *ud)
{
  if (ud->size != 3)
    return (0);
  return (memcmp(ud->data, "\343\205\244", 3) == 0);
}

/* Count regional indicator characters. */
static u_int
utf8_regional_count(const struct utf8_data *ud)
{
  u_int count = 0, i;

  for (i = 0; i + 4 <= ud->size; i++) {
    if (ud->data[i] == 0xf0 &&
        ud->data[i + 1] == 0x9f &&
        ud->data[i + 2] == 0x87 &&
        ud->data[i + 3] >= 0xa6 &&
        ud->data[i + 3] <= 0xbf)
      count++;
  }
  return (count);
}

/* Should these two characters combine? */
int
utf8_should_combine(const struct utf8_data *with, const struct utf8_data *add)
{
  wchar_t w, a;

  if (utf8_towc(with, &w) != UTF8_DONE)
    return (0);
  if (utf8_towc(add, &a) != UTF8_DONE)
    return (0);

  /* Regional indicators. */
  if ((a >= 0x1F1E6 && a <= 0x1F1FF) && (w >= 0x1F1E6 && w <= 0x1F1FF)) {
    if (utf8_regional_count(with) != 1)
      return (0);
    if (utf8_regional_count(add) != 1)
      return (0);
    return (1);
  }

  /* Emoji skin tone modifiers. */
  switch (a) {
  case 0x1F44B:
  case 0x1F44C:
  case 0x1F44D:
  case 0x1F44E:
  case 0x1F44F:
  case 0x1F450:
  case 0x1F466:
  case 0x1F467:
  case 0x1F468:
  case 0x1F469:
  case 0x1F46E:
  case 0x1F470:
  case 0x1F471:
  case 0x1F472:
  case 0x1F473:
  case 0x1F474:
  case 0x1F475:
  case 0x1F476:
  case 0x1F477:
  case 0x1F478:
  case 0x1F47C:
  case 0x1F481:
  case 0x1F482:
  case 0x1F483:
  case 0x1F485:
  case 0x1F486:
  case 0x1F487:
  case 0x1F4AA:
  case 0x1F575:
  case 0x1F57A:
  case 0x1F590:
  case 0x1F595:
  case 0x1F596:
  case 0x1F645:
  case 0x1F646:
  case 0x1F647:
  case 0x1F64B:
  case 0x1F64C:
  case 0x1F64D:
  case 0x1F64E:
  case 0x1F64F:
  case 0x1F6B4:
  case 0x1F6B5:
  case 0x1F6B6:
  case 0x1F926:
  case 0x1F937:
  case 0x1F938:
  case 0x1F939:
  case 0x1F93D:
  case 0x1F93E:
  case 0x1F9B5:
  case 0x1F9B6:
  case 0x1F9B8:
  case 0x1F9B9:
  case 0x1F9CD:
  case 0x1F9CE:
  case 0x1F9CF:
  case 0x1F9D1:
  case 0x1F9D2:
  case 0x1F9D3:
  case 0x1F9D4:
  case 0x1F9D5:
  case 0x1F9D6:
  case 0x1F9D7:
  case 0x1F9D8:
  case 0x1F9D9:
  case 0x1F9DA:
  case 0x1F9DB:
  case 0x1F9DC:
  case 0x1F9DD:
  case 0x1F9DE:
  case 0x1F9DF:
    if (w >= 0x1F3FB && w <= 0x1F3FF)
      return (1);
    break;
  }
  return (0);
}

static enum hanguljamo_subclass
hanguljamo_get_subclass(const u_char *s)
{
  switch (s[0]) {
  case 0xE1:
    switch (s[1]) {
    case 0x84:
      if (s[2] >= 0x80 && s[2] <= 0x92)
        return (HANGULJAMO_SUBCLASS_CHOSEONG);
      if (s[2] >= 0x93 && s[2] <= 0xBF)
        return (HANGULJAMO_SUBCLASS_OLD_CHOSEONG);
      break;
    case 0x85:
      if (s[2] == 0x9F)
        return (HANGULJAMO_SUBCLASS_CHOSEONG_FILLER);
      if (s[2] == 0xA0)
        return (HANGULJAMO_SUBCLASS_JUNGSEONG_FILLER);
      if (s[2] >= 0x80 && s[2] <= 0x9E)
        return (HANGULJAMO_SUBCLASS_OLD_CHOSEONG);
      if (s[2] >= 0xA1 && s[2] <= 0xB5)
        return (HANGULJAMO_SUBCLASS_JUNGSEONG);
      if (s[2] >= 0xB6 && s[2] <= 0xBF)
        return (HANGULJAMO_SUBCLASS_OLD_JUNGSEONG);
      break;
    case 0x86:
      if (s[2] >= 0x80 && s[2] <= 0xA7)
        return (HANGULJAMO_SUBCLASS_OLD_JUNGSEONG);
      if (s[2] >= 0xA8 && s[2] <= 0xBF)
        return (HANGULJAMO_SUBCLASS_JONGSEONG);
      break;
    case 0x87:
      if (s[2] >= 0x80 && s[2] <= 0x82)
        return (HANGULJAMO_SUBCLASS_JONGSEONG);
      if (s[2] >= 0x83 && s[2] <= 0xBF)
        return (HANGULJAMO_SUBCLASS_OLD_JONGSEONG);
      break;
    }
    break;
  case 0xEA:
    if (s[1] == 0xA5 && s[2] >= 0xA0 && s[2] <= 0xBC)
      return (HANGULJAMO_SUBCLASS_EXTENDED_OLD_CHOSEONG);
    break;
  case 0xED:
    if (s[1] == 0x9E && s[2] >= 0xB0 && s[2] <= 0xBF)
      return (HANGULJAMO_SUBCLASS_EXTENDED_OLD_JUNGSEONG);
    if (s[1] != 0x9F)
      break;
    if (s[2] >= 0x80 && s[2] <= 0x86)
      return (HANGULJAMO_SUBCLASS_EXTENDED_OLD_JUNGSEONG);
    if (s[2] >= 0x8B && s[2] <= 0xBB)
      return (HANGULJAMO_SUBCLASS_EXTENDED_OLD_JONGSEONG);
    break;
  }
  return (HANGULJAMO_SUBCLASS_NOT_HANGULJAMO);
}

static enum hanguljamo_class
hanguljamo_get_class(const u_char *s)
{
  switch (hanguljamo_get_subclass(s)) {
  case HANGULJAMO_SUBCLASS_CHOSEONG:
  case HANGULJAMO_SUBCLASS_CHOSEONG_FILLER:
  case HANGULJAMO_SUBCLASS_OLD_CHOSEONG:
  case HANGULJAMO_SUBCLASS_EXTENDED_OLD_CHOSEONG:
    return (HANGULJAMO_CLASS_CHOSEONG);
  case HANGULJAMO_SUBCLASS_JUNGSEONG:
  case HANGULJAMO_SUBCLASS_JUNGSEONG_FILLER:
  case HANGULJAMO_SUBCLASS_OLD_JUNGSEONG:
  case HANGULJAMO_SUBCLASS_EXTENDED_OLD_JUNGSEONG:
    return (HANGULJAMO_CLASS_JUNGSEONG);
  case HANGULJAMO_SUBCLASS_JONGSEONG:
  case HANGULJAMO_SUBCLASS_OLD_JONGSEONG:
  case HANGULJAMO_SUBCLASS_EXTENDED_OLD_JONGSEONG:
    return (HANGULJAMO_CLASS_JONGSEONG);
  case HANGULJAMO_SUBCLASS_NOT_HANGULJAMO:
    return (HANGULJAMO_CLASS_NOT_HANGULJAMO);
  }
  return (HANGULJAMO_CLASS_NOT_HANGULJAMO);
}

enum hanguljamo_state
hanguljamo_check_state(const struct utf8_data *p_ud, const struct utf8_data *ud)
{
  const u_char  *s;

  if (ud->size != 3)
    return (HANGULJAMO_STATE_NOT_HANGULJAMO);

  switch (hanguljamo_get_class(ud->data)) {
  case HANGULJAMO_CLASS_CHOSEONG:
    return (HANGULJAMO_STATE_CHOSEONG);
  case HANGULJAMO_CLASS_JUNGSEONG:
    if (p_ud->size < 3)
      return (HANGULJAMO_STATE_NOT_COMPOSABLE);
    s = p_ud->data + p_ud->size - 3;
    if (hanguljamo_get_class(s) == HANGULJAMO_CLASS_CHOSEONG)
      return (HANGULJAMO_STATE_COMPOSABLE);
    return (HANGULJAMO_STATE_NOT_COMPOSABLE);
  case HANGULJAMO_CLASS_JONGSEONG:
    if (p_ud->size < 3)
      return (HANGULJAMO_STATE_NOT_COMPOSABLE);
    s = p_ud->data + p_ud->size - 3;
    if (hanguljamo_get_class(s) == HANGULJAMO_CLASS_JUNGSEONG)
      return (HANGULJAMO_STATE_COMPOSABLE);
    return (HANGULJAMO_STATE_NOT_COMPOSABLE);
  case HANGULJAMO_CLASS_NOT_HANGULJAMO:
    return (HANGULJAMO_STATE_NOT_HANGULJAMO);
  }
  return (HANGULJAMO_STATE_NOT_HANGULJAMO);
}

Coverage Report

Created: 2026-08-31 06:30

Line	Count	Source
1		/* $OpenBSD: utf8-combined.c,v 1.10 2026/06/09 11:49:36 nicm Exp $ */
2
3		/*
4		* Copyright (c) 2023 Nicholas Marriott <nicholas.marriott@gmail.com>
5		*
6		* Permission to use, copy, modify, and distribute this software for any
7		* purpose with or without fee is hereby granted, provided that the above
8		* copyright notice and this permission notice appear in all copies.
9		*
10		* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11		* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12		* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13		* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14		* WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
15		* IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
16		* OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17		*/
18
19		#include <sys/types.h>
20
21		#include <stdlib.h>
22		#include <string.h>
23		#include <wchar.h>
24
25		#include "tmux.h"
26
27		enum hanguljamo_subclass {
28		HANGULJAMO_SUBCLASS_NOT_HANGULJAMO,
29		HANGULJAMO_SUBCLASS_CHOSEONG, // U+1100 - U+1112
30		HANGULJAMO_SUBCLASS_OLD_CHOSEONG, // U+1113 - U+115E
31		HANGULJAMO_SUBCLASS_CHOSEONG_FILLER, // U+115F
32		HANGULJAMO_SUBCLASS_JUNGSEONG_FILLER, // U+1160
33		HANGULJAMO_SUBCLASS_JUNGSEONG, // U+1161 - U+1175
34		HANGULJAMO_SUBCLASS_OLD_JUNGSEONG, // U+1176 - U+11A7
35		HANGULJAMO_SUBCLASS_JONGSEONG, // U+11A8 - U+11C2
36		HANGULJAMO_SUBCLASS_OLD_JONGSEONG, // U+11C3 - U+11FF
37		HANGULJAMO_SUBCLASS_EXTENDED_OLD_CHOSEONG, // U+A960 - U+A97C
38		HANGULJAMO_SUBCLASS_EXTENDED_OLD_JUNGSEONG, // U+D7B0 - U+D7C6
39		HANGULJAMO_SUBCLASS_EXTENDED_OLD_JONGSEONG // U+D7CB - U+D7FB
40		};
41
42		enum hanguljamo_class {
43		HANGULJAMO_CLASS_NOT_HANGULJAMO,
44		HANGULJAMO_CLASS_CHOSEONG,
45		HANGULJAMO_CLASS_JUNGSEONG,
46		HANGULJAMO_CLASS_JONGSEONG
47		};
48
49		/* Has this got a zero width joiner at the end? */
50		int
51		utf8_has_zwj(const struct utf8_data *ud)
52	0	{
53	0	if (ud->size < 3)
54	0	return (0);
55	0	return (memcmp(ud->data + ud->size - 3, "\342\200\215", 3) == 0);
56	0	}
57
58		/* Is this zero width joiner U+200D? */
59		int
60		utf8_is_zwj(const struct utf8_data *ud)
61	0	{
62	0	if (ud->size != 3)
63	0	return (0);
64	0	return (memcmp(ud->data, "\342\200\215", 3) == 0);
65	0	}
66
67		/* Is this variation selector U+FE0F? */
68		int
69		utf8_is_vs(const struct utf8_data *ud)
70	0	{
71	0	if (ud->size != 3)
72	0	return (0);
73	0	return (memcmp(ud->data, "\357\270\217", 3) == 0);
74	0	}
75
76		/* Is this Hangul filler U+3164? */
77		int
78		utf8_is_hangul_filler(const struct utf8_data *ud)
79	0	{
80	0	if (ud->size != 3)
81	0	return (0);
82	0	return (memcmp(ud->data, "\343\205\244", 3) == 0);
83	0	}
84
85		/* Count regional indicator characters. */
86		static u_int
87		utf8_regional_count(const struct utf8_data *ud)
88	0	{
89	0	u_int count = 0, i;
90
91	0	for (i = 0; i + 4 <= ud->size; i++) {
92	0	if (ud->data[i] == 0xf0 &&
93	0	ud->data[i + 1] == 0x9f &&
94	0	ud->data[i + 2] == 0x87 &&
95	0	ud->data[i + 3] >= 0xa6 &&
96	0	ud->data[i + 3] <= 0xbf)
97	0	count++;
98	0	}
99	0	return (count);
100	0	}
101
102		/* Should these two characters combine? */
103		int
104		utf8_should_combine(const struct utf8_data with, const struct utf8_data add)
105	0	{
106	0	wchar_t w, a;
107
108	0	if (utf8_towc(with, &w) != UTF8_DONE)
109	0	return (0);
110	0	if (utf8_towc(add, &a) != UTF8_DONE)
111	0	return (0);
112
113		/* Regional indicators. */
114	0	if ((a >= 0x1F1E6 && a <= 0x1F1FF) && (w >= 0x1F1E6 && w <= 0x1F1FF)) {
115	0	if (utf8_regional_count(with) != 1)
116	0	return (0);
117	0	if (utf8_regional_count(add) != 1)
118	0	return (0);
119	0	return (1);
120	0	}
121
122		/* Emoji skin tone modifiers. */
123	0	switch (a) {
124	0	case 0x1F44B:
125	0	case 0x1F44C:
126	0	case 0x1F44D:
127	0	case 0x1F44E:
128	0	case 0x1F44F:
129	0	case 0x1F450:
130	0	case 0x1F466:
131	0	case 0x1F467:
132	0	case 0x1F468:
133	0	case 0x1F469:
134	0	case 0x1F46E:
135	0	case 0x1F470:
136	0	case 0x1F471:
137	0	case 0x1F472:
138	0	case 0x1F473:
139	0	case 0x1F474:
140	0	case 0x1F475:
141	0	case 0x1F476:
142	0	case 0x1F477:
143	0	case 0x1F478:
144	0	case 0x1F47C:
145	0	case 0x1F481:
146	0	case 0x1F482:
147	0	case 0x1F483:
148	0	case 0x1F485:
149	0	case 0x1F486:
150	0	case 0x1F487:
151	0	case 0x1F4AA:
152	0	case 0x1F575:
153	0	case 0x1F57A:
154	0	case 0x1F590:
155	0	case 0x1F595:
156	0	case 0x1F596:
157	0	case 0x1F645:
158	0	case 0x1F646:
159	0	case 0x1F647:
160	0	case 0x1F64B:
161	0	case 0x1F64C:
162	0	case 0x1F64D:
163	0	case 0x1F64E:
164	0	case 0x1F64F:
165	0	case 0x1F6B4:
166	0	case 0x1F6B5:
167	0	case 0x1F6B6:
168	0	case 0x1F926:
169	0	case 0x1F937:
170	0	case 0x1F938:
171	0	case 0x1F939:
172	0	case 0x1F93D:
173	0	case 0x1F93E:
174	0	case 0x1F9B5:
175	0	case 0x1F9B6:
176	0	case 0x1F9B8:
177	0	case 0x1F9B9:
178	0	case 0x1F9CD:
179	0	case 0x1F9CE:
180	0	case 0x1F9CF:
181	0	case 0x1F9D1:
182	0	case 0x1F9D2:
183	0	case 0x1F9D3:
184	0	case 0x1F9D4:
185	0	case 0x1F9D5:
186	0	case 0x1F9D6:
187	0	case 0x1F9D7:
188	0	case 0x1F9D8:
189	0	case 0x1F9D9:
190	0	case 0x1F9DA:
191	0	case 0x1F9DB:
192	0	case 0x1F9DC:
193	0	case 0x1F9DD:
194	0	case 0x1F9DE:
195	0	case 0x1F9DF:
196	0	if (w >= 0x1F3FB && w <= 0x1F3FF)
197	0	return (1);
198	0	break;
199	0	}
200	0	return (0);
201	0	}
202
203		static enum hanguljamo_subclass
204		hanguljamo_get_subclass(const u_char *s)
205	0	{
206	0	switch (s[0]) {
207	0	case 0xE1:
208	0	switch (s[1]) {
209	0	case 0x84:
210	0	if (s[2] >= 0x80 && s[2] <= 0x92)
211	0	return (HANGULJAMO_SUBCLASS_CHOSEONG);
212	0	if (s[2] >= 0x93 && s[2] <= 0xBF)
213	0	return (HANGULJAMO_SUBCLASS_OLD_CHOSEONG);
214	0	break;
215	0	case 0x85:
216	0	if (s[2] == 0x9F)
217	0	return (HANGULJAMO_SUBCLASS_CHOSEONG_FILLER);
218	0	if (s[2] == 0xA0)
219	0	return (HANGULJAMO_SUBCLASS_JUNGSEONG_FILLER);
220	0	if (s[2] >= 0x80 && s[2] <= 0x9E)
221	0	return (HANGULJAMO_SUBCLASS_OLD_CHOSEONG);
222	0	if (s[2] >= 0xA1 && s[2] <= 0xB5)
223	0	return (HANGULJAMO_SUBCLASS_JUNGSEONG);
224	0	if (s[2] >= 0xB6 && s[2] <= 0xBF)
225	0	return (HANGULJAMO_SUBCLASS_OLD_JUNGSEONG);
226	0	break;
227	0	case 0x86:
228	0	if (s[2] >= 0x80 && s[2] <= 0xA7)
229	0	return (HANGULJAMO_SUBCLASS_OLD_JUNGSEONG);
230	0	if (s[2] >= 0xA8 && s[2] <= 0xBF)
231	0	return (HANGULJAMO_SUBCLASS_JONGSEONG);
232	0	break;
233	0	case 0x87:
234	0	if (s[2] >= 0x80 && s[2] <= 0x82)
235	0	return (HANGULJAMO_SUBCLASS_JONGSEONG);
236	0	if (s[2] >= 0x83 && s[2] <= 0xBF)
237	0	return (HANGULJAMO_SUBCLASS_OLD_JONGSEONG);
238	0	break;
239	0	}
240	0	break;
241	0	case 0xEA:
242	0	if (s[1] == 0xA5 && s[2] >= 0xA0 && s[2] <= 0xBC)
243	0	return (HANGULJAMO_SUBCLASS_EXTENDED_OLD_CHOSEONG);
244	0	break;
245	0	case 0xED:
246	0	if (s[1] == 0x9E && s[2] >= 0xB0 && s[2] <= 0xBF)
247	0	return (HANGULJAMO_SUBCLASS_EXTENDED_OLD_JUNGSEONG);
248	0	if (s[1] != 0x9F)
249	0	break;
250	0	if (s[2] >= 0x80 && s[2] <= 0x86)
251	0	return (HANGULJAMO_SUBCLASS_EXTENDED_OLD_JUNGSEONG);
252	0	if (s[2] >= 0x8B && s[2] <= 0xBB)
253	0	return (HANGULJAMO_SUBCLASS_EXTENDED_OLD_JONGSEONG);
254	0	break;
255	0	}
256	0	return (HANGULJAMO_SUBCLASS_NOT_HANGULJAMO);
257	0	}
258
259		static enum hanguljamo_class
260		hanguljamo_get_class(const u_char *s)
261	0	{
262	0	switch (hanguljamo_get_subclass(s)) {
263	0	case HANGULJAMO_SUBCLASS_CHOSEONG:
264	0	case HANGULJAMO_SUBCLASS_CHOSEONG_FILLER:
265	0	case HANGULJAMO_SUBCLASS_OLD_CHOSEONG:
266	0	case HANGULJAMO_SUBCLASS_EXTENDED_OLD_CHOSEONG:
267	0	return (HANGULJAMO_CLASS_CHOSEONG);
268	0	case HANGULJAMO_SUBCLASS_JUNGSEONG:
269	0	case HANGULJAMO_SUBCLASS_JUNGSEONG_FILLER:
270	0	case HANGULJAMO_SUBCLASS_OLD_JUNGSEONG:
271	0	case HANGULJAMO_SUBCLASS_EXTENDED_OLD_JUNGSEONG:
272	0	return (HANGULJAMO_CLASS_JUNGSEONG);
273	0	case HANGULJAMO_SUBCLASS_JONGSEONG:
274	0	case HANGULJAMO_SUBCLASS_OLD_JONGSEONG:
275	0	case HANGULJAMO_SUBCLASS_EXTENDED_OLD_JONGSEONG:
276	0	return (HANGULJAMO_CLASS_JONGSEONG);
277	0	case HANGULJAMO_SUBCLASS_NOT_HANGULJAMO:
278	0	return (HANGULJAMO_CLASS_NOT_HANGULJAMO);
279	0	}
280	0	return (HANGULJAMO_CLASS_NOT_HANGULJAMO);
281	0	}
282
283		enum hanguljamo_state
284		hanguljamo_check_state(const struct utf8_data p_ud, const struct utf8_data ud)
285	0	{
286	0	const u_char *s;
287
288	0	if (ud->size != 3)
289	0	return (HANGULJAMO_STATE_NOT_HANGULJAMO);
290
291	0	switch (hanguljamo_get_class(ud->data)) {
292	0	case HANGULJAMO_CLASS_CHOSEONG:
293	0	return (HANGULJAMO_STATE_CHOSEONG);
294	0	case HANGULJAMO_CLASS_JUNGSEONG:
295	0	if (p_ud->size < 3)
296	0	return (HANGULJAMO_STATE_NOT_COMPOSABLE);
297	0	s = p_ud->data + p_ud->size - 3;
298	0	if (hanguljamo_get_class(s) == HANGULJAMO_CLASS_CHOSEONG)
299	0	return (HANGULJAMO_STATE_COMPOSABLE);
300	0	return (HANGULJAMO_STATE_NOT_COMPOSABLE);
301	0	case HANGULJAMO_CLASS_JONGSEONG:
302	0	if (p_ud->size < 3)
303	0	return (HANGULJAMO_STATE_NOT_COMPOSABLE);
304	0	s = p_ud->data + p_ud->size - 3;
305	0	if (hanguljamo_get_class(s) == HANGULJAMO_CLASS_JUNGSEONG)
306	0	return (HANGULJAMO_STATE_COMPOSABLE);
307	0	return (HANGULJAMO_STATE_NOT_COMPOSABLE);
308	0	case HANGULJAMO_CLASS_NOT_HANGULJAMO:
309	0	return (HANGULJAMO_STATE_NOT_HANGULJAMO);
310	0	}
311	0	return (HANGULJAMO_STATE_NOT_HANGULJAMO);
312	0	}