/src/w3m/libwc/hz.c

Source

#include "wc.h"
#include "iso2022.h"
#include "hz.h"
#include "wtf.h"
#ifdef USE_UNICODE
#include "ucs.h"
#endif

Str
wc_conv_from_hz(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_HZ_NOSTATE;

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

    for (; p < ep; p++) {
  switch (state) {
  case WC_HZ_NOSTATE:
      if (*p == WC_C_HZ_TILDA)
    state = WC_HZ_TILDA;
      else if (WC_ISO_MAP[*p] == WC_ISO_MAP_GR)
    state = WC_HZ_MBYTE1_GR;    /* GB 2312 ? */
      else if (*p & 0x80)
    wtf_push_unknown(os, p, 1);
      else
    Strcat_char(os, (char)*p);
      break;
  case WC_HZ_TILDA:
      if (*p == WC_C_HZ_SI) {
    state = WC_HZ_MBYTE;
    break;
      } else if (*p == WC_C_HZ_TILDA)
    Strcat_char(os, (char)*p);
      else if (*p == '\n')
    break;
      else
    wtf_push_unknown(os, p-1, 2);
      state = WC_HZ_NOSTATE;
      break;
  case WC_HZ_TILDA_MB:
      if (*p == WC_C_HZ_SO || *p == '\n') {
    state = WC_HZ_NOSTATE;
    break;
      }
      else if (WC_ISO_MAP[*p & 0x7f] == WC_ISO_MAP_GL)
    wtf_push(os, WC_CCS_GB_2312, ((wc_uint32)*(p-1) << 8) | *p);
      else
    wtf_push_unknown(os, p-1, 2);
      state = WC_HZ_MBYTE;
      break;
  case WC_HZ_MBYTE:
      if (*p == WC_C_HZ_TILDA)
    state = WC_HZ_TILDA_MB;
      else if (WC_ISO_MAP[*p & 0x7f] == WC_ISO_MAP_GL)
    state = WC_HZ_MBYTE1;
      else
    wtf_push_unknown(os, p, 1);
      break;
  case WC_HZ_MBYTE1:
      if (WC_ISO_MAP[*p & 0x7f] == WC_ISO_MAP_GL)
    wtf_push(os, WC_CCS_GB_2312, ((wc_uint32)*(p-1) << 8) | *p);
      else
    wtf_push_unknown(os, p-1, 2);
      state = WC_HZ_MBYTE;
      break;
  case WC_HZ_MBYTE1_GR:
      if (WC_ISO_MAP[*p] == WC_ISO_MAP_GR)
    wtf_push(os, WC_CCS_GB_2312, ((wc_uint32)*(p-1) << 8) | *p);
      else
    wtf_push_unknown(os, p-1, 2);
      state = WC_HZ_NOSTATE;
      break;
  }
    }
    switch (state) {
    case WC_HZ_TILDA:
    case WC_HZ_TILDA_MB:
    case WC_HZ_MBYTE1:
    case WC_HZ_MBYTE1_GR:
  wtf_push_unknown(os, p-1, 1);
  break;
    }
    return os;
}

void
wc_push_to_hz(Str os, wc_wchar_t cc, wc_status *st)
{
  while (1) {
    switch (cc.ccs) {
    case WC_CCS_US_ASCII:
  if (st->gl) {
      Strcat_char(os, WC_C_HZ_TILDA);
      Strcat_char(os, WC_C_HZ_SO);
      st->gl = 0;
  }
  if ((char)cc.code == WC_C_HZ_TILDA)
      Strcat_char(os, WC_C_HZ_TILDA);
  Strcat_char(os, (char)cc.code);
  return;
    case WC_CCS_GB_2312:
  if (! st->gl) {
      Strcat_char(os, WC_C_HZ_TILDA);
      Strcat_char(os, WC_C_HZ_SI);
      st->gl = 1;
  }
  Strcat_char(os, (char)((cc.code >> 8) & 0x7f));
  Strcat_char(os, (char)(cc.code & 0x7f));
  return;
    case WC_CCS_UNKNOWN_W:
  if (WcOption.no_replace)
      return;
  if (st->gl) {
      Strcat_char(os, WC_C_HZ_TILDA);
      Strcat_char(os, WC_C_HZ_SO);
      st->gl = 0;
  }
  Strcat_charp(os, WC_REPLACE_W);
  return;
    case WC_CCS_UNKNOWN:
  if (WcOption.no_replace)
      return;
  if (st->gl) {
      Strcat_char(os, WC_C_HZ_TILDA);
      Strcat_char(os, WC_C_HZ_SO);
      st->gl = 0;
  }
  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;
    }
  }
}

