func (field_editor *FieldEditor) handleKeyEvent(event termbox.Event) (string, bool) {
is_done := false
if event.Key == termbox.KeyEnter {
is_done = true
} else if event.Key == termbox.KeyEsc {
is_done = true
field_editor.value = nil
} else if event.Key == termbox.KeyArrowLeft {
if field_editor.cursor_pos > 0 {
field_editor.cursor_pos--
}
} else if event.Key == termbox.KeyArrowUp || event.Key == termbox.KeyCtrlA {
field_editor.cursor_pos = 0
} else if event.Key == termbox.KeyArrowRight {
if field_editor.cursor_pos < utf8.RuneCount(field_editor.value) {
field_editor.cursor_pos++
}
} else if event.Key == termbox.KeyArrowDown || event.Key == termbox.KeyCtrlE {
field_editor.cursor_pos = utf8.RuneCount(field_editor.value)
} else if event.Key == termbox.KeyCtrlH || event.Key == termbox.KeyBackspace {
if field_editor.cursor_pos > 0 {
field_editor.value = removeRuneAtIndex(field_editor.value, field_editor.cursor_pos-1)
field_editor.cursor_pos--
}
} else if unicode.IsPrint(event.Ch) {
field_editor.value = insertRuneAtIndex(field_editor.value, field_editor.cursor_pos, event.Ch)
field_editor.cursor_pos++
} else if event.Key == termbox.KeySpace {
field_editor.value = insertRuneAtIndex(field_editor.value, field_editor.cursor_pos, ' ')
field_editor.cursor_pos++
}
return string(field_editor.value), is_done
}
// parseStringToken takes a token of either LITERAL or STRING type and
// returns the interpreted string, after processing any relevant
// escape sequences.
func (p *parser) parseStringToken(tok *scanner.Token) (string, error) {
var backslashes bool
switch tok.Type {
case scanner.LITERAL:
backslashes = false
case scanner.STRING:
backslashes = true
default:
panic("unsupported string token type")
}
raw := []byte(tok.Content)
buf := make([]byte, 0, len(raw))
for i := 0; i < len(raw); i++ {
b := raw[i]
more := len(raw) > (i + 1)
if b == '$' {
if more && raw[i+1] == '$' {
// skip over the second dollar sign
i++
}
} else if backslashes && b == '\\' {
if !more {
return "", Errorf(
ast.Pos{
Column: tok.Pos.Column + utf8.RuneCount(raw[:i]),
Line: tok.Pos.Line,
},
`unfinished backslash escape sequence`,
)
}
escapeType := raw[i+1]
switch escapeType {
case '\\':
// skip over the second slash
i++
case 'n':
b = '\n'
i++
case '"':
b = '"'
i++
default:
return "", Errorf(
ast.Pos{
Column: tok.Pos.Column + utf8.RuneCount(raw[:i]),
Line: tok.Pos.Line,
},
`invalid backslash escape sequence`,
)
}
}
buf = append(buf, b)
}
return string(buf), nil
}
func (v *RuneCountValidator) Validate(value string, criteria *Criteria) (bool, error) {
if criteria == nil {
return false, errors.New("Criteria for 'rune_count' not enough")
}
if criteria.Has("eq") {
eq, err := criteria.Int("eq")
if err != nil {
return false, err
}
return utf8.RuneCount([]byte(value)) == eq, nil
} else if criteria.Has("to") && criteria.Has("from") {
to, err := criteria.Int("to")
if err != nil {
return false, err
}
from, err := criteria.Int("from")
if err != nil {
return false, err
}
count := utf8.RuneCount([]byte(value))
return count >= from && count <= to, nil
} else {
return false, errors.New("Criteria for 'rune_count' not enough")
}
}
func Timeline(screen_name string, since_id int64) []Post {
var posts = []Post{}
for _, p := range sina.TimeLine(0, screen_name, since_id, 20) {
id := p.Id
text := p.Text
link := ""
if p.Original_Pic != "" {
link = " ✈ " + p.Original_Pic
}
if p.Retweeted_Status != nil {
if p.Retweeted_Status.User != nil {
re_user := p.Retweeted_Status.User
text = text + " //RT @" + re_user.Name + ": " + p.Retweeted_Status.Text
}
if p.Retweeted_Status.Original_Pic != "" {
link = " ✈ " + p.Retweeted_Status.Original_Pic
}
}
len1 := utf8.RuneCount([]byte(text))
len2 := utf8.RuneCount([]byte(link))
if len1+len2 > 140 {
link2 := fmt.Sprintf("http://weibo.com/%d/%s", p.User.Id, sina.QueryMid(id, 1))
text = SubStringByChar(text, 140-38-len2) + link + " " + link2
} else {
text = text + link
}
posts = append(posts, Post{id, text})
}
return posts
}
func (v *jsonSchema) validateString(currentSchema *jsonSchema, value interface{}, result *ValidationResult, context *jsonContext) {
// Ignore non strings
if !isKind(value, reflect.String) {
return
}
stringValue := value.(string)
// minLength & maxLength:
if currentSchema.minLength != nil {
if utf8.RuneCount([]byte(stringValue)) < *currentSchema.minLength {
result.addError(context, value, fmt.Sprintf(ERROR_MESSAGE_STRING_LENGTH_MUST_BE_GREATER_OR_EQUAL, *currentSchema.minLength))
}
}
if currentSchema.maxLength != nil {
if utf8.RuneCount([]byte(stringValue)) > *currentSchema.maxLength {
result.addError(context, value, fmt.Sprintf(ERROR_MESSAGE_STRING_LENGTH_MUST_BE_LOWER_OR_EQUAL, *currentSchema.maxLength))
}
}
// pattern:
if currentSchema.pattern != nil {
if !currentSchema.pattern.MatchString(stringValue) {
result.addError(context, value, fmt.Sprintf(ERROR_MESSAGE_DOES_NOT_MATCH_PATTERN, currentSchema.pattern))
}
}
result.incrementScore()
}
func (v *subSchema) validateString(currentSubSchema *subSchema, value interface{}, result *Result, context *jsonContext) {
internalLog("validateString %s", context.String())
internalLog(" %v", value)
// Ignore non strings
if !isKind(value, reflect.String) {
return
}
stringValue := value.(string)
// minLength & maxLength:
if currentSubSchema.minLength != nil {
if utf8.RuneCount([]byte(stringValue)) < *currentSubSchema.minLength {
result.addError(
new(StringLengthGTEError),
context,
value,
ErrorDetails{"min": *currentSubSchema.minLength},
)
}
}
if currentSubSchema.maxLength != nil {
if utf8.RuneCount([]byte(stringValue)) > *currentSubSchema.maxLength {
result.addError(
new(StringLengthLTEError),
context,
value,
ErrorDetails{"max": *currentSubSchema.maxLength},
)
}
}
// pattern:
if currentSubSchema.pattern != nil {
if matcher := currentSubSchema.pattern.MatcherString(stringValue, 0); !matcher.Matches() {
result.addError(
new(DoesNotMatchPatternError),
context,
value,
ErrorDetails{"pattern": currentSubSchema.patternString},
)
}
}
// format
if currentSubSchema.format != "" {
if !FormatCheckers.IsFormat(currentSubSchema.format, stringValue) {
result.addError(
new(DoesNotMatchFormatError),
context,
value,
ErrorDetails{"format": currentSubSchema.format},
)
}
}
result.incrementScore()
}
func Timeline(access_token string, screen_name string, since_id int64) []Post {
url := "https://api.weibo.com/2/statuses/user_timeline.json?access_token=" + access_token
url += fmt.Sprintf("&screen_name=%s&since_id=%d", screen_name, since_id)
//url = "http://www.baidu.com"
resp, err := http.Get(url)
if err != nil {
log.Fatal(url, err)
}
defer resp.Body.Close()
bytes, _ := ioutil.ReadAll(resp.Body)
log.Println(url)
var posts = []Post{}
if resp.StatusCode == 200 {
var data map[string]interface{}
json.Unmarshal(bytes, &data)
// log.Println(string(bytes))
if data["statuses"] != nil {
for _, entry := range data["statuses"].([]interface{}) {
entry := entry.(map[string]interface{})
id, _ := strconv.ParseInt(entry["idstr"].(string), 10, 64)
text := entry["text"].(string)
link := ""
if entry["original_pic"] != nil {
link = " ✈ " + entry["original_pic"].(string)
}
if entry["retweeted_status"] != nil {
retweeted := entry["retweeted_status"].(map[string]interface{})
if retweeted["user"] != nil {
re_user := retweeted["user"].(map[string]interface{})
text = text + " //RT @" + re_user["name"].(string) + ": " + retweeted["text"].(string)
}
if retweeted["original_pic"] != nil {
link = " ✈ " + retweeted["original_pic"].(string)
}
}
len1 := utf8.RuneCount([]byte(text))
len2 := utf8.RuneCount([]byte(link))
if len1+len2 > 140 {
text = SubStringByChar(text, 140-len2) + link
} else {
text = text + link
}
posts = append(posts, Post{id, text})
}
}
} else {
log.Fatal(string(bytes))
}
return posts
}
func extractColor(str string, state *ansiState, proc func(string, *ansiState) bool) (string, *[]ansiOffset, *ansiState) {
var offsets []ansiOffset
var output bytes.Buffer
if state != nil {
offsets = append(offsets, ansiOffset{[2]int32{0, 0}, *state})
}
idx := 0
for _, offset := range ansiRegex.FindAllStringIndex(str, -1) {
prev := str[idx:offset[0]]
output.WriteString(prev)
if proc != nil && !proc(prev, state) {
return "", nil, nil
}
newState := interpretCode(str[offset[0]:offset[1]], state)
if !newState.equals(state) {
if state != nil {
// Update last offset
(&offsets[len(offsets)-1]).offset[1] = int32(utf8.RuneCount(output.Bytes()))
}
if newState.colored() {
// Append new offset
state = newState
newLen := int32(utf8.RuneCount(output.Bytes()))
offsets = append(offsets, ansiOffset{[2]int32{newLen, newLen}, *state})
} else {
// Discard state
state = nil
}
}
idx = offset[1]
}
rest := str[idx:]
if len(rest) > 0 {
output.WriteString(rest)
if state != nil {
// Update last offset
(&offsets[len(offsets)-1]).offset[1] = int32(utf8.RuneCount(output.Bytes()))
}
}
if proc != nil {
proc(rest, state)
}
if len(offsets) == 0 {
return output.String(), nil, state
}
return output.String(), &offsets, state
}
// Encode takes payload, encodes it and writes it to dst. Payload must be one
// of the following: a heartbeat, a handshake, []byte, string, int or anything
// than can be marshalled by the default json package. If payload can't be
// encoded or the writing fails, an error will be returned.
func (enc *sioEncoder) Encode(dst io.Writer, payload interface{}) (err error) {
enc.elem.Reset()
switch t := payload.(type) {
case heartbeat:
s := strconv.Itoa(int(t))
_, err = fmt.Fprintf(dst, "%s%d%s%s%s", sioFrameDelim, len(s)+len(sioFrameDelimHeartbeat), sioFrameDelim, sioFrameDelimHeartbeat, s)
case handshake:
_, err = fmt.Fprintf(dst, "%s%d%s%s", sioFrameDelim, len(t), sioFrameDelim, t)
case []byte:
l := utf8.RuneCount(t)
if l == 0 {
break
}
_, err = fmt.Fprintf(dst, "%s%d%s%s", sioFrameDelim, l, sioFrameDelim, t)
case string:
l := utf8.RuneCountInString(t)
if l == 0 {
break
}
_, err = fmt.Fprintf(dst, "%s%d%s%s", sioFrameDelim, l, sioFrameDelim, t)
case int:
s := strconv.Itoa(t)
if s == "" {
break
}
_, err = fmt.Fprintf(dst, "%s%d%s%s", sioFrameDelim, len(s), sioFrameDelim, s)
default:
data, err := json.Marshal(payload)
if len(data) == 0 || err != nil {
break
}
err = json.Compact(&enc.elem, data)
if err != nil {
break
}
_, err = fmt.Fprintf(dst, "%s%d%s%s", sioFrameDelim, utf8.RuneCount(enc.elem.Bytes())+len(sioFrameDelimJSON), sioFrameDelim, sioFrameDelimJSON)
if err == nil {
_, err = enc.elem.WriteTo(dst)
}
}
return err
}
func makeFakeData(size1, size2 int) ([]byte, Annotations) {
input := []byte(strings.Repeat(strings.Repeat("a", size1)+"⌘", size2))
inputLength := utf8.RuneCount(input)
n := len(input)/2 - (size1+1)/2
anns := make(Annotations, n)
for i := 0; i < n; i++ {
if i%2 == 0 {
anns[i] = &Annotation{Start: 2 * i, End: 2*i + 1}
} else {
anns[i] = &Annotation{Start: 2*i - 50, End: 2*i + 50}
if anns[i].Start < 0 {
anns[i].Start = 0
anns[i].End = i
}
if anns[i].End >= inputLength {
anns[i].End = inputLength
}
}
anns[i].Left = []byte("L") //[]byte(strings.Repeat("L", i%20))
anns[i].Right = []byte("R") //[]byte(strings.Repeat("R", i%20))
anns[i].WantInner = i % 5
}
sort.Sort(anns)
return input, anns
}
// Render cell as text.
// As a special case a cell that is nil is treated as an empty cell.
func (cell *Cell) renderText(cellWidth int) []byte {
if cell == nil {
return fill(' ', cellWidth)
}
buf := make([]byte, 0)
if cell.PadLeft > 0 {
buf = append(buf, fill(' ', int(cell.PadLeft))...)
}
buf = append(buf, cell.Content...)
if cell.PadRight > 0 {
buf = append(buf, fill(' ', int(cell.PadRight))...)
}
pad := cellWidth - utf8.RuneCount(buf)
var padLeft, padRight int
switch cell.Align {
case AlignRight:
padLeft = pad
case AlignCenter:
// Pad with a bias of more padding to the right.
padLeft = pad / 2
padRight = pad - padLeft
default:
// Since it's possible to pass values other than the specified
// constants use AlignLeft as the default.
padRight = pad
}
buf = append(buf, fill(' ', padRight)...)
return append(fill(' ', padLeft), buf...)
}
func (s *CJKWidthFilter) Filter(input analysis.TokenStream) analysis.TokenStream {
for _, token := range input {
runeCount := utf8.RuneCount(token.Term)
runes := bytes.Runes(token.Term)
for i := 0; i < runeCount; i++ {
ch := runes[i]
if ch >= 0xFF01 && ch <= 0xFF5E {
// fullwidth ASCII variants
runes[i] -= 0xFEE0
} else if ch >= 0xFF65 && ch <= 0xFF9F {
// halfwidth Katakana variants
if (ch == 0xFF9E || ch == 0xFF9F) && i > 0 && combine(runes, i, ch) {
runes = analysis.DeleteRune(runes, i)
i--
runeCount = len(runes)
} else {
runes[i] = kanaNorm[ch-0xFF65]
}
}
}
token.Term = analysis.BuildTermFromRunes(runes)
}
return input
}
func CountChar(str string) (int, int) {
b := []byte(str)
// int bytes = len(b)
var bytes int = len(b)
var runes int = utf8.RuneCount(b)
return bytes, runes
}
func tabsToSpaces(in []byte, tabsize int) []byte {
if bytes.IndexByte(in, '\t') == -1 {
return in
}
spaces := bytes.Repeat([]byte(" "), tabsize)
var out []byte
i := bytes.IndexAny(in, "\n\r\f\t")
col := 0
for i != -1 {
out = append(out, in[:i]...)
col += utf8.RuneCount(in[:i])
if in[i] == '\t' {
nspaces := tabsize - (col % tabsize)
out = append(out, spaces[:nspaces]...)
col += nspaces
} else {
// line feed
out = append(out, in[i])
col = 0
}
in = in[i+1:]
i = bytes.IndexAny(in, "\n\r\f\t")
}
return append(out, in...)
}
func TestTextState(t *testing.T) {
gen := new(testGenerator)
p := NewParser(gen)
data := parserData{isTagLine: false, asIs: false, parseText: true, tagMode: tagModeLtGt}
text := "txt <"
buf := bytes.NewBufferString(text)
i := 0
charsInBuf := utf8.RuneCount(buf.Bytes())
for r, _, err := buf.ReadRune(); err == nil; r, _, err = buf.ReadRune() {
if st, err := p.states[stText].processChar(r, gen, &data); err == nil {
if i == charsInBuf-1 {
if st != stInlineTag {
t.Error(fmt.Sprintf("In %s at %d state %d must be %d.", text, i, st, stInlineTag))
t.Fail()
}
} else if st != stText {
t.Error(fmt.Sprintf("In %s at %d state %d must be %d.", text, i, st, stText))
t.Fail()
}
} else {
t.Error(fmt.Sprintf("Error on %s at %d %s.", text, i, err.String()))
t.Fail()
}
i++
}
}
func (s *NgramFilter) Filter(input analysis.TokenStream) analysis.TokenStream {
rv := make(analysis.TokenStream, 0, len(input))
for _, token := range input {
runeCount := utf8.RuneCount(token.Term)
runes := bytes.Runes(token.Term)
for i := 0; i < runeCount; i++ {
// index of the starting rune for this token
for ngramSize := s.minLength; ngramSize <= s.maxLength; ngramSize++ {
// build an ngram of this size starting at i
if i+ngramSize <= runeCount {
ngramTerm := buildTermFromRunes(runes[i : i+ngramSize])
token := analysis.Token{
Position: token.Position,
Start: token.Start,
End: token.End,
Type: token.Type,
Term: ngramTerm,
}
rv = append(rv, &token)
}
}
}
}
return rv
}
func StrPos(str string, sep string) int64 {
//indez := bytes.Index([]byte(str), []byte(sep))
indez := strings.Index(str, sep)
var index int64 = -1
if indez != -1 {
index = int64(utf8.RuneCount([]byte(str)[:indez]))
//fmt.Println(index, index2, str[index:index+len(sep)])
}
return index
/*rstr := []rune(sep)[0]
return int64(strings.Index(str, sep))
*/
/*
n := len(sep)
fmt.Println(n)
if n == 0 {
return 0
}
c := sep[0]
if n == 1 {
for i, k := range rs {
if strs[i] == c {
fmt.Println(k)
fmt.Println(i)
return int64(i)
}
}
}
return -1
*/
}
// Count counts the number of non-overlapping instances of sep in s.
func Count(s, sep []byte) int {
n := len(sep)
if n == 0 {
return utf8.RuneCount(s) + 1
}
if n > len(s) {
return 0
}
count := 0
c := sep[0]
i := 0
t := s[:len(s)-n+1]
for i < len(t) {
if t[i] != c {
o := IndexByte(t[i:], c)
if o < 0 {
break
}
i += o
}
if n == 1 || Equal(s[i:i+n], sep) {
count++
i += n
continue
}
i++
}
return count
}
// NewCanvas returns an initialized Canvas.
func NewCanvas(data []byte) *Canvas {
c := &Canvas{}
c.rawData = data
lines := bytes.Split(data, []byte("\n"))
c.size.Y = len(lines)
for _, line := range lines {
if i := utf8.RuneCount(line); i > c.size.X {
c.size.X = i
}
}
for _, line := range lines {
t := make([]char, c.size.X)
i := 0
for len(line) > 0 {
r, l := utf8.DecodeRune(line)
t[i] = char(r)
i++
line = line[l:]
}
for ; i < c.size.X; i++ {
t[i] = ' '
}
c.grid = append(c.grid, t)
}
return c
}
// MinLength validates a string for minimum length
func MinLength(path, in, data string, minLength int64) *errors.Validation {
strLen := int64(utf8.RuneCount([]byte(data)))
if strLen < minLength {
return errors.TooShort(path, in, minLength)
}
return nil
}
// MaxLength validates a string for maximum length
func MaxLength(path, in, data string, maxLength int64) *errors.Validation {
strLen := int64(utf8.RuneCount([]byte(data)))
if strLen > maxLength {
return errors.TooLong(path, in, maxLength)
}
return nil
}
func (f *File) SetByteOffsetsForContent(content []byte) {
offset := 0
if len(content) >= 3 {
if bytes.HasPrefix(content, utf8bom) {
content = content[3:]
offset = 3
}
}
s := string(content)
byteOffsetOfRune := make([]int, utf8.RuneCount(content))
i := 0
for b, _ := range s {
byteOffsetOfRune[i] = b + offset
i++
}
f.numRunes = len(byteOffsetOfRune)
// set lines table
f.set.mutex.Lock()
f.byteOffsetOfRune = byteOffsetOfRune
f.set.mutex.Unlock()
}
// Q3. (1) string
func Q3() {
// 1
str := "A"
for i := 1; i <= 10; i++ {
fmt.Printf("%s\n", str)
str = str + "A"
}
// 2
var s string = "asSASA ddd dsjkdsjs dk"
fmt.Println(len(s), " ", utf8.RuneCount([]byte(s)))
// 3
//s3 := strings.Replace(s, s[4:7], "abc", 3)
s3 := []byte(s)
copy(s3[4:4+3], []byte("abc"))
fmt.Println(string(s3))
// 4
var s4 string = "foobar"
reverse := func(s string) string {
array := []byte(s)
for i, j := 0, len(array)-1; i < j; i, j = i+1, j-1 {
array[i], array[j] = array[j], array[i]
}
return string(array)
}
s5 := reverse(s4)
fmt.Println(s5)
}
func (f *DictionaryCompoundFilter) decompose(token *analysis.Token) []*analysis.Token {
runes := bytes.Runes(token.Term)
rv := make([]*analysis.Token, 0)
rlen := len(runes)
for i := 0; i <= (rlen - f.minSubWordSize); i++ {
var longestMatchToken *analysis.Token
for j := f.minSubWordSize; j <= f.maxSubWordSize; j++ {
if i+j > rlen {
break
}
_, inDict := f.dict[string(runes[i:i+j])]
if inDict {
newtoken := analysis.Token{
Term: []byte(string(runes[i : i+j])),
Position: token.Position,
Start: token.Start + i,
End: token.Start + i + j,
Type: token.Type,
KeyWord: token.KeyWord,
}
if f.onlyLongestMatch {
if longestMatchToken == nil || utf8.RuneCount(longestMatchToken.Term) < j {
longestMatchToken = &newtoken
}
} else {
rv = append(rv, &newtoken)
}
}
}
if f.onlyLongestMatch && longestMatchToken != nil {
rv = append(rv, longestMatchToken)
}
}
return rv
}
func (m *Message) writeRecipient(b *bytes.Buffer) {
if m.From != "" {
fmt.Fprintf(b, "From: %s %s", m.From, NewLine)
}
if m.ReplyTo != "" {
fmt.Fprintf(b, "Reply-To: %s %s", m.ReplyTo, NewLine)
}
if len(m.To) > 0 {
fmt.Fprintf(b, "To: %s %s", strings.Join(m.To, ", "), NewLine)
}
if len(m.Cc) > 0 {
fmt.Fprintf(b, "Cc: %s %s", strings.Join(m.Cc, ", "), NewLine)
}
if m.Subject != "" {
subjectBytes := []byte(m.Subject)
if len(subjectBytes) == utf8.RuneCount(subjectBytes) {
fmt.Fprintf(b, "Subject: %s %s", m.Subject, NewLine)
} else {
fmt.Fprintf(b, "Subject: =?UTF-8?B?%s?= %s", base64.StdEncoding.EncodeToString(subjectBytes), NewLine)
}
}
}
// extractLetterSequence extracts first word (sequence of letters ending with a non-letter)
// starting with the specified index and wraps it to dateStringLayoutItem according to the type
// of the word.
func extractLetterSequence(originalStr string, index int) (it dateStringLayoutItem) {
letters := ""
bytesToParse := []byte(originalStr[index:])
runeCount := utf8.RuneCount(bytesToParse)
var isWord bool
var isDigit bool
for i := 0; i < runeCount; i++ {
rune, runeSize := utf8.DecodeRune(bytesToParse)
bytesToParse = bytesToParse[runeSize:]
if i == 0 {
isWord = unicode.IsLetter(rune)
isDigit = unicode.IsDigit(rune)
} else {
if (isWord && (!unicode.IsLetter(rune) && !unicode.IsDigit(rune))) ||
(isDigit && !unicode.IsDigit(rune)) ||
(!isWord && unicode.IsLetter(rune)) ||
(!isDigit && unicode.IsDigit(rune)) {
break
}
}
letters += string(rune)
}
it.item = letters
it.isWord = isWord
it.isDigit = isDigit
return
}
func main() {
s := "abcdefg韩"
s1 := s[:4] + "abc" + s[7:]
fmt.Printf("The string [%s] has %v unicode characters\n", s, utf8.RuneCount([]byte(s)))
fmt.Printf("The string [%s] has %v bytes\n", s, len(s))
fmt.Printf("The old string [%s] new string [%s]\n", s, s1)
}
func ExampleRuneCount() {
buf := []byte("Hello, 世界")
fmt.Println("bytes =", len(buf))
fmt.Println("runes =", utf8.RuneCount(buf))
// Output:
// bytes = 13
// runes = 9
}
func (self *WordDict) AddReplaceRule(rule []byte) {
if utf8.RuneCount(rule) != 2 {
self.Panic("rule format differs from '=xX'")
}
from, fromSize := utf8.DecodeRune(rule)
to, _ := utf8.DecodeRune(rule[fromSize:])
self.runeMapping[from] = to
}
func (p *Preprocessor) calcColumn(added []byte) {
i := bytes.LastIndex(added, []byte{_LF})
if i >= 0 {
p.column = 0
added = added[i:]
}
p.column += utf8.RuneCount(added)
}
