podman

1
// Copyright 2015 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 runes
6

7
import (
8
	"unicode/utf8"
9

10
	"golang.org/x/text/transform"
11
)
12

13
// Note: below we pass invalid UTF-8 to the tIn and tNotIn transformers as is.
14
// This is done for various reasons:
15
// - To retain the semantics of the Nop transformer: if input is passed to a Nop
16
//   one would expect it to be unchanged.
17
// - It would be very expensive to pass a converted RuneError to a transformer:
18
//   a transformer might need more source bytes after RuneError, meaning that
19
//   the only way to pass it safely is to create a new buffer and manage the
20
//   intermingling of RuneErrors and normal input.
21
// - Many transformers leave ill-formed UTF-8 as is, so this is not
22
//   inconsistent. Generally ill-formed UTF-8 is only replaced if it is a
23
//   logical consequence of the operation (as for Map) or if it otherwise would
24
//   pose security concerns (as for Remove).
25
// - An alternative would be to return an error on ill-formed UTF-8, but this
26
//   would be inconsistent with other operations.
27

28
// If returns a transformer that applies tIn to consecutive runes for which
29
// s.Contains(r) and tNotIn to consecutive runes for which !s.Contains(r). Reset
30
// is called on tIn and tNotIn at the start of each run. A Nop transformer will
31
// substitute a nil value passed to tIn or tNotIn. Invalid UTF-8 is translated
32
// to RuneError to determine which transformer to apply, but is passed as is to
33
// the respective transformer.
34
func If(s Set, tIn, tNotIn transform.Transformer) Transformer {
35
	if tIn == nil && tNotIn == nil {
36
		return Transformer{transform.Nop}
37
	}
38
	if tIn == nil {
39
		tIn = transform.Nop
40
	}
41
	if tNotIn == nil {
42
		tNotIn = transform.Nop
43
	}
44
	sIn, ok := tIn.(transform.SpanningTransformer)
45
	if !ok {
46
		sIn = dummySpan{tIn}
47
	}
48
	sNotIn, ok := tNotIn.(transform.SpanningTransformer)
49
	if !ok {
50
		sNotIn = dummySpan{tNotIn}
51
	}
52

53
	a := &cond{
54
		tIn:    sIn,
55
		tNotIn: sNotIn,
56
		f:      s.Contains,
57
	}
58
	a.Reset()
59
	return Transformer{a}
60
}
61

62
type dummySpan struct{ transform.Transformer }
63

64
func (d dummySpan) Span(src []byte, atEOF bool) (n int, err error) {
65
	return 0, transform.ErrEndOfSpan
66
}
67

68
type cond struct {
69
	tIn, tNotIn transform.SpanningTransformer
70
	f           func(rune) bool
71
	check       func(rune) bool               // current check to perform
72
	t           transform.SpanningTransformer // current transformer to use
73
}
74

75
// Reset implements transform.Transformer.
76
func (t *cond) Reset() {
77
	t.check = t.is
78
	t.t = t.tIn
79
	t.t.Reset() // notIn will be reset on first usage.
80
}
81

82
func (t *cond) is(r rune) bool {
83
	if t.f(r) {
84
		return true
85
	}
86
	t.check = t.isNot
87
	t.t = t.tNotIn
88
	t.tNotIn.Reset()
89
	return false
90
}
91

92
func (t *cond) isNot(r rune) bool {
93
	if !t.f(r) {
94
		return true
95
	}
96
	t.check = t.is
97
	t.t = t.tIn
98
	t.tIn.Reset()
99
	return false
100
}
101

102
// This implementation of Span doesn't help all too much, but it needs to be
103
// there to satisfy this package's Transformer interface.
104
// TODO: there are certainly room for improvements, though. For example, if
105
// t.t == transform.Nop (which will a common occurrence) it will save a bundle
106
// to special-case that loop.
107
func (t *cond) Span(src []byte, atEOF bool) (n int, err error) {
108
	p := 0
109
	for n < len(src) && err == nil {
110
		// Don't process too much at a time as the Spanner that will be
111
		// called on this block may terminate early.
112
		const maxChunk = 4096
113
		max := len(src)
114
		if v := n + maxChunk; v < max {
115
			max = v
116
		}
117
		atEnd := false
118
		size := 0
119
		current := t.t
120
		for ; p < max; p += size {
121
			r := rune(src[p])
122
			if r < utf8.RuneSelf {
123
				size = 1
124
			} else if r, size = utf8.DecodeRune(src[p:]); size == 1 {
125
				if !atEOF && !utf8.FullRune(src[p:]) {
126
					err = transform.ErrShortSrc
127
					break
128
				}
129
			}
130
			if !t.check(r) {
131
				// The next rune will be the start of a new run.
132
				atEnd = true
133
				break
134
			}
135
		}
136
		n2, err2 := current.Span(src[n:p], atEnd || (atEOF && p == len(src)))
137
		n += n2
138
		if err2 != nil {
139
			return n, err2
140
		}
141
		// At this point either err != nil or t.check will pass for the rune at p.
142
		p = n + size
143
	}
144
	return n, err
145
}
146

147
func (t *cond) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
148
	p := 0
149
	for nSrc < len(src) && err == nil {
150
		// Don't process too much at a time, as the work might be wasted if the
151
		// destination buffer isn't large enough to hold the result or a
152
		// transform returns an error early.
153
		const maxChunk = 4096
154
		max := len(src)
155
		if n := nSrc + maxChunk; n < len(src) {
156
			max = n
157
		}
158
		atEnd := false
159
		size := 0
160
		current := t.t
161
		for ; p < max; p += size {
162
			r := rune(src[p])
163
			if r < utf8.RuneSelf {
164
				size = 1
165
			} else if r, size = utf8.DecodeRune(src[p:]); size == 1 {
166
				if !atEOF && !utf8.FullRune(src[p:]) {
167
					err = transform.ErrShortSrc
168
					break
169
				}
170
			}
171
			if !t.check(r) {
172
				// The next rune will be the start of a new run.
173
				atEnd = true
174
				break
175
			}
176
		}
177
		nDst2, nSrc2, err2 := current.Transform(dst[nDst:], src[nSrc:p], atEnd || (atEOF && p == len(src)))
178
		nDst += nDst2
179
		nSrc += nSrc2
180
		if err2 != nil {
181
			return nDst, nSrc, err2
182
		}
183
		// At this point either err != nil or t.check will pass for the rune at p.
184
		p = nSrc + size
185
	}
186
	return nDst, nSrc, err
187
}
188