/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	276	{
13	276	Str os;
14	276	wc_uchar sp = (wc_uchar )is->ptr;
15	276	wc_uchar *ep = sp + is->length;
16	276	wc_uchar *p;
17	276	int state = WC_HZ_NOSTATE;
18
19	583	for (p = sp; p < ep && p < 0x80 && p != WC_C_HZ_TILDA; p++)
20	307	;
21	276	if (p == ep)
22	28	return is;
23	248	os = Strnew_size(is->length);
24	248	if (p > sp)
25	27	Strcat_charp_n(os, is->ptr, (int)(p - sp));
26
27	1.03M	for (; p < ep; p++) {
28	1.03M	switch (state) {
29	704k	case WC_HZ_NOSTATE:
30	704k	if (*p == WC_C_HZ_TILDA)
31	2.74k	state = WC_HZ_TILDA;
32	701k	else if (WC_ISO_MAP[*p] == WC_ISO_MAP_GR)
33	324k	state = WC_HZ_MBYTE1_GR; /* GB 2312 ? */
34	376k	else if (*p & 0x80)
35	208k	wtf_push_unknown(os, p, 1);
36	168k	else
37	168k	Strcat_char(os, (char)*p);
38	704k	break;
39	2.92k	case WC_HZ_TILDA:
40	2.92k	if (*p == WC_C_HZ_SI) {
41	691	state = WC_HZ_MBYTE;
42	691	break;
43	2.23k	} else if (*p == WC_C_HZ_TILDA)
44	513	Strcat_char(os, (char)*p);
45	1.72k	else if (*p == '\n')
46	195	break;
47	1.52k	else
48	1.52k	wtf_push_unknown(os, p-1, 2);
49	2.04k	state = WC_HZ_NOSTATE;
50	2.04k	break;
51	1.19k	case WC_HZ_TILDA_MB:
52	1.19k	if (p == WC_C_HZ_SO \|\| p == '\n') {
53	605	state = WC_HZ_NOSTATE;
54	605	break;
55	605	}
56	587	else if (WC_ISO_MAP[*p & 0x7f] == WC_ISO_MAP_GL)
57	362	wtf_push(os, WC_CCS_GB_2312, ((wc_uint32)(p-1) << 8) \| p);
58	225	else
59	225	wtf_push_unknown(os, p-1, 2);
60	587	state = WC_HZ_MBYTE;
61	587	break;
62	3.67k	case WC_HZ_MBYTE:
63	3.67k	if (*p == WC_C_HZ_TILDA)
64	1.19k	state = WC_HZ_TILDA_MB;
65	2.47k	else if (WC_ISO_MAP[*p & 0x7f] == WC_ISO_MAP_GL)
66	1.45k	state = WC_HZ_MBYTE1;
67	1.02k	else
68	1.02k	wtf_push_unknown(os, p, 1);
69	3.67k	break;
70	1.43k	case WC_HZ_MBYTE1:
71	1.43k	if (WC_ISO_MAP[*p & 0x7f] == WC_ISO_MAP_GL)
72	964	wtf_push(os, WC_CCS_GB_2312, ((wc_uint32)(p-1) << 8) \| p);
73	475	else
74	475	wtf_push_unknown(os, p-1, 2);
75	1.43k	state = WC_HZ_MBYTE;
76	1.43k	break;
77	324k	case WC_HZ_MBYTE1_GR:
78	324k	if (WC_ISO_MAP[*p] == WC_ISO_MAP_GR)
79	304k	wtf_push(os, WC_CCS_GB_2312, ((wc_uint32)(p-1) << 8) \| p);
80	19.5k	else
81	19.5k	wtf_push_unknown(os, p-1, 2);
82	324k	state = WC_HZ_NOSTATE;
83	324k	break;
84	1.03M	}
85	1.03M	}
86	248	switch (state) {
87	11	case WC_HZ_TILDA:
88	17	case WC_HZ_TILDA_MB:
89	32	case WC_HZ_MBYTE1:
90	52	case WC_HZ_MBYTE1_GR:
91	52	wtf_push_unknown(os, p-1, 1);
92	52	break;
93	248	}
94	248	return os;
95	248	}
96
97		void
98		wc_push_to_hz(Str os, wc_wchar_t cc, wc_status *st)
99	24.9M	{
100	46.2M	while (1) {
101	46.2M	switch (cc.ccs) {
102	3.23M	case WC_CCS_US_ASCII:
103	3.23M	if (st->gl) {
104	2.98M	Strcat_char(os, WC_C_HZ_TILDA);
105	2.98M	Strcat_char(os, WC_C_HZ_SO);
106	2.98M	st->gl = 0;
107	2.98M	}
108	3.23M	if ((char)cc.code == WC_C_HZ_TILDA)
109	2.93M	Strcat_char(os, WC_C_HZ_TILDA);
110	3.23M	Strcat_char(os, (char)cc.code);
111	3.23M	return;
112	12.0M	case WC_CCS_GB_2312:
113	12.0M	if (! st->gl) {
114	11.6M	Strcat_char(os, WC_C_HZ_TILDA);
115	11.6M	Strcat_char(os, WC_C_HZ_SI);
116	11.6M	st->gl = 1;
117	11.6M	}
118	12.0M	Strcat_char(os, (char)((cc.code >> 8) & 0x7f));
119	12.0M	Strcat_char(os, (char)(cc.code & 0x7f));
120	12.0M	return;
121	8.74M	case WC_CCS_UNKNOWN_W:
122	8.74M	if (WcOption.no_replace)
123	0	return;
124	8.74M	if (st->gl) {
125	8.63M	Strcat_char(os, WC_C_HZ_TILDA);
126	8.63M	Strcat_char(os, WC_C_HZ_SO);
127	8.63M	st->gl = 0;
128	8.63M	}
129	8.74M	Strcat_charp(os, WC_REPLACE_W);
130	8.74M	return;
131	912k	case WC_CCS_UNKNOWN:
132	912k	if (WcOption.no_replace)
133	0	return;
134	912k	if (st->gl) {
135	23.1k	Strcat_char(os, WC_C_HZ_TILDA);
136	23.1k	Strcat_char(os, WC_C_HZ_SO);
137	23.1k	st->gl = 0;
138	23.1k	}
139	912k	Strcat_charp(os, WC_REPLACE);
140	912k	return;
141	21.3M	default:
142	21.3M	#ifdef USE_UNICODE
143	21.3M	if (WcOption.ucs_conv)
144	21.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	21.3M	continue;
149	46.2M	}
150	46.2M	}
151	24.9M	}
152
153		void
154		wc_push_to_hz_end(Str os, wc_status *st)
155	459	{
156	459	if (st->gl) {
157	223	Strcat_char(os, WC_C_HZ_TILDA);
158		Strcat_char(os, WC_C_HZ_SO);
159	223	st->gl = 0;
160	223	}
161	459	}

Coverage Report

Created: 2025-11-09 06:12