void
wc_push_to_hz_end(Str os, wc_status *st)
{
    if (st->gl) {
  Strcat_char(os, WC_C_HZ_TILDA);
  Strcat_char(os, WC_C_HZ_SO);
  st->gl = 0;
    }
}

Line	Count	Source
1
2		#include "wc.h"
3		#include "iso2022.h"
4		#include "hz.h"
5		#include "wtf.h"
6		#ifdef USE_UNICODE
7		#include "ucs.h"
8		#endif
9
10		Str
11		wc_conv_from_hz(Str is, wc_ces ces)
12	267	{
13	267	Str os;
14	267	wc_uchar sp = (wc_uchar )is->ptr;
15	267	wc_uchar *ep = sp + is->length;
16	267	wc_uchar *p;
17	267	int state = WC_HZ_NOSTATE;
18
19	649	for (p = sp; p < ep && p < 0x80 && p != WC_C_HZ_TILDA; p++)
20	382	;
21	267	if (p == ep)
22	27	return is;
23	240	os = Strnew_size(is->length);
24	240	if (p > sp)
25	22	Strcat_charp_n(os, is->ptr, (int)(p - sp));
26
27	1.27M	for (; p < ep; p++) {
28	1.27M	switch (state) {
29	637k	case WC_HZ_NOSTATE:
30	637k	if (*p == WC_C_HZ_TILDA)
31	3.34k	state = WC_HZ_TILDA;
32	634k	else if (WC_ISO_MAP[*p] == WC_ISO_MAP_GR)
33	257k	state = WC_HZ_MBYTE1_GR; /* GB 2312 ? */
34	376k	else if (*p & 0x80)
35	173k	wtf_push_unknown(os, p, 1);
36	202k	else
37	202k	Strcat_char(os, (char)*p);
38	637k	break;
39	3.59k	case WC_HZ_TILDA:
40	3.59k	if (*p == WC_C_HZ_SI) {
41	658	state = WC_HZ_MBYTE;
42	658	break;
43	2.94k	} else if (*p == WC_C_HZ_TILDA)
44	744	Strcat_char(os, (char)*p);
45	2.19k	else if (*p == '\n')
46	267	break;
47	1.93k	else
48	1.93k	wtf_push_unknown(os, p-1, 2);
49	2.67k	state = WC_HZ_NOSTATE;
50	2.67k	break;
51	1.87k	case WC_HZ_TILDA_MB:
52	1.87k	if (p == WC_C_HZ_SO \|\| p == '\n') {
53	581	state = WC_HZ_NOSTATE;
54	581	break;
55	581	}
56	1.29k	else if (WC_ISO_MAP[*p & 0x7f] == WC_ISO_MAP_GL)
57	930	wtf_push(os, WC_CCS_GB_2312, ((wc_uint32)(p-1) << 8) \| p);
58	365	else
59	365	wtf_push_unknown(os, p-1, 2);
60	1.29k	state = WC_HZ_MBYTE;
61	1.29k	break;
62	213k	case WC_HZ_MBYTE:
63	213k	if (*p == WC_C_HZ_TILDA)
64	1.88k	state = WC_HZ_TILDA_MB;
65	211k	else if (WC_ISO_MAP[*p & 0x7f] == WC_ISO_MAP_GL)
66	158k	state = WC_HZ_MBYTE1;
67	53.6k	else
68	53.6k	wtf_push_unknown(os, p, 1);
69	213k	break;
70	158k	case WC_HZ_MBYTE1:
71	158k	if (WC_ISO_MAP[*p & 0x7f] == WC_ISO_MAP_GL)
72	124k	wtf_push(os, WC_CCS_GB_2312, ((wc_uint32)(p-1) << 8) \| p);
73	33.2k	else
74	33.2k	wtf_push_unknown(os, p-1, 2);
75	158k	state = WC_HZ_MBYTE;
76	158k	break;
77	257k	case WC_HZ_MBYTE1_GR:
78	257k	if (WC_ISO_MAP[*p] == WC_ISO_MAP_GR)
79	110k	wtf_push(os, WC_CCS_GB_2312, ((wc_uint32)(p-1) << 8) \| p);
80	147k	else
81	147k	wtf_push_unknown(os, p-1, 2);
82	257k	state = WC_HZ_NOSTATE;
83	257k	break;
84	1.27M	}
85	1.27M	}
86	240	switch (state) {
87	12	case WC_HZ_TILDA:
88	18	case WC_HZ_TILDA_MB:
89	35	case WC_HZ_MBYTE1:
90	52	case WC_HZ_MBYTE1_GR:
91	52	wtf_push_unknown(os, p-1, 1);
92	52	break;
93	240	}
94	240	return os;
95	240	}
96
97		void
98		wc_push_to_hz(Str os, wc_wchar_t cc, wc_status *st)
99	22.0M	{
100	40.3M	while (1) {
101	40.3M	switch (cc.ccs) {
102	3.42M	case WC_CCS_US_ASCII:
103	3.42M	if (st->gl) {
104	2.29M	Strcat_char(os, WC_C_HZ_TILDA);
105	2.29M	Strcat_char(os, WC_C_HZ_SO);
106	2.29M	st->gl = 0;
107	2.29M	}
108	3.42M	if ((char)cc.code == WC_C_HZ_TILDA)
109	2.11M	Strcat_char(os, WC_C_HZ_TILDA);
110	3.42M	Strcat_char(os, (char)cc.code);
111	3.42M	return;
112	10.9M	case WC_CCS_GB_2312:
113	10.9M	if (! st->gl) {
114	7.96M	Strcat_char(os, WC_C_HZ_TILDA);
115	7.96M	Strcat_char(os, WC_C_HZ_SI);
116	7.96M	st->gl = 1;
117	7.96M	}
118	10.9M	Strcat_char(os, (char)((cc.code >> 8) & 0x7f));
119	10.9M	Strcat_char(os, (char)(cc.code & 0x7f));
120	10.9M	return;
121	7.30M	case WC_CCS_UNKNOWN_W:
122	7.30M	if (WcOption.no_replace)
123	0	return;
124	7.30M	if (st->gl) {
125	5.60M	Strcat_char(os, WC_C_HZ_TILDA);
126	5.60M	Strcat_char(os, WC_C_HZ_SO);
127	5.60M	st->gl = 0;
128	5.60M	}
129	7.30M	Strcat_charp(os, WC_REPLACE_W);
130	7.30M	return;
131	313k	case WC_CCS_UNKNOWN:
132	313k	if (WcOption.no_replace)
133	0	return;
134	313k	if (st->gl) {
135	60.7k	Strcat_char(os, WC_C_HZ_TILDA);
136	60.7k	Strcat_char(os, WC_C_HZ_SO);
137	60.7k	st->gl = 0;
138	60.7k	}
139	313k	Strcat_charp(os, WC_REPLACE);
140	313k	return;
141	18.3M	default:
142	18.3M	#ifdef USE_UNICODE
143	18.3M	if (WcOption.ucs_conv)
144	18.3M	cc = wc_any_to_any_ces(cc, st);
145	0	else
146	0	#endif
147	0	cc.ccs = WC_CCS_IS_WIDE(cc.ccs) ? WC_CCS_UNKNOWN_W : WC_CCS_UNKNOWN;
148	18.3M	continue;
149	40.3M	}
150	40.3M	}
151	22.0M	}
152
153		void
154		wc_push_to_hz_end(Str os, wc_status *st)
155	425	{
156	425	if (st->gl) {
157	206	Strcat_char(os, WC_C_HZ_TILDA);
158		Strcat_char(os, WC_C_HZ_SO);
159	206	st->gl = 0;
160	206	}
161	425	}

Coverage Report

Created: 2026-06-07 06:42