--- /dev/null
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package simplifiedchinese
+
+import (
+ "unicode/utf8"
+
+ "golang.org/x/text/encoding"
+ "golang.org/x/text/encoding/internal"
+ "golang.org/x/text/encoding/internal/identifier"
+ "golang.org/x/text/transform"
+)
+
+// HZGB2312 is the HZ-GB2312 encoding.
+var HZGB2312 encoding.Encoding = &hzGB2312
+
+var hzGB2312 = internal.Encoding{
+ internal.FuncEncoding{hzGB2312NewDecoder, hzGB2312NewEncoder},
+ "HZ-GB2312",
+ identifier.HZGB2312,
+}
+
+func hzGB2312NewDecoder() transform.Transformer {
+ return new(hzGB2312Decoder)
+}
+
+func hzGB2312NewEncoder() transform.Transformer {
+ return new(hzGB2312Encoder)
+}
+
+const (
+ asciiState = iota
+ gbState
+)
+
+type hzGB2312Decoder int
+
+func (d *hzGB2312Decoder) Reset() {
+ *d = asciiState
+}
+
+func (d *hzGB2312Decoder) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
+ r, size := rune(0), 0
+loop:
+ for ; nSrc < len(src); nSrc += size {
+ c0 := src[nSrc]
+ if c0 >= utf8.RuneSelf {
+ r, size = utf8.RuneError, 1
+ goto write
+ }
+
+ if c0 == '~' {
+ if nSrc+1 >= len(src) {
+ if !atEOF {
+ err = transform.ErrShortSrc
+ break loop
+ }
+ r = utf8.RuneError
+ goto write
+ }
+ size = 2
+ switch src[nSrc+1] {
+ case '{':
+ *d = gbState
+ continue
+ case '}':
+ *d = asciiState
+ continue
+ case '~':
+ if nDst >= len(dst) {
+ err = transform.ErrShortDst
+ break loop
+ }
+ dst[nDst] = '~'
+ nDst++
+ continue
+ case '\n':
+ continue
+ default:
+ r = utf8.RuneError
+ goto write
+ }
+ }
+
+ if *d == asciiState {
+ r, size = rune(c0), 1
+ } else {
+ if nSrc+1 >= len(src) {
+ if !atEOF {
+ err = transform.ErrShortSrc
+ break loop
+ }
+ r, size = utf8.RuneError, 1
+ goto write
+ }
+ size = 2
+ c1 := src[nSrc+1]
+ if c0 < 0x21 || 0x7e <= c0 || c1 < 0x21 || 0x7f <= c1 {
+ // error
+ } else if i := int(c0-0x01)*190 + int(c1+0x3f); i < len(decode) {
+ r = rune(decode[i])
+ if r != 0 {
+ goto write
+ }
+ }
+ if c1 > utf8.RuneSelf {
+ // Be consistent and always treat non-ASCII as a single error.
+ size = 1
+ }
+ r = utf8.RuneError
+ }
+
+ write:
+ if nDst+utf8.RuneLen(r) > len(dst) {
+ err = transform.ErrShortDst
+ break loop
+ }
+ nDst += utf8.EncodeRune(dst[nDst:], r)
+ }
+ return nDst, nSrc, err
+}
+
+type hzGB2312Encoder int
+
+func (d *hzGB2312Encoder) Reset() {
+ *d = asciiState
+}
+
+func (e *hzGB2312Encoder) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
+ r, size := rune(0), 0
+ for ; nSrc < len(src); nSrc += size {
+ r = rune(src[nSrc])
+
+ // Decode a 1-byte rune.
+ if r < utf8.RuneSelf {
+ size = 1
+ if r == '~' {
+ if nDst+2 > len(dst) {
+ err = transform.ErrShortDst
+ break
+ }
+ dst[nDst+0] = '~'
+ dst[nDst+1] = '~'
+ nDst += 2
+ continue
+ } else if *e != asciiState {
+ if nDst+3 > len(dst) {
+ err = transform.ErrShortDst
+ break
+ }
+ *e = asciiState
+ dst[nDst+0] = '~'
+ dst[nDst+1] = '}'
+ nDst += 2
+ } else if nDst >= len(dst) {
+ err = transform.ErrShortDst
+ break
+ }
+ dst[nDst] = uint8(r)
+ nDst += 1
+ continue
+
+ }
+
+ // Decode a multi-byte rune.
+ r, size = utf8.DecodeRune(src[nSrc:])
+ if size == 1 {
+ // All valid runes of size 1 (those below utf8.RuneSelf) were
+ // handled above. We have invalid UTF-8 or we haven't seen the
+ // full character yet.
+ if !atEOF && !utf8.FullRune(src[nSrc:]) {
+ err = transform.ErrShortSrc
+ break
+ }
+ }
+
+ // func init checks that the switch covers all tables.
+ switch {
+ case encode0Low <= r && r < encode0High:
+ if r = rune(encode0[r-encode0Low]); r != 0 {
+ goto writeGB
+ }
+ case encode1Low <= r && r < encode1High:
+ if r = rune(encode1[r-encode1Low]); r != 0 {
+ goto writeGB
+ }
+ case encode2Low <= r && r < encode2High:
+ if r = rune(encode2[r-encode2Low]); r != 0 {
+ goto writeGB
+ }
+ case encode3Low <= r && r < encode3High:
+ if r = rune(encode3[r-encode3Low]); r != 0 {
+ goto writeGB
+ }
+ case encode4Low <= r && r < encode4High:
+ if r = rune(encode4[r-encode4Low]); r != 0 {
+ goto writeGB
+ }
+ }
+
+ terminateInASCIIState:
+ // Switch back to ASCII state in case of error so that an ASCII
+ // replacement character can be written in the correct state.
+ if *e != asciiState {
+ if nDst+2 > len(dst) {
+ err = transform.ErrShortDst
+ break
+ }
+ dst[nDst+0] = '~'
+ dst[nDst+1] = '}'
+ nDst += 2
+ }
+ err = internal.ErrASCIIReplacement
+ break
+
+ writeGB:
+ c0 := uint8(r>>8) - 0x80
+ c1 := uint8(r) - 0x80
+ if c0 < 0x21 || 0x7e <= c0 || c1 < 0x21 || 0x7f <= c1 {
+ goto terminateInASCIIState
+ }
+ if *e == asciiState {
+ if nDst+4 > len(dst) {
+ err = transform.ErrShortDst
+ break
+ }
+ *e = gbState
+ dst[nDst+0] = '~'
+ dst[nDst+1] = '{'
+ nDst += 2
+ } else if nDst+2 > len(dst) {
+ err = transform.ErrShortDst
+ break
+ }
+ dst[nDst+0] = c0
+ dst[nDst+1] = c1
+ nDst += 2
+ continue
+ }
+ // TODO: should one always terminate in ASCII state to make it safe to
+ // concatenate two HZ-GB2312-encoded strings?
+ return nDst, nSrc, err
+}
OSDN Git Service
