/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	274	{
13	274	Str os;
14	274	wc_uchar sp = (wc_uchar )is->ptr;
15	274	wc_uchar *ep = sp + is->length;
16	274	wc_uchar *p;
17	274	int state = WC_HZ_NOSTATE;
18
19	792	for (p = sp; p < ep && p < 0x80 && p != WC_C_HZ_TILDA; p++)
20	518	;
21	274	if (p == ep)
22	35	return is;
23	239	os = Strnew_size(is->length);
24	239	if (p > sp)
25	24	Strcat_charp_n(os, is->ptr, (int)(p - sp));
26
27	969k	for (; p < ep; p++) {
28	969k	switch (state) {
29	755k	case WC_HZ_NOSTATE:
30	755k	if (*p == WC_C_HZ_TILDA)
31	2.80k	state = WC_HZ_TILDA;
32	752k	else if (WC_ISO_MAP[*p] == WC_ISO_MAP_GR)
33	157k	state = WC_HZ_MBYTE1_GR; /* GB 2312 ? */
34	594k	else if (*p & 0x80)
35	477k	wtf_push_unknown(os, p, 1);
36	117k	else
37	117k	Strcat_char(os, (char)*p);
38	755k	break;
39	3.03k	case WC_HZ_TILDA:
40	3.03k	if (*p == WC_C_HZ_SI) {
41	643	state = WC_HZ_MBYTE;
42	643	break;
43	2.39k	} else if (*p == WC_C_HZ_TILDA)
44	507	Strcat_char(os, (char)*p);
45	1.88k	else if (*p == '\n')
46	239	break;
47	1.64k	else
48	1.64k	wtf_push_unknown(os, p-1, 2);
49	2.15k	state = WC_HZ_NOSTATE;
50	2.15k	break;
51	1.50k	case WC_HZ_TILDA_MB:
52	1.50k	if (p == WC_C_HZ_SO \|\| p == '\n') {
53	563	state = WC_HZ_NOSTATE;
54	563	break;
55	563	}
56	939	else if (WC_ISO_MAP[*p & 0x7f] == WC_ISO_MAP_GL)
57	692	wtf_push(os, WC_CCS_GB_2312, ((wc_uint32)(p-1) << 8) \| p);
58	247	else
59	247	wtf_push_unknown(os, p-1, 2);
60	939	state = WC_HZ_MBYTE;
61	939	break;
62	34.9k	case WC_HZ_MBYTE:
63	34.9k	if (*p == WC_C_HZ_TILDA)
64	1.50k	state = WC_HZ_TILDA_MB;
65	33.4k	else if (WC_ISO_MAP[*p & 0x7f] == WC_ISO_MAP_GL)
66	16.8k	state = WC_HZ_MBYTE1;
67	16.5k	else
68	16.5k	wtf_push_unknown(os, p, 1);
69	34.9k	break;
70	16.8k	case WC_HZ_MBYTE1:
71	16.8k	if (WC_ISO_MAP[*p & 0x7f] == WC_ISO_MAP_GL)
72	14.9k	wtf_push(os, WC_CCS_GB_2312, ((wc_uint32)(p-1) << 8) \| p);
73	1.93k	else
74	1.93k	wtf_push_unknown(os, p-1, 2);
75	16.8k	state = WC_HZ_MBYTE;
76	16.8k	break;
77	157k	case WC_HZ_MBYTE1_GR:
78	157k	if (WC_ISO_MAP[*p] == WC_ISO_MAP_GR)
79	56.9k	wtf_push(os, WC_CCS_GB_2312, ((wc_uint32)(p-1) << 8) \| p);
80	100k	else
81	100k	wtf_push_unknown(os, p-1, 2);
82	157k	state = WC_HZ_NOSTATE;
83	157k	break;
84	969k	}
85	969k	}
86	239	switch (state) {
87	9	case WC_HZ_TILDA:
88	14	case WC_HZ_TILDA_MB:
89	26	case WC_HZ_MBYTE1:
90	44	case WC_HZ_MBYTE1_GR:
91	44	wtf_push_unknown(os, p-1, 1);
92	44	break;
93	239	}
94	239	return os;
95	239	}
96
97		void
98		wc_push_to_hz(Str os, wc_wchar_t cc, wc_status *st)
99	24.7M	{
100	45.3M	while (1) {
101	45.3M	switch (cc.ccs) {
102	3.49M	case WC_CCS_US_ASCII:
103	3.49M	if (st->gl) {
104	2.58M	Strcat_char(os, WC_C_HZ_TILDA);
105	2.58M	Strcat_char(os, WC_C_HZ_SO);
106	2.58M	st->gl = 0;
107	2.58M	}
108	3.49M	if ((char)cc.code == WC_C_HZ_TILDA)
109	2.48M	Strcat_char(os, WC_C_HZ_TILDA);
110	3.49M	Strcat_char(os, (char)cc.code);
111	3.49M	return;
112	12.3M	case WC_CCS_GB_2312:
113	12.3M	if (! st->gl) {
114	10.7M	Strcat_char(os, WC_C_HZ_TILDA);
115	10.7M	Strcat_char(os, WC_C_HZ_SI);
116	10.7M	st->gl = 1;
117	10.7M	}
118	12.3M	Strcat_char(os, (char)((cc.code >> 8) & 0x7f));
119	12.3M	Strcat_char(os, (char)(cc.code & 0x7f));
120	12.3M	return;
121	8.24M	case WC_CCS_UNKNOWN_W:
122	8.24M	if (WcOption.no_replace)
123	0	return;
124	8.24M	if (st->gl) {
125	8.09M	Strcat_char(os, WC_C_HZ_TILDA);
126	8.09M	Strcat_char(os, WC_C_HZ_SO);
127	8.09M	st->gl = 0;
128	8.09M	}
129	8.24M	Strcat_charp(os, WC_REPLACE_W);
130	8.24M	return;
131	679k	case WC_CCS_UNKNOWN:
132	679k	if (WcOption.no_replace)
133	0	return;
134	679k	if (st->gl) {
135	38.5k	Strcat_char(os, WC_C_HZ_TILDA);
136	38.5k	Strcat_char(os, WC_C_HZ_SO);
137	38.5k	st->gl = 0;
138	38.5k	}
139	679k	Strcat_charp(os, WC_REPLACE);
140	679k	return;
141	20.6M	default:
142	20.6M	#ifdef USE_UNICODE
143	20.6M	if (WcOption.ucs_conv)
144	20.6M	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	20.6M	continue;
149	45.3M	}
150	45.3M	}
151	24.7M	}
152
153		void
154		wc_push_to_hz_end(Str os, wc_status *st)
155	457	{
156	457	if (st->gl) {
157	230	Strcat_char(os, WC_C_HZ_TILDA);
158		Strcat_char(os, WC_C_HZ_SO);
159	230	st->gl = 0;
160	230	}
161	457	}

Coverage Report

Created: 2026-01-10 06:48