aboutsummaryrefslogtreecommitdiff
path: root/vendor/golang.org/x/text/transform/transform.go
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/golang.org/x/text/transform/transform.go')
-rw-r--r--vendor/golang.org/x/text/transform/transform.go705
1 files changed, 0 insertions, 705 deletions
diff --git a/vendor/golang.org/x/text/transform/transform.go b/vendor/golang.org/x/text/transform/transform.go
deleted file mode 100644
index fe47b9b..0000000
--- a/vendor/golang.org/x/text/transform/transform.go
+++ /dev/null
@@ -1,705 +0,0 @@
-// Copyright 2013 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 transform provides reader and writer wrappers that transform the
-// bytes passing through as well as various transformations. Example
-// transformations provided by other packages include normalization and
-// conversion between character sets.
-package transform // import "golang.org/x/text/transform"
-
-import (
- "bytes"
- "errors"
- "io"
- "unicode/utf8"
-)
-
-var (
- // ErrShortDst means that the destination buffer was too short to
- // receive all of the transformed bytes.
- ErrShortDst = errors.New("transform: short destination buffer")
-
- // ErrShortSrc means that the source buffer has insufficient data to
- // complete the transformation.
- ErrShortSrc = errors.New("transform: short source buffer")
-
- // ErrEndOfSpan means that the input and output (the transformed input)
- // are not identical.
- ErrEndOfSpan = errors.New("transform: input and output are not identical")
-
- // errInconsistentByteCount means that Transform returned success (nil
- // error) but also returned nSrc inconsistent with the src argument.
- errInconsistentByteCount = errors.New("transform: inconsistent byte count returned")
-
- // errShortInternal means that an internal buffer is not large enough
- // to make progress and the Transform operation must be aborted.
- errShortInternal = errors.New("transform: short internal buffer")
-)
-
-// Transformer transforms bytes.
-type Transformer interface {
- // Transform writes to dst the transformed bytes read from src, and
- // returns the number of dst bytes written and src bytes read. The
- // atEOF argument tells whether src represents the last bytes of the
- // input.
- //
- // Callers should always process the nDst bytes produced and account
- // for the nSrc bytes consumed before considering the error err.
- //
- // A nil error means that all of the transformed bytes (whether freshly
- // transformed from src or left over from previous Transform calls)
- // were written to dst. A nil error can be returned regardless of
- // whether atEOF is true. If err is nil then nSrc must equal len(src);
- // the converse is not necessarily true.
- //
- // ErrShortDst means that dst was too short to receive all of the
- // transformed bytes. ErrShortSrc means that src had insufficient data
- // to complete the transformation. If both conditions apply, then
- // either error may be returned. Other than the error conditions listed
- // here, implementations are free to report other errors that arise.
- Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error)
-
- // Reset resets the state and allows a Transformer to be reused.
- Reset()
-}
-
-// SpanningTransformer extends the Transformer interface with a Span method
-// that determines how much of the input already conforms to the Transformer.
-type SpanningTransformer interface {
- Transformer
-
- // Span returns a position in src such that transforming src[:n] results in
- // identical output src[:n] for these bytes. It does not necessarily return
- // the largest such n. The atEOF argument tells whether src represents the
- // last bytes of the input.
- //
- // Callers should always account for the n bytes consumed before
- // considering the error err.
- //
- // A nil error means that all input bytes are known to be identical to the
- // output produced by the Transformer. A nil error can be be returned
- // regardless of whether atEOF is true. If err is nil, then then n must
- // equal len(src); the converse is not necessarily true.
- //
- // ErrEndOfSpan means that the Transformer output may differ from the
- // input after n bytes. Note that n may be len(src), meaning that the output
- // would contain additional bytes after otherwise identical output.
- // ErrShortSrc means that src had insufficient data to determine whether the
- // remaining bytes would change. Other than the error conditions listed
- // here, implementations are free to report other errors that arise.
- //
- // Calling Span can modify the Transformer state as a side effect. In
- // effect, it does the transformation just as calling Transform would, only
- // without copying to a destination buffer and only up to a point it can
- // determine the input and output bytes are the same. This is obviously more
- // limited than calling Transform, but can be more efficient in terms of
- // copying and allocating buffers. Calls to Span and Transform may be
- // interleaved.
- Span(src []byte, atEOF bool) (n int, err error)
-}
-
-// NopResetter can be embedded by implementations of Transformer to add a nop
-// Reset method.
-type NopResetter struct{}
-
-// Reset implements the Reset method of the Transformer interface.
-func (NopResetter) Reset() {}
-
-// Reader wraps another io.Reader by transforming the bytes read.
-type Reader struct {
- r io.Reader
- t Transformer
- err error
-
- // dst[dst0:dst1] contains bytes that have been transformed by t but
- // not yet copied out via Read.
- dst []byte
- dst0, dst1 int
-
- // src[src0:src1] contains bytes that have been read from r but not
- // yet transformed through t.
- src []byte
- src0, src1 int
-
- // transformComplete is whether the transformation is complete,
- // regardless of whether or not it was successful.
- transformComplete bool
-}
-
-const defaultBufSize = 4096
-
-// NewReader returns a new Reader that wraps r by transforming the bytes read
-// via t. It calls Reset on t.
-func NewReader(r io.Reader, t Transformer) *Reader {
- t.Reset()
- return &Reader{
- r: r,
- t: t,
- dst: make([]byte, defaultBufSize),
- src: make([]byte, defaultBufSize),
- }
-}
-
-// Read implements the io.Reader interface.
-func (r *Reader) Read(p []byte) (int, error) {
- n, err := 0, error(nil)
- for {
- // Copy out any transformed bytes and return the final error if we are done.
- if r.dst0 != r.dst1 {
- n = copy(p, r.dst[r.dst0:r.dst1])
- r.dst0 += n
- if r.dst0 == r.dst1 && r.transformComplete {
- return n, r.err
- }
- return n, nil
- } else if r.transformComplete {
- return 0, r.err
- }
-
- // Try to transform some source bytes, or to flush the transformer if we
- // are out of source bytes. We do this even if r.r.Read returned an error.
- // As the io.Reader documentation says, "process the n > 0 bytes returned
- // before considering the error".
- if r.src0 != r.src1 || r.err != nil {
- r.dst0 = 0
- r.dst1, n, err = r.t.Transform(r.dst, r.src[r.src0:r.src1], r.err == io.EOF)
- r.src0 += n
-
- switch {
- case err == nil:
- if r.src0 != r.src1 {
- r.err = errInconsistentByteCount
- }
- // The Transform call was successful; we are complete if we
- // cannot read more bytes into src.
- r.transformComplete = r.err != nil
- continue
- case err == ErrShortDst && (r.dst1 != 0 || n != 0):
- // Make room in dst by copying out, and try again.
- continue
- case err == ErrShortSrc && r.src1-r.src0 != len(r.src) && r.err == nil:
- // Read more bytes into src via the code below, and try again.
- default:
- r.transformComplete = true
- // The reader error (r.err) takes precedence over the
- // transformer error (err) unless r.err is nil or io.EOF.
- if r.err == nil || r.err == io.EOF {
- r.err = err
- }
- continue
- }
- }
-
- // Move any untransformed source bytes to the start of the buffer
- // and read more bytes.
- if r.src0 != 0 {
- r.src0, r.src1 = 0, copy(r.src, r.src[r.src0:r.src1])
- }
- n, r.err = r.r.Read(r.src[r.src1:])
- r.src1 += n
- }
-}
-
-// TODO: implement ReadByte (and ReadRune??).
-
-// Writer wraps another io.Writer by transforming the bytes read.
-// The user needs to call Close to flush unwritten bytes that may
-// be buffered.
-type Writer struct {
- w io.Writer
- t Transformer
- dst []byte
-
- // src[:n] contains bytes that have not yet passed through t.
- src []byte
- n int
-}
-
-// NewWriter returns a new Writer that wraps w by transforming the bytes written
-// via t. It calls Reset on t.
-func NewWriter(w io.Writer, t Transformer) *Writer {
- t.Reset()
- return &Writer{
- w: w,
- t: t,
- dst: make([]byte, defaultBufSize),
- src: make([]byte, defaultBufSize),
- }
-}
-
-// Write implements the io.Writer interface. If there are not enough
-// bytes available to complete a Transform, the bytes will be buffered
-// for the next write. Call Close to convert the remaining bytes.
-func (w *Writer) Write(data []byte) (n int, err error) {
- src := data
- if w.n > 0 {
- // Append bytes from data to the last remainder.
- // TODO: limit the amount copied on first try.
- n = copy(w.src[w.n:], data)
- w.n += n
- src = w.src[:w.n]
- }
- for {
- nDst, nSrc, err := w.t.Transform(w.dst, src, false)
- if _, werr := w.w.Write(w.dst[:nDst]); werr != nil {
- return n, werr
- }
- src = src[nSrc:]
- if w.n == 0 {
- n += nSrc
- } else if len(src) <= n {
- // Enough bytes from w.src have been consumed. We make src point
- // to data instead to reduce the copying.
- w.n = 0
- n -= len(src)
- src = data[n:]
- if n < len(data) && (err == nil || err == ErrShortSrc) {
- continue
- }
- }
- switch err {
- case ErrShortDst:
- // This error is okay as long as we are making progress.
- if nDst > 0 || nSrc > 0 {
- continue
- }
- case ErrShortSrc:
- if len(src) < len(w.src) {
- m := copy(w.src, src)
- // If w.n > 0, bytes from data were already copied to w.src and n
- // was already set to the number of bytes consumed.
- if w.n == 0 {
- n += m
- }
- w.n = m
- err = nil
- } else if nDst > 0 || nSrc > 0 {
- // Not enough buffer to store the remainder. Keep processing as
- // long as there is progress. Without this case, transforms that
- // require a lookahead larger than the buffer may result in an
- // error. This is not something one may expect to be common in
- // practice, but it may occur when buffers are set to small
- // sizes during testing.
- continue
- }
- case nil:
- if w.n > 0 {
- err = errInconsistentByteCount
- }
- }
- return n, err
- }
-}
-
-// Close implements the io.Closer interface.
-func (w *Writer) Close() error {
- src := w.src[:w.n]
- for {
- nDst, nSrc, err := w.t.Transform(w.dst, src, true)
- if _, werr := w.w.Write(w.dst[:nDst]); werr != nil {
- return werr
- }
- if err != ErrShortDst {
- return err
- }
- src = src[nSrc:]
- }
-}
-
-type nop struct{ NopResetter }
-
-func (nop) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
- n := copy(dst, src)
- if n < len(src) {
- err = ErrShortDst
- }
- return n, n, err
-}
-
-func (nop) Span(src []byte, atEOF bool) (n int, err error) {
- return len(src), nil
-}
-
-type discard struct{ NopResetter }
-
-func (discard) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
- return 0, len(src), nil
-}
-
-var (
- // Discard is a Transformer for which all Transform calls succeed
- // by consuming all bytes and writing nothing.
- Discard Transformer = discard{}
-
- // Nop is a SpanningTransformer that copies src to dst.
- Nop SpanningTransformer = nop{}
-)
-
-// chain is a sequence of links. A chain with N Transformers has N+1 links and
-// N+1 buffers. Of those N+1 buffers, the first and last are the src and dst
-// buffers given to chain.Transform and the middle N-1 buffers are intermediate
-// buffers owned by the chain. The i'th link transforms bytes from the i'th
-// buffer chain.link[i].b at read offset chain.link[i].p to the i+1'th buffer
-// chain.link[i+1].b at write offset chain.link[i+1].n, for i in [0, N).
-type chain struct {
- link []link
- err error
- // errStart is the index at which the error occurred plus 1. Processing
- // errStart at this level at the next call to Transform. As long as
- // errStart > 0, chain will not consume any more source bytes.
- errStart int
-}
-
-func (c *chain) fatalError(errIndex int, err error) {
- if i := errIndex + 1; i > c.errStart {
- c.errStart = i
- c.err = err
- }
-}
-
-type link struct {
- t Transformer
- // b[p:n] holds the bytes to be transformed by t.
- b []byte
- p int
- n int
-}
-
-func (l *link) src() []byte {
- return l.b[l.p:l.n]
-}
-
-func (l *link) dst() []byte {
- return l.b[l.n:]
-}
-
-// Chain returns a Transformer that applies t in sequence.
-func Chain(t ...Transformer) Transformer {
- if len(t) == 0 {
- return nop{}
- }
- c := &chain{link: make([]link, len(t)+1)}
- for i, tt := range t {
- c.link[i].t = tt
- }
- // Allocate intermediate buffers.
- b := make([][defaultBufSize]byte, len(t)-1)
- for i := range b {
- c.link[i+1].b = b[i][:]
- }
- return c
-}
-
-// Reset resets the state of Chain. It calls Reset on all the Transformers.
-func (c *chain) Reset() {
- for i, l := range c.link {
- if l.t != nil {
- l.t.Reset()
- }
- c.link[i].p, c.link[i].n = 0, 0
- }
-}
-
-// TODO: make chain use Span (is going to be fun to implement!)
-
-// Transform applies the transformers of c in sequence.
-func (c *chain) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
- // Set up src and dst in the chain.
- srcL := &c.link[0]
- dstL := &c.link[len(c.link)-1]
- srcL.b, srcL.p, srcL.n = src, 0, len(src)
- dstL.b, dstL.n = dst, 0
- var lastFull, needProgress bool // for detecting progress
-
- // i is the index of the next Transformer to apply, for i in [low, high].
- // low is the lowest index for which c.link[low] may still produce bytes.
- // high is the highest index for which c.link[high] has a Transformer.
- // The error returned by Transform determines whether to increase or
- // decrease i. We try to completely fill a buffer before converting it.
- for low, i, high := c.errStart, c.errStart, len(c.link)-2; low <= i && i <= high; {
- in, out := &c.link[i], &c.link[i+1]
- nDst, nSrc, err0 := in.t.Transform(out.dst(), in.src(), atEOF && low == i)
- out.n += nDst
- in.p += nSrc
- if i > 0 && in.p == in.n {
- in.p, in.n = 0, 0
- }
- needProgress, lastFull = lastFull, false
- switch err0 {
- case ErrShortDst:
- // Process the destination buffer next. Return if we are already
- // at the high index.
- if i == high {
- return dstL.n, srcL.p, ErrShortDst
- }
- if out.n != 0 {
- i++
- // If the Transformer at the next index is not able to process any
- // source bytes there is nothing that can be done to make progress
- // and the bytes will remain unprocessed. lastFull is used to
- // detect this and break out of the loop with a fatal error.
- lastFull = true
- continue
- }
- // The destination buffer was too small, but is completely empty.
- // Return a fatal error as this transformation can never complete.
- c.fatalError(i, errShortInternal)
- case ErrShortSrc:
- if i == 0 {
- // Save ErrShortSrc in err. All other errors take precedence.
- err = ErrShortSrc
- break
- }
- // Source bytes were depleted before filling up the destination buffer.
- // Verify we made some progress, move the remaining bytes to the errStart
- // and try to get more source bytes.
- if needProgress && nSrc == 0 || in.n-in.p == len(in.b) {
- // There were not enough source bytes to proceed while the source
- // buffer cannot hold any more bytes. Return a fatal error as this
- // transformation can never complete.
- c.fatalError(i, errShortInternal)
- break
- }
- // in.b is an internal buffer and we can make progress.
- in.p, in.n = 0, copy(in.b, in.src())
- fallthrough
- case nil:
- // if i == low, we have depleted the bytes at index i or any lower levels.
- // In that case we increase low and i. In all other cases we decrease i to
- // fetch more bytes before proceeding to the next index.
- if i > low {
- i--
- continue
- }
- default:
- c.fatalError(i, err0)
- }
- // Exhausted level low or fatal error: increase low and continue
- // to process the bytes accepted so far.
- i++
- low = i
- }
-
- // If c.errStart > 0, this means we found a fatal error. We will clear
- // all upstream buffers. At this point, no more progress can be made
- // downstream, as Transform would have bailed while handling ErrShortDst.
- if c.errStart > 0 {
- for i := 1; i < c.errStart; i++ {
- c.link[i].p, c.link[i].n = 0, 0
- }
- err, c.errStart, c.err = c.err, 0, nil
- }
- return dstL.n, srcL.p, err
-}
-
-// Deprecated: use runes.Remove instead.
-func RemoveFunc(f func(r rune) bool) Transformer {
- return removeF(f)
-}
-
-type removeF func(r rune) bool
-
-func (removeF) Reset() {}
-
-// Transform implements the Transformer interface.
-func (t removeF) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
- for r, sz := rune(0), 0; len(src) > 0; src = src[sz:] {
-
- if r = rune(src[0]); r < utf8.RuneSelf {
- sz = 1
- } else {
- r, sz = utf8.DecodeRune(src)
-
- if sz == 1 {
- // Invalid rune.
- if !atEOF && !utf8.FullRune(src) {
- err = ErrShortSrc
- break
- }
- // We replace illegal bytes with RuneError. Not doing so might
- // otherwise turn a sequence of invalid UTF-8 into valid UTF-8.
- // The resulting byte sequence may subsequently contain runes
- // for which t(r) is true that were passed unnoticed.
- if !t(r) {
- if nDst+3 > len(dst) {
- err = ErrShortDst
- break
- }
- nDst += copy(dst[nDst:], "\uFFFD")
- }
- nSrc++
- continue
- }
- }
-
- if !t(r) {
- if nDst+sz > len(dst) {
- err = ErrShortDst
- break
- }
- nDst += copy(dst[nDst:], src[:sz])
- }
- nSrc += sz
- }
- return
-}
-
-// grow returns a new []byte that is longer than b, and copies the first n bytes
-// of b to the start of the new slice.
-func grow(b []byte, n int) []byte {
- m := len(b)
- if m <= 32 {
- m = 64
- } else if m <= 256 {
- m *= 2
- } else {
- m += m >> 1
- }
- buf := make([]byte, m)
- copy(buf, b[:n])
- return buf
-}
-
-const initialBufSize = 128
-
-// String returns a string with the result of converting s[:n] using t, where
-// n <= len(s). If err == nil, n will be len(s). It calls Reset on t.
-func String(t Transformer, s string) (result string, n int, err error) {
- t.Reset()
- if s == "" {
- // Fast path for the common case for empty input. Results in about a
- // 86% reduction of running time for BenchmarkStringLowerEmpty.
- if _, _, err := t.Transform(nil, nil, true); err == nil {
- return "", 0, nil
- }
- }
-
- // Allocate only once. Note that both dst and src escape when passed to
- // Transform.
- buf := [2 * initialBufSize]byte{}
- dst := buf[:initialBufSize:initialBufSize]
- src := buf[initialBufSize : 2*initialBufSize]
-
- // The input string s is transformed in multiple chunks (starting with a
- // chunk size of initialBufSize). nDst and nSrc are per-chunk (or
- // per-Transform-call) indexes, pDst and pSrc are overall indexes.
- nDst, nSrc := 0, 0
- pDst, pSrc := 0, 0
-
- // pPrefix is the length of a common prefix: the first pPrefix bytes of the
- // result will equal the first pPrefix bytes of s. It is not guaranteed to
- // be the largest such value, but if pPrefix, len(result) and len(s) are
- // all equal after the final transform (i.e. calling Transform with atEOF
- // being true returned nil error) then we don't need to allocate a new
- // result string.
- pPrefix := 0
- for {
- // Invariant: pDst == pPrefix && pSrc == pPrefix.
-
- n := copy(src, s[pSrc:])
- nDst, nSrc, err = t.Transform(dst, src[:n], pSrc+n == len(s))
- pDst += nDst
- pSrc += nSrc
-
- // TODO: let transformers implement an optional Spanner interface, akin
- // to norm's QuickSpan. This would even allow us to avoid any allocation.
- if !bytes.Equal(dst[:nDst], src[:nSrc]) {
- break
- }
- pPrefix = pSrc
- if err == ErrShortDst {
- // A buffer can only be short if a transformer modifies its input.
- break
- } else if err == ErrShortSrc {
- if nSrc == 0 {
- // No progress was made.
- break
- }
- // Equal so far and !atEOF, so continue checking.
- } else if err != nil || pPrefix == len(s) {
- return string(s[:pPrefix]), pPrefix, err
- }
- }
- // Post-condition: pDst == pPrefix + nDst && pSrc == pPrefix + nSrc.
-
- // We have transformed the first pSrc bytes of the input s to become pDst
- // transformed bytes. Those transformed bytes are discontiguous: the first
- // pPrefix of them equal s[:pPrefix] and the last nDst of them equal
- // dst[:nDst]. We copy them around, into a new dst buffer if necessary, so
- // that they become one contiguous slice: dst[:pDst].
- if pPrefix != 0 {
- newDst := dst
- if pDst > len(newDst) {
- newDst = make([]byte, len(s)+nDst-nSrc)
- }
- copy(newDst[pPrefix:pDst], dst[:nDst])
- copy(newDst[:pPrefix], s[:pPrefix])
- dst = newDst
- }
-
- // Prevent duplicate Transform calls with atEOF being true at the end of
- // the input. Also return if we have an unrecoverable error.
- if (err == nil && pSrc == len(s)) ||
- (err != nil && err != ErrShortDst && err != ErrShortSrc) {
- return string(dst[:pDst]), pSrc, err
- }
-
- // Transform the remaining input, growing dst and src buffers as necessary.
- for {
- n := copy(src, s[pSrc:])
- nDst, nSrc, err := t.Transform(dst[pDst:], src[:n], pSrc+n == len(s))
- pDst += nDst
- pSrc += nSrc
-
- // If we got ErrShortDst or ErrShortSrc, do not grow as long as we can
- // make progress. This may avoid excessive allocations.
- if err == ErrShortDst {
- if nDst == 0 {
- dst = grow(dst, pDst)
- }
- } else if err == ErrShortSrc {
- if nSrc == 0 {
- src = grow(src, 0)
- }
- } else if err != nil || pSrc == len(s) {
- return string(dst[:pDst]), pSrc, err
- }
- }
-}
-
-// Bytes returns a new byte slice with the result of converting b[:n] using t,
-// where n <= len(b). If err == nil, n will be len(b). It calls Reset on t.
-func Bytes(t Transformer, b []byte) (result []byte, n int, err error) {
- return doAppend(t, 0, make([]byte, len(b)), b)
-}
-
-// Append appends the result of converting src[:n] using t to dst, where
-// n <= len(src), If err == nil, n will be len(src). It calls Reset on t.
-func Append(t Transformer, dst, src []byte) (result []byte, n int, err error) {
- if len(dst) == cap(dst) {
- n := len(src) + len(dst) // It is okay for this to be 0.
- b := make([]byte, n)
- dst = b[:copy(b, dst)]
- }
- return doAppend(t, len(dst), dst[:cap(dst)], src)
-}
-
-func doAppend(t Transformer, pDst int, dst, src []byte) (result []byte, n int, err error) {
- t.Reset()
- pSrc := 0
- for {
- nDst, nSrc, err := t.Transform(dst[pDst:], src[pSrc:], true)
- pDst += nDst
- pSrc += nSrc
- if err != ErrShortDst {
- return dst[:pDst], pSrc, err
- }
-
- // Grow the destination buffer, but do not grow as long as we can make
- // progress. This may avoid excessive allocations.
- if nDst == 0 {
- dst = grow(dst, pDst)
- }
- }
-}
generated by cgit v1.2.3 (git 2.25.1) at 2024-04-19 11:51:04 +0000