1 files changed, 112 insertions, 0 deletions
diff --git a/pkg/fspath/builder.go b/pkg/fspath/builder.go
new file mode 100644
index 000000000..6318d3874
--- /dev/null
+++ b/pkg/fspath/builder.go
@@ -0,0 +1,112 @@
+// Copyright 2019 The gVisor Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package fspath
+
+import (
+	"fmt"
+
+	"gvisor.dev/gvisor/pkg/gohacks"
+)
+
+// Builder is similar to strings.Builder, but is used to produce pathnames
+// given path components in reverse order (from leaf to root). This is useful
+// in the common case where a filesystem is represented by a tree of named
+// nodes, and the path to a given node must be produced by walking upward from
+// that node to a given root.
+type Builder struct {
+	buf     []byte
+	start   int
+	needSep bool
+}
+
+// Reset resets the Builder to be empty.
+func (b *Builder) Reset() {
+	b.start = len(b.buf)
+	b.needSep = false
+}
+
+// Len returns the number of accumulated bytes.
+func (b *Builder) Len() int {
+	return len(b.buf) - b.start
+}
+
+func (b *Builder) needToGrow(n int) bool {
+	return b.start < n
+}
+
+func (b *Builder) grow(n int) {
+	newLen := b.Len() + n
+	var newCap int
+	if len(b.buf) == 0 {
+		newCap = 64 // arbitrary
+	} else {
+		newCap = 2 * len(b.buf)
+	}
+	for newCap < newLen {
+		newCap *= 2
+		if newCap == 0 {
+			panic(fmt.Sprintf("required length (%d) causes buffer size to overflow", newLen))
+		}
+	}
+	newBuf := make([]byte, newCap)
+	copy(newBuf[newCap-b.Len():], b.buf[b.start:])
+	b.start += newCap - len(b.buf)
+	b.buf = newBuf
+}
+
+// PrependComponent prepends the given path component to b's buffer. A path
+// separator is automatically inserted if appropriate.
+func (b *Builder) PrependComponent(pc string) {
+	if b.needSep {
+		b.PrependByte('/')
+	}
+	b.PrependString(pc)
+	b.needSep = true
+}
+
+// PrependString prepends the given string to b's buffer.
+func (b *Builder) PrependString(str string) {
+	if b.needToGrow(len(str)) {
+		b.grow(len(str))
+	}
+	b.start -= len(str)
+	copy(b.buf[b.start:], str)
+}
+
+// PrependByte prepends the given byte to b's buffer.
+func (b *Builder) PrependByte(c byte) {
+	if b.needToGrow(1) {
+		b.grow(1)
+	}
+	b.start--
+	b.buf[b.start] = c
+}
+
+// AppendString appends the given string to b's buffer.
+func (b *Builder) AppendString(str string) {
+	if b.needToGrow(len(str)) {
+		b.grow(len(str))
+	}
+	oldStart := b.start
+	b.start -= len(str)
+	copy(b.buf[b.start:], b.buf[oldStart:])
+	copy(b.buf[len(b.buf)-len(str):], str)
+}
+
+// String returns the accumulated string. No other methods should be called
+// after String.
+func (b *Builder) String() string {
+	return gohacks.StringFromImmutableBytes(b.buf[b.start:])
+}