github.com/graybobo/golang.org-package-offline-cache@v0.0.0-20200626051047-6608995c132f/x/text/encoding/korean/euckr.go (about)

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