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 japanese
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
// EUCJP is the EUC-JP encoding.
17
var EUCJP encoding.Encoding = &eucJP
18

19
var eucJP = internal.Encoding{
20
	&internal.SimpleEncoding{eucJPDecoder{}, eucJPEncoder{}},
21
	"EUC-JP",
22
	identifier.EUCPkdFmtJapanese,
23
}
24

25
type eucJPDecoder struct{ transform.NopResetter }
26

27
// See https://encoding.spec.whatwg.org/#euc-jp-decoder.
28
func (eucJPDecoder) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
29
	r, size := rune(0), 0
30
loop:
31
	for ; nSrc < len(src); nSrc += size {
32
		switch c0 := src[nSrc]; {
33
		case c0 < utf8.RuneSelf:
34
			r, size = rune(c0), 1
35

36
		case c0 == 0x8e:
37
			if nSrc+1 >= len(src) {
38
				if !atEOF {
39
					err = transform.ErrShortSrc
40
					break loop
41
				}
42
				r, size = utf8.RuneError, 1
43
				break
44
			}
45
			c1 := src[nSrc+1]
46
			switch {
47
			case c1 < 0xa1:
48
				r, size = utf8.RuneError, 1
49
			case c1 > 0xdf:
50
				r, size = utf8.RuneError, 2
51
				if c1 == 0xff {
52
					size = 1
53
				}
54
			default:
55
				r, size = rune(c1)+(0xff61-0xa1), 2
56
			}
57
		case c0 == 0x8f:
58
			if nSrc+2 >= len(src) {
59
				if !atEOF {
60
					err = transform.ErrShortSrc
61
					break loop
62
				}
63
				r, size = utf8.RuneError, 1
64
				if p := nSrc + 1; p < len(src) && 0xa1 <= src[p] && src[p] < 0xfe {
65
					size = 2
66
				}
67
				break
68
			}
69
			c1 := src[nSrc+1]
70
			if c1 < 0xa1 || 0xfe < c1 {
71
				r, size = utf8.RuneError, 1
72
				break
73
			}
74
			c2 := src[nSrc+2]
75
			if c2 < 0xa1 || 0xfe < c2 {
76
				r, size = utf8.RuneError, 2
77
				break
78
			}
79
			r, size = utf8.RuneError, 3
80
			if i := int(c1-0xa1)*94 + int(c2-0xa1); i < len(jis0212Decode) {
81
				r = rune(jis0212Decode[i])
82
				if r == 0 {
83
					r = utf8.RuneError
84
				}
85
			}
86

87
		case 0xa1 <= c0 && c0 <= 0xfe:
88
			if nSrc+1 >= len(src) {
89
				if !atEOF {
90
					err = transform.ErrShortSrc
91
					break loop
92
				}
93
				r, size = utf8.RuneError, 1
94
				break
95
			}
96
			c1 := src[nSrc+1]
97
			if c1 < 0xa1 || 0xfe < c1 {
98
				r, size = utf8.RuneError, 1
99
				break
100
			}
101
			r, size = utf8.RuneError, 2
102
			if i := int(c0-0xa1)*94 + int(c1-0xa1); i < len(jis0208Decode) {
103
				r = rune(jis0208Decode[i])
104
				if r == 0 {
105
					r = utf8.RuneError
106
				}
107
			}
108

109
		default:
110
			r, size = utf8.RuneError, 1
111
		}
112

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

122
type eucJPEncoder struct{ transform.NopResetter }
123

124
func (eucJPEncoder) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
125
	r, size := rune(0), 0
126
	for ; nSrc < len(src); nSrc += size {
127
		r = rune(src[nSrc])
128

129
		// Decode a 1-byte rune.
130
		if r < utf8.RuneSelf {
131
			size = 1
132

133
		} else {
134
			// Decode a multi-byte rune.
135
			r, size = utf8.DecodeRune(src[nSrc:])
136
			if size == 1 {
137
				// All valid runes of size 1 (those below utf8.RuneSelf) were
138
				// handled above. We have invalid UTF-8 or we haven't seen the
139
				// full character yet.
140
				if !atEOF && !utf8.FullRune(src[nSrc:]) {
141
					err = transform.ErrShortSrc
142
					break
143
				}
144
			}
145

146
			// func init checks that the switch covers all tables.
147
			switch {
148
			case encode0Low <= r && r < encode0High:
149
				if r = rune(encode0[r-encode0Low]); r != 0 {
150
					goto write2or3
151
				}
152
			case encode1Low <= r && r < encode1High:
153
				if r = rune(encode1[r-encode1Low]); r != 0 {
154
					goto write2or3
155
				}
156
			case encode2Low <= r && r < encode2High:
157
				if r = rune(encode2[r-encode2Low]); r != 0 {
158
					goto write2or3
159
				}
160
			case encode3Low <= r && r < encode3High:
161
				if r = rune(encode3[r-encode3Low]); r != 0 {
162
					goto write2or3
163
				}
164
			case encode4Low <= r && r < encode4High:
165
				if r = rune(encode4[r-encode4Low]); r != 0 {
166
					goto write2or3
167
				}
168
			case encode5Low <= r && r < encode5High:
169
				if 0xff61 <= r && r < 0xffa0 {
170
					goto write2
171
				}
172
				if r = rune(encode5[r-encode5Low]); r != 0 {
173
					goto write2or3
174
				}
175
			}
176
			err = internal.ErrASCIIReplacement
177
			break
178
		}
179

180
		if nDst >= len(dst) {
181
			err = transform.ErrShortDst
182
			break
183
		}
184
		dst[nDst] = uint8(r)
185
		nDst++
186
		continue
187

188
	write2or3:
189
		if r>>tableShift == jis0208 {
190
			if nDst+2 > len(dst) {
191
				err = transform.ErrShortDst
192
				break
193
			}
194
		} else {
195
			if nDst+3 > len(dst) {
196
				err = transform.ErrShortDst
197
				break
198
			}
199
			dst[nDst] = 0x8f
200
			nDst++
201
		}
202
		dst[nDst+0] = 0xa1 + uint8(r>>codeShift)&codeMask
203
		dst[nDst+1] = 0xa1 + uint8(r)&codeMask
204
		nDst += 2
205
		continue
206

207
	write2:
208
		if nDst+2 > len(dst) {
209
			err = transform.ErrShortDst
210
			break
211
		}
212
		dst[nDst+0] = 0x8e
213
		dst[nDst+1] = uint8(r - (0xff61 - 0xa1))
214
		nDst += 2
215
		continue
216
	}
217
	return nDst, nSrc, err
218
}
219

220
func init() {
221
	// Check that the hard-coded encode switch covers all tables.
222
	if numEncodeTables != 6 {
223
		panic("bad numEncodeTables")
224
	}
225
}
226

227