/src/tmux/utf8-combined.c

Source
/* $OpenBSD$ */

/*
 * 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);
}

/* 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))
    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 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: 2025-11-19 06:37

Line	Count	Source
1		/* $OpenBSD$ */
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	6.35k	{
53	6.35k	if (ud->size < 3)
54	3.47k	return (0);
55	2.88k	return (memcmp(ud->data + ud->size - 3, "\342\200\215", 3) == 0);
56	6.35k	}
57
58		/* Is this zero width joiner U+200D? */
59		int
60		utf8_is_zwj(const struct utf8_data *ud)
61	20.7k	{
62	20.7k	if (ud->size != 3)
63	14.7k	return (0);
64	5.95k	return (memcmp(ud->data, "\342\200\215", 3) == 0);
65	20.7k	}
66
67		/* Is this variation selector U+FE0F? */
68		int
69		utf8_is_vs(const struct utf8_data *ud)
70	20.7k	{
71	20.7k	if (ud->size != 3)
72	14.7k	return (0);
73	5.95k	return (memcmp(ud->data, "\357\270\217", 3) == 0);
74	20.7k	}
75
76		/* Is this Hangul filler U+3164? */
77		int
78		utf8_is_hangul_filler(const struct utf8_data *ud)
79	20.7k	{
80	20.7k	if (ud->size != 3)
81	14.7k	return (0);
82	5.95k	return (memcmp(ud->data, "\343\205\244", 3) == 0);
83	20.7k	}
84
85		/* Should these two characters combine? */
86		int
87		utf8_should_combine(const struct utf8_data with, const struct utf8_data add)
88	6.35k	{
89	6.35k	wchar_t w, a;
90
91	6.35k	if (utf8_towc(with, &w) != UTF8_DONE)
92	2.88k	return (0);
93	3.47k	if (utf8_towc(add, &a) != UTF8_DONE)
94	2.04k	return (0);
95
96		/* Regional indicators. */
97	1.42k	if ((a >= 0x1F1E6 && a <= 0x1F1FF) && (w >= 0x1F1E6 && w <= 0x1F1FF))
98	0	return (1);
99
100		/* Emoji skin tone modifiers. */
101	1.42k	switch (a) {
102	0	case 0x1F44B:
103	0	case 0x1F44C:
104	0	case 0x1F44D:
105	0	case 0x1F44E:
106	0	case 0x1F44F:
107	0	case 0x1F450:
108	0	case 0x1F466:
109	0	case 0x1F467:
110	0	case 0x1F468:
111	0	case 0x1F469:
112	0	case 0x1F46E:
113	0	case 0x1F470:
114	0	case 0x1F471:
115	0	case 0x1F472:
116	0	case 0x1F473:
117	0	case 0x1F474:
118	0	case 0x1F475:
119	0	case 0x1F476:
120	0	case 0x1F477:
121	0	case 0x1F478:
122	0	case 0x1F47C:
123	0	case 0x1F481:
124	0	case 0x1F482:
125	0	case 0x1F485:
126	0	case 0x1F486:
127	0	case 0x1F487:
128	0	case 0x1F4AA:
129	0	case 0x1F575:
130	0	case 0x1F57A:
131	0	case 0x1F590:
132	0	case 0x1F595:
133	0	case 0x1F596:
134	0	case 0x1F645:
135	0	case 0x1F646:
136	0	case 0x1F647:
137	0	case 0x1F64B:
138	0	case 0x1F64C:
139	0	case 0x1F64D:
140	0	case 0x1F64E:
141	0	case 0x1F64F:
142	0	case 0x1F6B4:
143	0	case 0x1F6B5:
144	0	case 0x1F6B6:
145	0	case 0x1F926:
146	0	case 0x1F937:
147	0	case 0x1F938:
148	0	case 0x1F939:
149	0	case 0x1F93D:
150	0	case 0x1F93E:
151	0	case 0x1F9B5:
152	0	case 0x1F9B6:
153	0	case 0x1F9B8:
154	0	case 0x1F9B9:
155	0	case 0x1F9CD:
156	0	case 0x1F9CE:
157	0	case 0x1F9CF:
158	0	case 0x1F9D1:
159	0	case 0x1F9D2:
160	0	case 0x1F9D3:
161	0	case 0x1F9D4:
162	0	case 0x1F9D5:
163	0	case 0x1F9D6:
164	0	case 0x1F9D7:
165	0	case 0x1F9D8:
166	0	case 0x1F9D9:
167	0	case 0x1F9DA:
168	0	case 0x1F9DB:
169	0	case 0x1F9DC:
170	0	case 0x1F9DD:
171	0	case 0x1F9DE:
172	0	case 0x1F9DF:
173	0	if (w >= 0x1F3FB && w <= 0x1F3FF)
174	0	return (1);
175	0	break;
176	1.42k	}
177	1.42k	return 0;
178	1.42k	}
179
180		static enum hanguljamo_subclass
181		hanguljamo_get_subclass(const u_char *s)
182	4.87k	{
183	4.87k	switch (s[0]) {
184	0	case 0xE1:
185	0	switch (s[1]) {
186	0	case 0x84:
187	0	if (s[2] >= 0x80 && s[2] <= 0x92)
188	0	return (HANGULJAMO_SUBCLASS_CHOSEONG);
189	0	if (s[2] >= 0x93 && s[2] <= 0xBF)
190	0	return (HANGULJAMO_SUBCLASS_OLD_CHOSEONG);
191	0	break;
192	0	case 0x85:
193	0	if (s[2] == 0x9F)
194	0	return (HANGULJAMO_SUBCLASS_CHOSEONG_FILLER);
195	0	if (s[2] == 0xA0)
196	0	return (HANGULJAMO_SUBCLASS_JUNGSEONG_FILLER);
197	0	if (s[2] >= 0x80 && s[2] <= 0x9E)
198	0	return (HANGULJAMO_SUBCLASS_OLD_CHOSEONG);
199	0	if (s[2] >= 0xA1 && s[2] <= 0xB5)
200	0	return (HANGULJAMO_SUBCLASS_JUNGSEONG);
201	0	if (s[2] >= 0xB6 && s[2] <= 0xBF)
202	0	return (HANGULJAMO_SUBCLASS_OLD_JUNGSEONG);
203	0	break;
204	0	case 0x86:
205	0	if (s[2] >= 0x80 && s[2] <= 0xA7)
206	0	return (HANGULJAMO_SUBCLASS_OLD_JUNGSEONG);
207	0	if (s[2] >= 0xA8 && s[2] <= 0xBF)
208	0	return (HANGULJAMO_SUBCLASS_JONGSEONG);
209	0	break;
210	0	case 0x87:
211	0	if (s[2] >= 0x80 && s[2] <= 0x82)
212	0	return (HANGULJAMO_SUBCLASS_JONGSEONG);
213	0	if (s[2] >= 0x83 && s[2] <= 0xBF)
214	0	return (HANGULJAMO_SUBCLASS_OLD_JONGSEONG);
215	0	break;
216	0	}
217	0	break;
218	0	case 0xEA:
219	0	if (s[1] == 0xA5 && s[2] >= 0xA0 && s[2] <= 0xBC)
220	0	return (HANGULJAMO_SUBCLASS_EXTENDED_OLD_CHOSEONG);
221	0	break;
222	0	case 0xED:
223	0	if (s[1] == 0x9E && s[2] >= 0xB0 && s[2] <= 0xBF)
224	0	return (HANGULJAMO_SUBCLASS_EXTENDED_OLD_JUNGSEONG);
225	0	if (s[1] != 0x9F)
226	0	break;
227	0	if (s[2] >= 0x80 && s[2] <= 0x86)
228	0	return (HANGULJAMO_SUBCLASS_EXTENDED_OLD_JUNGSEONG);
229	0	if (s[2] >= 0x8B && s[2] <= 0xBB)
230	0	return (HANGULJAMO_SUBCLASS_EXTENDED_OLD_JONGSEONG);
231	0	break;
232	4.87k	}
233	4.87k	return (HANGULJAMO_SUBCLASS_NOT_HANGULJAMO);
234	4.87k	}
235
236		static enum hanguljamo_class
237		hanguljamo_get_class(const u_char *s)
238	4.87k	{
239	4.87k	switch (hanguljamo_get_subclass(s)) {
240	0	case HANGULJAMO_SUBCLASS_CHOSEONG:
241	0	case HANGULJAMO_SUBCLASS_CHOSEONG_FILLER:
242	0	case HANGULJAMO_SUBCLASS_OLD_CHOSEONG:
243	0	case HANGULJAMO_SUBCLASS_EXTENDED_OLD_CHOSEONG:
244	0	return (HANGULJAMO_CLASS_CHOSEONG);
245	0	case HANGULJAMO_SUBCLASS_JUNGSEONG:
246	0	case HANGULJAMO_SUBCLASS_JUNGSEONG_FILLER:
247	0	case HANGULJAMO_SUBCLASS_OLD_JUNGSEONG:
248	0	case HANGULJAMO_SUBCLASS_EXTENDED_OLD_JUNGSEONG:
249	0	return (HANGULJAMO_CLASS_JUNGSEONG);
250	0	case HANGULJAMO_SUBCLASS_JONGSEONG:
251	0	case HANGULJAMO_SUBCLASS_OLD_JONGSEONG:
252	0	case HANGULJAMO_SUBCLASS_EXTENDED_OLD_JONGSEONG:
253	0	return (HANGULJAMO_CLASS_JONGSEONG);
254	4.87k	case HANGULJAMO_SUBCLASS_NOT_HANGULJAMO:
255	4.87k	return (HANGULJAMO_CLASS_NOT_HANGULJAMO);
256	4.87k	}
257	0	return (HANGULJAMO_CLASS_NOT_HANGULJAMO);
258	4.87k	}
259
260		enum hanguljamo_state
261		hanguljamo_check_state(const struct utf8_data p_ud, const struct utf8_data ud)
262	6.35k	{
263	6.35k	const u_char *s;
264
265	6.35k	if (ud->size != 3)
266	1.48k	return (HANGULJAMO_STATE_NOT_HANGULJAMO);
267
268	4.87k	switch (hanguljamo_get_class(ud->data)) {
269	0	case HANGULJAMO_CLASS_CHOSEONG:
270	0	return (HANGULJAMO_STATE_CHOSEONG);
271	0	case HANGULJAMO_CLASS_JUNGSEONG:
272	0	if (p_ud->size < 3)
273	0	return (HANGULJAMO_STATE_NOT_COMPOSABLE);
274	0	s = p_ud->data + p_ud->size - 3;
275	0	if (hanguljamo_get_class(s) == HANGULJAMO_CLASS_CHOSEONG)
276	0	return (HANGULJAMO_STATE_COMPOSABLE);
277	0	return (HANGULJAMO_STATE_NOT_COMPOSABLE);
278	0	case HANGULJAMO_CLASS_JONGSEONG:
279	0	if (p_ud->size < 3)
280	0	return (HANGULJAMO_STATE_NOT_COMPOSABLE);
281	0	s = p_ud->data + p_ud->size - 3;
282	0	if (hanguljamo_get_class(s) == HANGULJAMO_CLASS_JUNGSEONG)
283	0	return (HANGULJAMO_STATE_COMPOSABLE);
284	0	return (HANGULJAMO_STATE_NOT_COMPOSABLE);
285	4.87k	case HANGULJAMO_CLASS_NOT_HANGULJAMO:
286	4.87k	return (HANGULJAMO_STATE_NOT_HANGULJAMO);
287	4.87k	}
288	0	return (HANGULJAMO_STATE_NOT_HANGULJAMO);
289	4.87k	}