gofront 1.8.0 → 1.9.0

package/stdlib/strings/reader.go

@@ -0,0 +1,163 @@
+//go:build gofront
+
+//gofront:target both
+
+// Overlay on the emitter-backed strings package: Reader written in Go over the
+// real package's algorithm.  GoFront strings are host strings whose indexes
+// are not UTF-8 byte offsets, so the Reader holds the UTF-8 bytes of the
+// string it was created from.
+package strings
+
+import (
+	"errors"
+	"io"
+	"unicode/utf8"
+)
+
+// A Reader implements the [io.Reader], [io.ReaderAt], [io.WriterTo], [io.Seeker],
+// [io.ByteScanner], and [io.RuneScanner] interfaces by reading from
+// a string.
+// Unlike a [Buffer], a Reader is read-only and supports seeking.
+// The zero value for Reader operates like a Reader of an empty string.
+type Reader struct {
+	s        []byte
+	i        int64 // current reading index
+	prevRune int   // index of previous rune; or < 0
+}
+
+// Len returns the number of bytes of the unread portion of the
+// string.
+func (r *Reader) Len() int {
+	if r.i >= int64(len(r.s)) {
+		return 0
+	}
+	return int(int64(len(r.s)) - r.i)
+}
+
+// Size returns the original length of the underlying string.
+// Size is the number of bytes available for reading via [Reader.ReadAt].
+// The result is unaffected by any method calls except [Reader.Reset].
+func (r *Reader) Size() int64 { return int64(len(r.s)) }
+
+// Read implements the [io.Reader] interface.
+func (r *Reader) Read(b []byte) (n int, err error) {
+	if r.i >= int64(len(r.s)) {
+		return 0, io.EOF
+	}
+	r.prevRune = -1
+	n = copy(b, r.s[r.i:])
+	r.i += int64(n)
+	return
+}
+
+// ReadAt implements the [io.ReaderAt] interface.
+func (r *Reader) ReadAt(b []byte, off int64) (n int, err error) {
+	// cannot modify state - see io.ReaderAt
+	if off < 0 {
+		return 0, errors.New("strings.Reader.ReadAt: negative offset")
+	}
+	if off >= int64(len(r.s)) {
+		return 0, io.EOF
+	}
+	n = copy(b, r.s[off:])
+	if n < len(b) {
+		err = io.EOF
+	}
+	return
+}
+
+// ReadByte implements the [io.ByteReader] interface.
+func (r *Reader) ReadByte() (byte, error) {
+	r.prevRune = -1
+	if r.i >= int64(len(r.s)) {
+		return 0, io.EOF
+	}
+	b := r.s[r.i]
+	r.i++
+	return b, nil
+}
+
+// UnreadByte complements [Reader.ReadByte] in implementing the [io.ByteScanner] interface.
+func (r *Reader) UnreadByte() error {
+	if r.i <= 0 {
+		return errors.New("strings.Reader.UnreadByte: at beginning of string")
+	}
+	r.prevRune = -1
+	r.i--
+	return nil
+}
+
+// ReadRune implements the [io.RuneReader] interface.
+func (r *Reader) ReadRune() (ch rune, size int, err error) {
+	if r.i >= int64(len(r.s)) {
+		r.prevRune = -1
+		return 0, 0, io.EOF
+	}
+	r.prevRune = int(r.i)
+	if c := r.s[r.i]; c < utf8.RuneSelf {
+		r.i++
+		return rune(c), 1, nil
+	}
+	ch, size = utf8.DecodeRune(r.s[r.i:])
+	r.i += int64(size)
+	return
+}
+
+// UnreadRune complements [Reader.ReadRune] in implementing the [io.RuneScanner] interface.
+func (r *Reader) UnreadRune() error {
+	if r.i <= 0 {
+		return errors.New("strings.Reader.UnreadRune: at beginning of string")
+	}
+	if r.prevRune < 0 {
+		return errors.New("strings.Reader.UnreadRune: previous operation was not ReadRune")
+	}
+	r.i = int64(r.prevRune)
+	r.prevRune = -1
+	return nil
+}
+
+// Seek implements the [io.Seeker] interface.
+func (r *Reader) Seek(offset int64, whence int) (int64, error) {
+	r.prevRune = -1
+	var abs int64
+	switch whence {
+	case io.SeekStart:
+		abs = offset
+	case io.SeekCurrent:
+		abs = r.i + offset
+	case io.SeekEnd:
+		abs = int64(len(r.s)) + offset
+	default:
+		return 0, errors.New("strings.Reader.Seek: invalid whence")
+	}
+	if abs < 0 {
+		return 0, errors.New("strings.Reader.Seek: negative position")
+	}
+	r.i = abs
+	return abs, nil
+}
+
+// WriteTo implements the [io.WriterTo] interface.
+func (r *Reader) WriteTo(w io.Writer) (n int64, err error) {
+	r.prevRune = -1
+	if r.i >= int64(len(r.s)) {
+		return 0, nil
+	}
+	b := r.s[r.i:]
+	m, err := w.Write(b)
+	if m > len(b) {
+		panic("strings.Reader.WriteTo: invalid Write count")
+	}
+	r.i += int64(m)
+	n = int64(m)
+	if m != len(b) && err == nil {
+		err = io.ErrShortWrite
+	}
+	return
+}
+
+// Reset resets the [Reader] to be reading from s.
+func (r *Reader) Reset(s string) { *r = Reader{[]byte(s), 0, -1} }
+
+// NewReader returns a new [Reader] reading from s.
+func NewReader(s string) *Reader { return &Reader{[]byte(s), 0, -1} }

