gofront 1.8.0 → 1.9.1

package/stdlib/internal/jsonrt/scanner.go

@@ -71,7 +71,9 @@ type scanner struct {
 	endTop bool
 
 	// Stack of what we're in the middle of - array values, object keys, object values.
-	parseState []int
+	// Only the first parseStateLen entries are live; the rest is reused room.
+	parseState    []int
+	parseStateLen int
 
 	// Error that happened, if any.
 	err error
@@ -130,7 +132,7 @@ const maxNestingDepth = 10000
 // It must be called before calling s.step.
 func (s *scanner) reset() {
 	s.step = stateBeginValue
-	s.parseState = s.parseState[0:0]
+	s.parseStateLen = 0
 	s.err = nil
 	s.endTop = false
 }
@@ -157,8 +159,13 @@ func (s *scanner) eof() int {
 // pushParseState pushes a new parse state newParseState onto the parse stack.
 // an error state is returned if maxNestingDepth was exceeded, otherwise successState is returned.
 func (s *scanner) pushParseState(c byte, newParseState int, successState int) int {
-	s.parseState = append(s.parseState, newParseState)
-	if len(s.parseState) <= maxNestingDepth {
+	if s.parseStateLen < len(s.parseState) {
+		s.parseState[s.parseStateLen] = newParseState
+	} else {
+		s.parseState = append(s.parseState, newParseState)
+	}
+	s.parseStateLen++
+	if s.parseStateLen <= maxNestingDepth {
 		return successState
 	}
 	return s.error(c, "exceeded max depth")
@@ -167,8 +174,8 @@ func (s *scanner) pushParseState(c byte, newParseState int, successState int) in
 // popParseState pops a parse state (already obtained) off the stack
 // and updates s.step accordingly.
 func (s *scanner) popParseState() {
-	n := len(s.parseState) - 1
-	s.parseState = s.parseState[0:n]
+	s.parseStateLen--
+	n := s.parseStateLen
 	if n == 0 {
 		s.step = stateEndTop
 		s.endTop = true
@@ -236,7 +243,7 @@ func stateBeginStringOrEmpty(s *scanner, c byte) int {
 		return scanSkipSpace
 	}
 	if c == '}' {
-		n := len(s.parseState)
+		n := s.parseStateLen
 		s.parseState[n-1] = parseObjectValue
 		return stateEndValue(s, c)
 	}
@@ -258,7 +265,7 @@ func stateBeginString(s *scanner, c byte) int {
 // stateEndValue is the state after completing a value,
 // such as after reading `{}` or `true` or `["x"`.
 func stateEndValue(s *scanner, c byte) int {
-	n := len(s.parseState)
+	n := s.parseStateLen
 	if n == 0 {
 		// Completed top-level before the current byte.
 		s.step = stateEndTop
@@ -592,6 +599,8 @@ func quoteChar(c byte) string {
 
 // CheckValid returns nil when data is one valid JSON value, else the
 // *SyntaxError describing the first problem.
+//
+//gofront:native jsonrt.CheckValid
 func CheckValid(data []byte) error {
 	return checkValid(data, newScanner())
 }

package/stdlib/io/io.go

@@ -2,13 +2,38 @@
 
 //gofront:target both
 
-// Overlay on the emitter-backed io package.
+// Package io provides the basic interfaces to I/O primitives, written in
+// Go over the real package's algorithms. io.Pipe is not supported.
 package io
 
 import (
 	"errors"
 )
 
+// EOF is the error returned by Read when no more input is available.
+var EOF = errors.New("EOF")
+
+// Reader is the interface that wraps the basic Read method.
+type Reader interface {
+	Read(p []byte) (n int, err error)
+}
+
+// Writer is the interface that wraps the basic Write method.
+type Writer interface {
+	Write(p []byte) (n int, err error)
+}
+
+// Closer is the interface that wraps the basic Close method.
+type Closer interface {
+	Close() error
+}
+
+// ReadWriter is the interface that groups the basic Read and Write methods.
+type ReadWriter interface {
+	Reader
+	Writer
+}
+
 // Seek whence values.
 const (
 	SeekStart   = 0 // seek relative to the origin of the file
@@ -344,3 +369,134 @@ func (s *SectionReader) Size() int64 { return s.limit - s.base }
 func (s *SectionReader) Outer() (r ReaderAt, off int64, n int64) {
 	return s.r, s.base, s.n
 }
+
+// WriteString writes the contents of the string s to w.
+func WriteString(w Writer, s string) (n int, err error) {
+	if sw, ok := w.(StringWriter); ok {
+		return sw.WriteString(s)
+	}
+	return w.Write([]byte(s))
+}
+
+// ReadAll reads from r until an error or EOF and returns the data it read.
+func ReadAll(r Reader) ([]byte, error) {
+	b := make([]byte, 0, 512)
+	for {
+		n, err := r.Read(b[len(b):cap(b)])
+		b = b[:len(b)+n]
+		if err != nil {
+			if err == EOF {
+				err = nil
+			}
+			return b, err
+		}
+		if len(b) == cap(b) {
+			b = append(b, 0)[:len(b)]
+		}
+	}
+}
+
+// A LimitedReader reads from R but limits the amount of data returned to just N bytes.
+type LimitedReader struct {
+	R Reader // underlying reader
+	N int64  // max bytes remaining
+}
+
+func (l *LimitedReader) Read(p []byte) (n int, err error) {
+	if l.N <= 0 {
+		return 0, EOF
+	}
+	if int64(len(p)) > l.N {
+		p = p[0:l.N]
+	}
+	n, err = l.R.Read(p)
+	l.N -= int64(n)
+	return
+}
+
+// LimitReader returns a Reader that reads from r but stops with EOF after n bytes.
+func LimitReader(r Reader, n int64) Reader { return &LimitedReader{r, n} }
+
+type discard struct{}
+
+func (discard) Write(p []byte) (int, error)       { return len(p), nil }
+func (discard) WriteString(s string) (int, error) { return len(s), nil }
+
+// Discard is a Writer on which all Write calls succeed without doing anything.
+var Discard Writer = discard{}
+
+// Copy copies from src to dst until either EOF is reached on src or an error occurs.
+func Copy(dst Writer, src Reader) (written int64, err error) {
+	return copyBuffer(dst, src, nil)
+}
+
+// CopyN copies n bytes (or until an error) from src to dst.
+func CopyN(dst Writer, src Reader, n int64) (written int64, err error) {
+	written, err = Copy(dst, LimitReader(src, n))
+	if written == n {
+		return n, nil
+	}
+	if written < n && err == nil {
+		// src stopped early; must have been EOF.
+		err = EOF
+	}
+	return
+}
+
+// CopyBuffer is identical to Copy except that it stages through the provided buffer.
+func CopyBuffer(dst Writer, src Reader, buf []byte) (written int64, err error) {
+	if buf != nil && len(buf) == 0 {
+		panic("empty buffer in CopyBuffer")
+	}
+	return copyBuffer(dst, src, buf)
+}
+
+func copyBuffer(dst Writer, src Reader, buf []byte) (written int64, err error) {
+	if wt, ok := src.(WriterTo); ok {
+		return wt.WriteTo(dst)
+	}
+	if rf, ok := dst.(ReaderFrom); ok {
+		return rf.ReadFrom(src)
+	}
+	if buf == nil {
+		size := 32 * 1024
+		if l, ok := src.(*LimitedReader); ok && int64(size) > l.N {
+			if l.N < 1 {
+				size = 1
+			} else {
+				size = int(l.N)
+			}
+		}
+		buf = make([]byte, size)
+	}
+	for {
+		nr, er := src.Read(buf)
+		if nr > 0 {
+			nw, ew := dst.Write(buf[0:nr])
+			if nw < 0 || nr < nw {
+				nw = 0
+				if ew == nil {
+					ew = errInvalidWrite
+				}
+			}
+			written += int64(nw)
+			if ew != nil {
+				err = ew
+				break
+			}
+			if nr != nw {
+				err = ErrShortWrite
+				break
+			}
+		}
+		if er != nil {
+			if er != EOF {
+				err = er
+			}
+			break
+		}
+	}
+	return written, err
+}
+
+var errInvalidWrite = errors.New("invalid write result")

package/stdlib/maps/maps.go

@@ -0,0 +1,131 @@
+//go:build gofront
+
+//gofront:target both
+
+// Copyright 2021 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 maps defines various functions useful with maps of any type.
+//
+// This package does not have any special handling for non-reflexive keys
+// (keys k where k != k), such as floating-point NaNs.
+package maps
+
+import "iter"
+
+// Equal reports whether two maps contain the same key/value pairs.
+// Values are compared using ==.
+func Equal[M1, M2 ~map[K]V, K, V comparable](m1 M1, m2 M2) bool {
+	if len(m1) != len(m2) {
+		return false
+	}
+	for k, v1 := range m1 {
+		if v2, ok := m2[k]; !ok || v1 != v2 {
+			return false
+		}
+	}
+	return true
+}
+
+// EqualFunc is like Equal, but compares values using eq.
+// Keys are still compared with ==.
+func EqualFunc[M1 ~map[K]V1, M2 ~map[K]V2, K comparable, V1, V2 any](m1 M1, m2 M2, eq func(V1, V2) bool) bool {
+	if len(m1) != len(m2) {
+		return false
+	}
+	for k, v1 := range m1 {
+		if v2, ok := m2[k]; !ok || !eq(v1, v2) {
+			return false
+		}
+	}
+	return true
+}
+
+// Clone returns a copy of m.  This is a shallow clone:
+// the new keys and values are set using ordinary assignment.
+func Clone[M ~map[K]V, K comparable, V any](m M) M {
+	// Preserve nil in case it matters.
+	if m == nil {
+		return nil
+	}
+	r := make(M, len(m))
+	for k, v := range m {
+		r[k] = v
+	}
+	return r
+}
+
+// Copy copies all key/value pairs in src adding them to dst.
+// When a key in src is already present in dst,
+// the value in dst will be overwritten by the value associated
+// with the key in src.
+func Copy[M1 ~map[K]V, M2 ~map[K]V, K comparable, V any](dst M1, src M2) {
+	for k, v := range src {
+		dst[k] = v
+	}
+}
+
+// DeleteFunc deletes any key/value pairs from m for which del returns true.
+func DeleteFunc[M ~map[K]V, K comparable, V any](m M, del func(K, V) bool) {
+	for k, v := range m {
+		if del(k, v) {
+			delete(m, k)
+		}
+	}
+}
+
+// All returns an iterator over key-value pairs from m.
+// The iteration order is not specified and is not guaranteed
+// to be the same from one call to the next.
+func All[Map ~map[K]V, K comparable, V any](m Map) iter.Seq2[K, V] {
+	return func(yield func(K, V) bool) {
+		for k, v := range m {
+			if !yield(k, v) {
+				return
+			}
+		}
+	}
+}
+
+// Keys returns an iterator over keys in m.
+// The iteration order is not specified and is not guaranteed
+// to be the same from one call to the next.
+func Keys[Map ~map[K]V, K comparable, V any](m Map) iter.Seq[K] {
+	return func(yield func(K) bool) {
+		for k := range m {
+			if !yield(k) {
+				return
+			}
+		}
+	}
+}
+
+// Values returns an iterator over values in m.
+// The iteration order is not specified and is not guaranteed
+// to be the same from one call to the next.
+func Values[Map ~map[K]V, K comparable, V any](m Map) iter.Seq[V] {
+	return func(yield func(V) bool) {
+		for _, v := range m {
+			if !yield(v) {
+				return
+			}
+		}
+	}
+}
+
+// Insert adds the key-value pairs from seq to m.
+// If a key in seq already exists in m, its value will be overwritten.
+func Insert[Map ~map[K]V, K comparable, V any](m Map, seq iter.Seq2[K, V]) {
+	for k, v := range seq {
+		m[k] = v
+	}
+}
+
+// Collect collects key-value pairs from seq into a new map
+// and returns it.
+func Collect[K comparable, V any](seq iter.Seq2[K, V]) map[K]V {
+	m := make(map[K]V)
+	Insert(m, seq)
+	return m
+}