/src/w3m/libwc/uhc.c

Source (jump to first uncovered line)

#include "wc.h"
#include "uhc.h"
#include "wtf.h"
#ifdef USE_UNICODE
#include "ucs.h"
#endif

#define C0 WC_UHC_MAP_C0
#define GL WC_UHC_MAP_GL
#define C1 WC_UHC_MAP_C1
#define LB WC_UHC_MAP_LB
#define UB WC_UHC_MAP_UB

wc_uint8 WC_UHC_MAP[ 0x100 ] = {
    C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0,
    C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0,
    GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL,
    GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL,
    GL, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB,
    LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, GL, GL, GL, GL, GL,
    GL, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB,
    LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, GL, GL, GL, GL, C0,

    C1, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB,
    UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB,
    UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB,
    UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB,
    UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB,
    UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB,
    UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB,
    UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, C1,
};

wc_wchar_t
wc_uhc_to_cs128w(wc_wchar_t cc)
{
    cc.code = WC_UHC_N(cc.code);
    if (cc.code < 0x4000)
  cc.ccs = WC_CCS_UHC_1;
    else {
  cc.ccs = WC_CCS_UHC_2;
  cc.code -= 0x4000;
    }
    cc.code = WC_N_CS128W(cc.code);
    return cc;
}

wc_wchar_t
wc_cs128w_to_uhc(wc_wchar_t cc)
{
    cc.code = WC_CS128W_N(cc.code);
    if (cc.ccs == WC_CCS_UHC_2)
  cc.code += 0x4000;
    cc.ccs = WC_CCS_UHC;
    cc.code = WC_N_UHC(cc.code);
    return cc;
}

wc_uint32
wc_uhc_to_N(wc_uint32 c)
{
    if (c <= 0xA1A0)  /* 0x8141 - 0xA1A0 */
  return WC_UHC_N(c);
    if (c <= 0xA2A0)  /* 0xA240 - 0xA2A0 */
  return WC_UHC_N(c) - 0x5E;
    if (c <= 0xA2E7)  /* 0xA2E6 - 0xA2E7 */
  return WC_UHC_N(0xA2A0) - 0x5E + c - 0xA2E5;
      /* 0xA340 - 0xFEA0 */
    return WC_UHC_N(c) - ((c >> 8) - 0xA1) * 0x5E + 2;
}

Str
wc_conv_from_uhc(Str is, wc_ces ces)
{
    Str os;
    wc_uchar *sp = (wc_uchar *)is->ptr;
    wc_uchar *ep = sp + is->length;
    wc_uchar *p;
    int state = WC_UHC_NOSTATE;
    wc_uint32 uhc;

    for (p = sp; p < ep && *p < 0x80; p++) 
  ;
    if (p == ep)
  return is;
    os = Strnew_size(is->length);
    if (p > sp)
  Strcat_charp_n(os, (char *)is->ptr, (int)(p - sp));

    for (; p < ep; p++) {
  switch (state) {
  case WC_UHC_NOSTATE:
      switch (WC_UHC_MAP[*p]) {
      case UB:
    state = WC_UHC_MBYTE1;
    break;
      case C1:
    wtf_push_unknown(os, p, 1);
    break;
      default:
    Strcat_char(os, (char)*p);
    break;
      }
      break;
  case WC_UHC_MBYTE1:
      if (WC_UHC_MAP[*p] & LB) {
    uhc = ((wc_uint32)*(p-1) << 8) | *p;
    if (*(p-1) >= 0xA1 && *p >= 0xA1 &&
        uhc != 0xA2E6 && uhc != 0xA2E7)
        wtf_push(os, WC_CCS_KS_X_1001, uhc);
    else
        wtf_push(os, WC_CCS_UHC, uhc);
      } else
    wtf_push_unknown(os, p-1, 2);
      state = WC_UHC_NOSTATE;
      break;
  }
    }
    switch (state) {
    case WC_UHC_MBYTE1:
  wtf_push_unknown(os, p-1, 1);
  break;
    }
    return os;
}

void
wc_push_to_uhc(Str os, wc_wchar_t cc, wc_status *st)
{
  while (1) {
    switch (cc.ccs) {
    case WC_CCS_US_ASCII:
  Strcat_char(os, (char)cc.code);
  return;
    case WC_CCS_KS_X_1001:
  Strcat_char(os, (char)((cc.code >> 8) | 0x80));
  Strcat_char(os, (char)((cc.code & 0xff) | 0x80));
  return;
    case WC_CCS_UHC_1:
    case WC_CCS_UHC_2:
  cc = wc_cs128w_to_uhc(cc);
    case WC_CCS_UHC:
  Strcat_char(os, (char)(cc.code >> 8));
  Strcat_char(os, (char)(cc.code & 0xff));
  return;
    case WC_CCS_UNKNOWN_W:
  if (!WcOption.no_replace)
      Strcat_charp(os, WC_REPLACE_W);
  return;
    case WC_CCS_UNKNOWN:
  if (!WcOption.no_replace)
      Strcat_charp(os, WC_REPLACE);
  return;
    default:
#ifdef USE_UNICODE
  if (WcOption.ucs_conv)
      cc = wc_any_to_any_ces(cc, st);
  else
#endif
      cc.ccs = WC_CCS_IS_WIDE(cc.ccs) ? WC_CCS_UNKNOWN_W : WC_CCS_UNKNOWN;
  continue;
    }
  }
}