package/stdlib/strings/replacer.go

@@ -0,0 +1,102 @@
+//go:build gofront
+
+//gofront:target both
+
+// Overlay on the emitter-backed strings package: Replacer written in Go.
+// Replacements run in the order they appear in the target string without
+// overlapping, and the old strings are tried in argument order, with an
+// empty old string never matching twice at the same position, as in Go's
+// generic replacer.
+package strings
+
+import "io"
+
+// Replacer replaces a list of strings with replacements.
+// It is safe for concurrent use by multiple goroutines.
+type Replacer struct {
+	oldnew []string
+}
+
+// NewReplacer returns a new Replacer from a list of old, new string
+// pairs. It panics if given an odd number of arguments.
+func NewReplacer(oldnew ...string) *Replacer {
+	if len(oldnew)%2 == 1 {
+		panic("strings.NewReplacer: odd argument count")
+	}
+	return &Replacer{oldnew: append([]string(nil), oldnew...)}
+}
+
+// match returns the replacement chosen at the start of s and the length of
+// the old string it replaces; the first old string in argument order that is
+// a prefix of s wins, and an empty one is skipped when skipEmpty is set.
+func (r *Replacer) match(s string, skipEmpty bool) (val string, keylen int, ok bool) {
+	for i := 0; i < len(r.oldnew); i += 2 {
+		old := r.oldnew[i]
+		if skipEmpty && len(old) == 0 {
+			continue
+		}
+		if len(old) <= len(s) && s[:len(old)] == old {
+			return r.oldnew[i+1], len(old), true
+		}
+	}
+	return "", 0, false
+}
+
+// Replace returns a copy of s with all replacements performed.
+func (r *Replacer) Replace(s string) string {
+	var out []byte
+	changed := false
+	last := 0
+	prevMatchEmpty := false
+	for i := 0; i <= len(s); {
+		val, keylen, ok := r.match(s[i:], prevMatchEmpty)
+		prevMatchEmpty = ok && keylen == 0
+		if ok {
+			changed = true
+			out = append(out, s[last:i]...)
+			out = append(out, val...)
+			i += keylen
+			last = i
+			continue
+		}
+		i++
+	}
+	if !changed {
+		return s
+	}
+	out = append(out, s[last:]...)
+	return string(out)
+}
+
+// WriteString writes s to w with all replacements performed.
+func (r *Replacer) WriteString(w io.Writer, s string) (n int, err error) {
+	last := 0
+	prevMatchEmpty := false
+	for i := 0; i <= len(s); {
+		val, keylen, ok := r.match(s[i:], prevMatchEmpty)
+		prevMatchEmpty = ok && keylen == 0
+		if ok {
+			var wn int
+			wn, err = io.WriteString(w, s[last:i])
+			n += wn
+			if err != nil {
+				return
+			}
+			wn, err = io.WriteString(w, val)
+			n += wn
+			if err != nil {
+				return
+			}
+			i += keylen
+			last = i
+			continue
+		}
+		i++
+	}
+	if last != len(s) {
+		var wn int
+		wn, err = io.WriteString(w, s[last:])
+		n += wn
+	}
+	return
+}