// Copyright 2015 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 runes import ( "unicode/utf8" "golang.org/x/text/transform" ) // Note: below we pass invalid UTF-8 to the tIn and tNotIn transformers as is. // This is done for various reasons: // - To retain the semantics of the Nop transformer: if input is passed to a Nop // one would expect it to be unchanged. // - It would be very expensive to pass a converted RuneError to a transformer: // a transformer might need more source bytes after RuneError, meaning that // the only way to pass it safely is to create a new buffer and manage the // intermingling of RuneErrors and normal input. // - Many transformers leave ill-formed UTF-8 as is, so this is not // inconsistent. Generally ill-formed UTF-8 is only replaced if it is a // logical consequence of the operation (as for Map) or if it otherwise would // pose security concerns (as for Remove). // - An alternative would be to return an error on ill-formed UTF-8, but this // would be inconsistent with other operations. // If returns a transformer that applies tIn to consecutive runes for which // s.Contains(r) and tNotIn to consecutive runes for which !s.Contains(r). Reset // is called on tIn and tNotIn at the start of each run. A Nop transformer will // substitute a nil value passed to tIn or tNotIn. Invalid UTF-8 is translated // to RuneError to determine which transformer to apply, but is passed as is to // the respective transformer. func If(s Set, tIn, tNotIn transform.Transformer) Transformer { if tIn == nil && tNotIn == nil { return Transformer{transform.Nop} } if tIn == nil { tIn = transform.Nop } if tNotIn == nil { tNotIn = transform.Nop } sIn, ok := tIn.(transform.SpanningTransformer) if !ok { sIn = dummySpan{tIn} } sNotIn, ok := tNotIn.(transform.SpanningTransformer) if !ok { sNotIn = dummySpan{tNotIn} } a := &cond{ tIn: sIn, tNotIn: sNotIn, f: s.Contains, } a.Reset() return Transformer{a} } type dummySpan struct{ transform.Transformer } func (d dummySpan) Span(src []byte, atEOF bool) (n int, err error) { return 0, transform.ErrEndOfSpan } type cond struct { tIn, tNotIn transform.SpanningTransformer f func(rune) bool check func(rune) bool // current check to perform t transform.SpanningTransformer // current transformer to use } // Reset implements transform.Transformer. func (t *cond) Reset() { t.check = t.is t.t = t.tIn t.t.Reset() // notIn will be reset on first usage. } func (t *cond) is(r rune) bool { if t.f(r) { return true } t.check = t.isNot t.t = t.tNotIn t.tNotIn.Reset() return false } func (t *cond) isNot(r rune) bool { if !t.f(r) { return true } t.check = t.is t.t = t.tIn t.tIn.Reset() return false } // This implementation of Span doesn't help all too much, but it needs to be // there to satisfy this package's Transformer interface. // TODO: there are certainly room for improvements, though. For example, if // t.t == transform.Nop (which will a common occurrence) it will save a bundle // to special-case that loop. func (t *cond) Span(src []byte, atEOF bool) (n int, err error) { p := 0 for n < len(src) && err == nil { // Don't process too much at a time as the Spanner that will be // called on this block may terminate early. const maxChunk = 4096 max := len(src) if v := n + maxChunk; v < max { max = v } atEnd := false size := 0 current := t.t for ; p < max; p += size { r := rune(src[p]) if r < utf8.RuneSelf { size = 1 } else if r, size = utf8.DecodeRune(src[p:]); size == 1 { if !atEOF && !utf8.FullRune(src[p:]) { err = transform.ErrShortSrc break } } if !t.check(r) { // The next rune will be the start of a new run. atEnd = true break } } n2, err2 := current.Span(src[n:p], atEnd || (atEOF && p == len(src))) n += n2 if err2 != nil { return n, err2 } // At this point either err != nil or t.check will pass for the rune at p. p = n + size } return n, err } func (t *cond) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) { p := 0 for nSrc < len(src) && err == nil { // Don't process too much at a time, as the work might be wasted if the // destination buffer isn't large enough to hold the result or a // transform returns an error early. const maxChunk = 4096 max := len(src) if n := nSrc + maxChunk; n < len(src) { max = n } atEnd := false size := 0 current := t.t for ; p < max; p += size { r := rune(src[p]) if r < utf8.RuneSelf { size = 1 } else if r, size = utf8.DecodeRune(src[p:]); size == 1 { if !atEOF && !utf8.FullRune(src[p:]) { err = transform.ErrShortSrc break } } if !t.check(r) { // The next rune will be the start of a new run. atEnd = true break } } nDst2, nSrc2, err2 := current.Transform(dst[nDst:], src[nSrc:p], atEnd || (atEOF && p == len(src))) nDst += nDst2 nSrc += nSrc2 if err2 != nil { return nDst, nSrc, err2 } // At this point either err != nil or t.check will pass for the rune at p. p = nSrc + size } return nDst, nSrc, err }