1// Copyright 2010 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 utf16 implements encoding and decoding of UTF-16 sequences. 6package utf16 7 8// The conditions replacementChar==unicode.ReplacementChar and 9// maxRune==unicode.MaxRune are verified in the tests. 10// Defining them locally avoids this package depending on package unicode. 11 12const ( 13 replacementChar = '\uFFFD' // Unicode replacement character 14 maxRune = '\U0010FFFF' // Maximum valid Unicode code point. 15) 16 17const ( 18 // 0xd800-0xdc00 encodes the high 10 bits of a pair. 19 // 0xdc00-0xe000 encodes the low 10 bits of a pair. 20 // the value is those 20 bits plus 0x10000. 21 surr1 = 0xd800 22 surr2 = 0xdc00 23 surr3 = 0xe000 24 25 surrSelf = 0x10000 26) 27 28// IsSurrogate reports whether the specified Unicode code point 29// can appear in a surrogate pair. 30func IsSurrogate(r rune) bool { 31 return surr1 <= r && r < surr3 32} 33 34// DecodeRune returns the UTF-16 decoding of a surrogate pair. 35// If the pair is not a valid UTF-16 surrogate pair, DecodeRune returns 36// the Unicode replacement code point U+FFFD. 37func DecodeRune(r1, r2 rune) rune { 38 if surr1 <= r1 && r1 < surr2 && surr2 <= r2 && r2 < surr3 { 39 return (r1-surr1)<<10 | (r2 - surr2) + surrSelf 40 } 41 return replacementChar 42} 43 44// EncodeRune returns the UTF-16 surrogate pair r1, r2 for the given rune. 45// If the rune is not a valid Unicode code point or does not need encoding, 46// EncodeRune returns U+FFFD, U+FFFD. 47func EncodeRune(r rune) (r1, r2 rune) { 48 if r < surrSelf || r > maxRune { 49 return replacementChar, replacementChar 50 } 51 r -= surrSelf 52 return surr1 + (r>>10)&0x3ff, surr2 + r&0x3ff 53} 54 55// Encode returns the UTF-16 encoding of the Unicode code point sequence s. 56func Encode(s []rune) []uint16 { 57 n := len(s) 58 for _, v := range s { 59 if v >= surrSelf { 60 n++ 61 } 62 } 63 64 a := make([]uint16, n) 65 n = 0 66 for _, v := range s { 67 switch { 68 case 0 <= v && v < surr1, surr3 <= v && v < surrSelf: 69 // normal rune 70 a[n] = uint16(v) 71 n++ 72 case surrSelf <= v && v <= maxRune: 73 // needs surrogate sequence 74 r1, r2 := EncodeRune(v) 75 a[n] = uint16(r1) 76 a[n+1] = uint16(r2) 77 n += 2 78 default: 79 a[n] = uint16(replacementChar) 80 n++ 81 } 82 } 83 return a[:n] 84} 85 86// Decode returns the Unicode code point sequence represented 87// by the UTF-16 encoding s. 88func Decode(s []uint16) []rune { 89 a := make([]rune, len(s)) 90 n := 0 91 for i := 0; i < len(s); i++ { 92 switch r := s[i]; { 93 case r < surr1, surr3 <= r: 94 // normal rune 95 a[n] = rune(r) 96 case surr1 <= r && r < surr2 && i+1 < len(s) && 97 surr2 <= s[i+1] && s[i+1] < surr3: 98 // valid surrogate sequence 99 a[n] = DecodeRune(rune(r), rune(s[i+1])) 100 i++ 101 default: 102 // invalid surrogate sequence 103 a[n] = replacementChar 104 } 105 n++ 106 } 107 return a[:n] 108} 109