Str
wc_char_conv_from_uhc(wc_uchar c, wc_status *st)
{
    static Str os;
    static wc_uchar uhcu;
    wc_uint32 uhc;

    if (st->state == -1) {
  st->state = WC_UHC_NOSTATE;
  os = Strnew_size(8);
    }

    switch (st->state) {
    case WC_UHC_NOSTATE:
  switch (WC_UHC_MAP[c]) {
  case UB:
      uhcu = c;
      st->state = WC_UHC_MBYTE1;
      return NULL;
  case C1:
      break;
  default:
      Strcat_char(os, (char)c);
      break;
  }
  break;
    case WC_UHC_MBYTE1:
  if (WC_UHC_MAP[c] & LB) {
      uhc = ((wc_uint32)uhcu << 8) | c;
      if (uhcu >= 0xA1 && c >= 0xA1 &&
    uhc != 0xA2E6 && uhc != 0xA2E7)
    wtf_push(os, WC_CCS_KS_X_1001, uhc);
      else
    wtf_push(os, WC_CCS_UHC, uhc);
  }
  break;
    }
    st->state = -1;
    return os;
}

Coverage Report

Created: 2025-04-11 06:33

Line	Count	Source (jump to first uncovered line)
1
2		#include "wc.h"
3		#include "uhc.h"
4		#include "wtf.h"
5		#ifdef USE_UNICODE
6		#include "ucs.h"
7		#endif
8
9		#define C0 WC_UHC_MAP_C0
10		#define GL WC_UHC_MAP_GL
11	65.3k	#define C1 WC_UHC_MAP_C1
12	82.1k	#define LB WC_UHC_MAP_LB
13	82.1k	#define UB WC_UHC_MAP_UB
14
15		wc_uint8 WC_UHC_MAP[ 0x100 ] = {
16		C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0,
17		C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0, C0,
18		GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL,
19		GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL, GL,
20		GL, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB,
21		LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, GL, GL, GL, GL, GL,
22		GL, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB,
23		LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, LB, GL, GL, GL, GL, C0,
24
25		C1, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB,
26		UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB,
27		UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB,
28		UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB,
29		UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB,
30		UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB,
31		UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB,
32		UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, UB, C1,
33		};
34
35		wc_wchar_t
36		wc_uhc_to_cs128w(wc_wchar_t cc)
37	313k	{
38	313k	cc.code = WC_UHC_N(cc.code);
39	313k	if (cc.code < 0x4000)
40	308k	cc.ccs = WC_CCS_UHC_1;
41	5.45k	else {
42	5.45k	cc.ccs = WC_CCS_UHC_2;
43	5.45k	cc.code -= 0x4000;
44	5.45k	}
45	313k	cc.code = WC_N_CS128W(cc.code);
46	313k	return cc;
47	313k	}
48
49		wc_wchar_t
50		wc_cs128w_to_uhc(wc_wchar_t cc)
51	313k	{
52	313k	cc.code = WC_CS128W_N(cc.code);
53	313k	if (cc.ccs == WC_CCS_UHC_2)
54	5.45k	cc.code += 0x4000;
55	313k	cc.ccs = WC_CCS_UHC;
56	313k	cc.code = WC_N_UHC(cc.code);
57	313k	return cc;
58	313k	}
59
60		wc_uint32
61		wc_uhc_to_N(wc_uint32 c)
62	4.75k	{
63	4.75k	if (c <= 0xA1A0) /* 0x8141 - 0xA1A0 */
64	2.85k	return WC_UHC_N(c);
65	1.90k	if (c <= 0xA2A0) /* 0xA240 - 0xA2A0 */
66	432	return WC_UHC_N(c) - 0x5E;
67	1.47k	if (c <= 0xA2E7) /* 0xA2E6 - 0xA2E7 */
68	687	return WC_UHC_N(0xA2A0) - 0x5E + c - 0xA2E5;
69		/* 0xA340 - 0xFEA0 */
70	784	return WC_UHC_N(c) - ((c >> 8) - 0xA1) * 0x5E + 2;
71	1.47k	}
72
73		Str
74		wc_conv_from_uhc(Str is, wc_ces ces)
75	260	{
76	260	Str os;
77	260	wc_uchar sp = (wc_uchar )is->ptr;
78	260	wc_uchar *ep = sp + is->length;
79	260	wc_uchar *p;
80	260	int state = WC_UHC_NOSTATE;
81	260	wc_uint32 uhc;
82
83	511	for (p = sp; p < ep && *p < 0x80; p++)
84	251	;
85	260	if (p == ep)
86	12	return is;
87	248	os = Strnew_size(is->length);
88	248	if (p > sp)
89	19	Strcat_charp_n(os, (char *)is->ptr, (int)(p - sp));
90
91	292k	for (; p < ep; p++) {
92	291k	switch (state) {
93	209k	case WC_UHC_NOSTATE:
94	209k	switch (WC_UHC_MAP[*p]) {
95	82.1k	case UB:
96	82.1k	state = WC_UHC_MBYTE1;
97	82.1k	break;
98	65.3k	case C1:
99	65.3k	wtf_push_unknown(os, p, 1);
100	65.3k	break;
101	62.1k	default:
102	62.1k	Strcat_char(os, (char)*p);
103	62.1k	break;
104	209k	}
105	209k	break;
106	209k	case WC_UHC_MBYTE1:
107	82.1k	if (WC_UHC_MAP[*p] & LB) {
108	34.1k	uhc = ((wc_uint32)(p-1) << 8) \| p;
109	34.1k	if ((p-1) >= 0xA1 && p >= 0xA1 &&
110	34.1k	uhc != 0xA2E6 && uhc != 0xA2E7)
111	9.25k	wtf_push(os, WC_CCS_KS_X_1001, uhc);
112	24.8k	else
113	24.8k	wtf_push(os, WC_CCS_UHC, uhc);
114	34.1k	} else
115	48.0k	wtf_push_unknown(os, p-1, 2);
116	82.1k	state = WC_UHC_NOSTATE;
117	82.1k	break;
118	291k	}
119	291k	}
120	248	switch (state) {
121	20	case WC_UHC_MBYTE1:
122	20	wtf_push_unknown(os, p-1, 1);
123	20	break;
124	248	}
125	248	return os;
126	248	}
127
128		void
129		wc_push_to_uhc(Str os, wc_wchar_t cc, wc_status *st)
130	8.58M	{
131	15.6M	while (1) {
132	15.6M	switch (cc.ccs) {
133	4.50M	case WC_CCS_US_ASCII:
134	4.50M	Strcat_char(os, (char)cc.code);
135	4.50M	return;
136	1.26M	case WC_CCS_KS_X_1001:
137	1.26M	Strcat_char(os, (char)((cc.code >> 8) \| 0x80));
138	1.26M	Strcat_char(os, (char)((cc.code & 0xff) \| 0x80));
139	1.26M	return;
140	289k	case WC_CCS_UHC_1:
141	289k	case WC_CCS_UHC_2:
142	289k	cc = wc_cs128w_to_uhc(cc);
143	308k	case WC_CCS_UHC:
144	308k	Strcat_char(os, (char)(cc.code >> 8));
145	308k	Strcat_char(os, (char)(cc.code & 0xff));
146	308k	return;
147	982k	case WC_CCS_UNKNOWN_W:
148	982k	if (!WcOption.no_replace)
149	982k	Strcat_charp(os, WC_REPLACE_W);
150	982k	return;
151	1.52M	case WC_CCS_UNKNOWN:
152	1.52M	if (!WcOption.no_replace)
153	1.52M	Strcat_charp(os, WC_REPLACE);
154	1.52M	return;
155	7.08M	default:
156	7.08M	#ifdef USE_UNICODE
157	7.08M	if (WcOption.ucs_conv)
158	7.08M	cc = wc_any_to_any_ces(cc, st);
159	0	else
160	0	#endif
161	0	cc.ccs = WC_CCS_IS_WIDE(cc.ccs) ? WC_CCS_UNKNOWN_W : WC_CCS_UNKNOWN;
162	7.08M	continue;
163	15.6M	}
164	15.6M	}
165	8.58M	}
166
167		Str
168		wc_char_conv_from_uhc(wc_uchar c, wc_status *st)
169	0	{
170	0	static Str os;
171	0	static wc_uchar uhcu;
172	0	wc_uint32 uhc;
173
174	0	if (st->state == -1) {
175	0	st->state = WC_UHC_NOSTATE;
176	0	os = Strnew_size(8);
177	0	}
178
179	0	switch (st->state) {
180	0	case WC_UHC_NOSTATE:
181	0	switch (WC_UHC_MAP[c]) {
182	0	case UB:
183	0	uhcu = c;
184	0	st->state = WC_UHC_MBYTE1;
185	0	return NULL;
186	0	case C1:
187	0	break;
188	0	default:
189	0	Strcat_char(os, (char)c);
190	0	break;
191	0	}
192	0	break;
193	0	case WC_UHC_MBYTE1:
194	0	if (WC_UHC_MAP[c] & LB) {
195	0	uhc = ((wc_uint32)uhcu << 8) \| c;
196	0	if (uhcu >= 0xA1 && c >= 0xA1 &&
197	0	uhc != 0xA2E6 && uhc != 0xA2E7)
198	0	wtf_push(os, WC_CCS_KS_X_1001, uhc);
199	0	else
200	0	wtf_push(os, WC_CCS_UHC, uhc);
201	0	}
202	0	break;
203	0	}
204	0	st->state = -1;
205	0	return os;
206	0	}