vendor/golang.org/x/text/encoding/korean/euckr.go

   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 korean
   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 // All is a list of all defined encodings in this package.
  17 var All = []encoding.Encoding{EUCKR}
  18
  19 // EUCKR is the EUC-KR encoding, also known as Code Page 949.
  20 var EUCKR encoding.Encoding = &eucKR
  21
  22 var eucKR = internal.Encoding{
  23         &internal.SimpleEncoding{eucKRDecoder{}, eucKREncoder{}},
  24         "EUC-KR",
  25         identifier.EUCKR,
  26 }
  27
  28 type eucKRDecoder struct{ transform.NopResetter }
  29
  30 func (eucKRDecoder) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
  31         r, size := rune(0), 0
  32 loop:
  33         for ; nSrc < len(src); nSrc += size {
  34                 switch c0 := src[nSrc]; {
  35                 case c0 < utf8.RuneSelf:
  36                         r, size = rune(c0), 1
  37
  38                 case 0x81 <= c0 && c0 < 0xff:
  39                         if nSrc+1 >= len(src) {
  40                                 if !atEOF {
  41                                         err = transform.ErrShortSrc
  42                                         break loop
  43                                 }
  44                                 r, size = utf8.RuneError, 1
  45                                 break
  46                         }
  47                         c1 := src[nSrc+1]
  48                         size = 2
  49                         if c0 < 0xc7 {
  50                                 r = 178 * rune(c0-0x81)
  51                                 switch {
  52                                 case 0x41 <= c1 && c1 < 0x5b:
  53                                         r += rune(c1) - (0x41 - 0*26)
  54                                 case 0x61 <= c1 && c1 < 0x7b:
  55                                         r += rune(c1) - (0x61 - 1*26)
  56                                 case 0x81 <= c1 && c1 < 0xff:
  57                                         r += rune(c1) - (0x81 - 2*26)
  58                                 default:
  59                                         goto decError
  60                                 }
  61                         } else if 0xa1 <= c1 && c1 < 0xff {
  62                                 r = 178*(0xc7-0x81) + rune(c0-0xc7)*94 + rune(c1-0xa1)
  63                         } else {
  64                                 goto decError
  65                         }
  66                         if int(r) < len(decode) {
  67                                 r = rune(decode[r])
  68                                 if r != 0 {
  69                                         break
  70                                 }
  71                         }
  72                 decError:
  73                         r = utf8.RuneError
  74                         if c1 < utf8.RuneSelf {
  75                                 size = 1
  76                         }
  77
  78                 default:
  79                         r, size = utf8.RuneError, 1
  80                         break
  81                 }
  82
  83                 if nDst+utf8.RuneLen(r) > len(dst) {
  84                         err = transform.ErrShortDst
  85                         break
  86                 }
  87                 nDst += utf8.EncodeRune(dst[nDst:], r)
  88         }
  89         return nDst, nSrc, err
  90 }
  91
  92 type eucKREncoder struct{ transform.NopResetter }
  93
  94 func (eucKREncoder) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
  95         r, size := rune(0), 0
  96         for ; nSrc < len(src); nSrc += size {
  97                 r = rune(src[nSrc])
  98
  99                 // Decode a 1-byte rune.
 100                 if r < utf8.RuneSelf {
 101                         size = 1
 102
 103                         if nDst >= len(dst) {
 104                                 err = transform.ErrShortDst
 105                                 break
 106                         }
 107                         dst[nDst] = uint8(r)
 108                         nDst++
 109                         continue
 110
 111                 } else {
 112                         // Decode a multi-byte rune.
 113                         r, size = utf8.DecodeRune(src[nSrc:])
 114                         if size == 1 {
 115                                 // All valid runes of size 1 (those below utf8.RuneSelf) were
 116                                 // handled above. We have invalid UTF-8 or we haven't seen the
 117                                 // full character yet.
 118                                 if !atEOF && !utf8.FullRune(src[nSrc:]) {
 119                                         err = transform.ErrShortSrc
 120                                         break
 121                                 }
 122                         }
 123
 124                         // func init checks that the switch covers all tables.
 125                         switch {
 126                         case encode0Low <= r && r < encode0High:
 127                                 if r = rune(encode0[r-encode0Low]); r != 0 {
 128                                         goto write2
 129                                 }
 130                         case encode1Low <= r && r < encode1High:
 131                                 if r = rune(encode1[r-encode1Low]); r != 0 {
 132                                         goto write2
 133                                 }
 134                         case encode2Low <= r && r < encode2High:
 135                                 if r = rune(encode2[r-encode2Low]); r != 0 {
 136                                         goto write2
 137                                 }
 138                         case encode3Low <= r && r < encode3High:
 139                                 if r = rune(encode3[r-encode3Low]); r != 0 {
 140                                         goto write2
 141                                 }
 142                         case encode4Low <= r && r < encode4High:
 143                                 if r = rune(encode4[r-encode4Low]); r != 0 {
 144                                         goto write2
 145                                 }
 146                         case encode5Low <= r && r < encode5High:
 147                                 if r = rune(encode5[r-encode5Low]); r != 0 {
 148                                         goto write2
 149                                 }
 150                         case encode6Low <= r && r < encode6High:
 151                                 if r = rune(encode6[r-encode6Low]); r != 0 {
 152                                         goto write2
 153                                 }
 154                         }
 155                         err = internal.ErrASCIIReplacement
 156                         break
 157                 }
 158
 159         write2:
 160                 if nDst+2 > len(dst) {
 161                         err = transform.ErrShortDst
 162                         break
 163                 }
 164                 dst[nDst+0] = uint8(r >> 8)
 165                 dst[nDst+1] = uint8(r)
 166                 nDst += 2
 167                 continue
 168         }
 169         return nDst, nSrc, err
 170 }
 171
 172 func init() {
 173         // Check that the hard-coded encode switch covers all tables.
 174         if numEncodeTables != 7 {
 175                 panic("bad numEncodeTables")
 176         }
 177 }