1
// Copyright 2013 The Go Authors. All rights reserved.
2
// Use of this source code is governed by a BSD-style
3
// license that can be found in the LICENSE file.
4

5
package simplifiedchinese
6

7
import (
8
	"unicode/utf8"
9

10
	"golang.org/x/text/encoding"
11
	"golang.org/x/text/encoding/internal"
12
	"golang.org/x/text/encoding/internal/identifier"
13
	"golang.org/x/text/transform"
14
)
15

16
// HZGB2312 is the HZ-GB2312 encoding.
17
var HZGB2312 encoding.Encoding = &hzGB2312
18

19
var hzGB2312 = internal.Encoding{
20
	internal.FuncEncoding{hzGB2312NewDecoder, hzGB2312NewEncoder},
21
	"HZ-GB2312",
22
	identifier.HZGB2312,
23
}
24

25
func hzGB2312NewDecoder() transform.Transformer {
26
	return new(hzGB2312Decoder)
27
}
28

29
func hzGB2312NewEncoder() transform.Transformer {
30
	return new(hzGB2312Encoder)
31
}
32

33
const (
34
	asciiState = iota
35
	gbState
36
)
37

38
type hzGB2312Decoder int
39

40
func (d *hzGB2312Decoder) Reset() {
41
	*d = asciiState
42
}
43

44
func (d *hzGB2312Decoder) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
45
	r, size := rune(0), 0
46
loop:
47
	for ; nSrc < len(src); nSrc += size {
48
		c0 := src[nSrc]
49
		if c0 >= utf8.RuneSelf {
50
			r, size = utf8.RuneError, 1
51
			goto write
52
		}
53

54
		if c0 == '~' {
55
			if nSrc+1 >= len(src) {
56
				if !atEOF {
57
					err = transform.ErrShortSrc
58
					break loop
59
				}
60
				r, size = utf8.RuneError, 1
61
				goto write
62
			}
63
			size = 2
64
			switch src[nSrc+1] {
65
			case '{':
66
				*d = gbState
67
				continue
68
			case '}':
69
				*d = asciiState
70
				continue
71
			case '~':
72
				if nDst >= len(dst) {
73
					err = transform.ErrShortDst
74
					break loop
75
				}
76
				dst[nDst] = '~'
77
				nDst++
78
				continue
79
			case '\n':
80
				continue
81
			default:
82
				r = utf8.RuneError
83
				goto write
84
			}
85
		}
86

87
		if *d == asciiState {
88
			r, size = rune(c0), 1
89
		} else {
90
			if nSrc+1 >= len(src) {
91
				if !atEOF {
92
					err = transform.ErrShortSrc
93
					break loop
94
				}
95
				r, size = utf8.RuneError, 1
96
				goto write
97
			}
98
			size = 2
99
			c1 := src[nSrc+1]
100
			if c0 < 0x21 || 0x7e <= c0 || c1 < 0x21 || 0x7f <= c1 {
101
				// error
102
			} else if i := int(c0-0x01)*190 + int(c1+0x3f); i < len(decode) {
103
				r = rune(decode[i])
104
				if r != 0 {
105
					goto write
106
				}
107
			}
108
			if c1 > utf8.RuneSelf {
109
				// Be consistent and always treat non-ASCII as a single error.
110
				size = 1
111
			}
112
			r = utf8.RuneError
113
		}
114

115
	write:
116
		if nDst+utf8.RuneLen(r) > len(dst) {
117
			err = transform.ErrShortDst
118
			break loop
119
		}
120
		nDst += utf8.EncodeRune(dst[nDst:], r)
121
	}
122
	return nDst, nSrc, err
123
}
124

125
type hzGB2312Encoder int
126

127
func (d *hzGB2312Encoder) Reset() {
128
	*d = asciiState
129
}
130

131
func (e *hzGB2312Encoder) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
132
	r, size := rune(0), 0
133
	for ; nSrc < len(src); nSrc += size {
134
		r = rune(src[nSrc])
135

136
		// Decode a 1-byte rune.
137
		if r < utf8.RuneSelf {
138
			size = 1
139
			if r == '~' {
140
				if nDst+2 > len(dst) {
141
					err = transform.ErrShortDst
142
					break
143
				}
144
				dst[nDst+0] = '~'
145
				dst[nDst+1] = '~'
146
				nDst += 2
147
				continue
148
			} else if *e != asciiState {
149
				if nDst+3 > len(dst) {
150
					err = transform.ErrShortDst
151
					break
152
				}
153
				*e = asciiState
154
				dst[nDst+0] = '~'
155
				dst[nDst+1] = '}'
156
				nDst += 2
157
			} else if nDst >= len(dst) {
158
				err = transform.ErrShortDst
159
				break
160
			}
161
			dst[nDst] = uint8(r)
162
			nDst += 1
163
			continue
164

165
		}
166

167
		// Decode a multi-byte rune.
168
		r, size = utf8.DecodeRune(src[nSrc:])
169
		if size == 1 {
170
			// All valid runes of size 1 (those below utf8.RuneSelf) were
171
			// handled above. We have invalid UTF-8 or we haven't seen the
172
			// full character yet.
173
			if !atEOF && !utf8.FullRune(src[nSrc:]) {
174
				err = transform.ErrShortSrc
175
				break
176
			}
177
		}
178

179
		// func init checks that the switch covers all tables.
180
		switch {
181
		case encode0Low <= r && r < encode0High:
182
			if r = rune(encode0[r-encode0Low]); r != 0 {
183
				goto writeGB
184
			}
185
		case encode1Low <= r && r < encode1High:
186
			if r = rune(encode1[r-encode1Low]); r != 0 {
187
				goto writeGB
188
			}
189
		case encode2Low <= r && r < encode2High:
190
			if r = rune(encode2[r-encode2Low]); r != 0 {
191
				goto writeGB
192
			}
193
		case encode3Low <= r && r < encode3High:
194
			if r = rune(encode3[r-encode3Low]); r != 0 {
195
				goto writeGB
196
			}
197
		case encode4Low <= r && r < encode4High:
198
			if r = rune(encode4[r-encode4Low]); r != 0 {
199
				goto writeGB
200
			}
201
		}
202

203
	terminateInASCIIState:
204
		// Switch back to ASCII state in case of error so that an ASCII
205
		// replacement character can be written in the correct state.
206
		if *e != asciiState {
207
			if nDst+2 > len(dst) {
208
				err = transform.ErrShortDst
209
				break
210
			}
211
			dst[nDst+0] = '~'
212
			dst[nDst+1] = '}'
213
			nDst += 2
214
		}
215
		err = internal.ErrASCIIReplacement
216
		break
217

218
	writeGB:
219
		c0 := uint8(r>>8) - 0x80
220
		c1 := uint8(r) - 0x80
221
		if c0 < 0x21 || 0x7e <= c0 || c1 < 0x21 || 0x7f <= c1 {
222
			goto terminateInASCIIState
223
		}
224
		if *e == asciiState {
225
			if nDst+4 > len(dst) {
226
				err = transform.ErrShortDst
227
				break
228
			}
229
			*e = gbState
230
			dst[nDst+0] = '~'
231
			dst[nDst+1] = '{'
232
			nDst += 2
233
		} else if nDst+2 > len(dst) {
234
			err = transform.ErrShortDst
235
			break
236
		}
237
		dst[nDst+0] = c0
238
		dst[nDst+1] = c1
239
		nDst += 2
240
		continue
241
	}
242
	// TODO: should one always terminate in ASCII state to make it safe to
243
	// concatenate two HZ-GB2312-encoded strings?
244
	return nDst, nSrc, err
245
}
246

247