gofront 1.7.0 → 1.9.0

package/stdlib/bytes/reader.go

@@ -0,0 +1,161 @@
+//go:build gofront
+
+//gofront:target both
+
+// Overlay on the emitter-backed bytes package: Reader written in Go over the
+// real package's algorithm.
+package bytes
+
+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 byte slice.
+// Unlike a [Buffer], a Reader is read-only and supports seeking.
+// The zero value for Reader operates like a Reader of an empty slice.
+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
+// slice.
+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 byte slice.
+// 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("bytes.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("bytes.Reader.UnreadByte: at beginning of slice")
+	}
+	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("bytes.Reader.UnreadRune: at beginning of slice")
+	}
+	if r.prevRune < 0 {
+		return errors.New("bytes.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("bytes.Reader.Seek: invalid whence")
+	}
+	if abs < 0 {
+		return 0, errors.New("bytes.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("bytes.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 b.
+func (r *Reader) Reset(b []byte) { *r = Reader{b, 0, -1} }
+
+// NewReader returns a new [Reader] reading from b.
+func NewReader(b []byte) *Reader { return &Reader{b, 0, -1} }

package/stdlib/cmp/cmp.go

@@ -0,0 +1,65 @@
+//go:build gofront
+
+//gofront:target both
+
+// Package cmp provides types and functions related to comparing ordered
+// values. Same API as Go's cmp package.
+package cmp
+
+// Ordered is a constraint that permits any ordered type: any type that
+// supports the operators < <= >= >.
+type Ordered interface {
+	~int | ~int8 | ~int16 | ~int32 | ~int64 |
+		~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr |
+		~float32 | ~float64 |
+		~string
+}
+
+// Less reports whether x is less than y. A NaN is less than any non-NaN,
+// and -0.0 is not less than 0.0.
+func Less[T Ordered](x, y T) bool {
+	return (isNaNValue(x) && !isNaNValue(y)) || x < y
+}
+
+// Compare returns -1 if x is less than y, 0 if x equals y, and +1 if x is
+// greater than y. A NaN is less than any non-NaN, a NaN equals a NaN, and
+// -0.0 equals 0.0.
+func Compare[T Ordered](x, y T) int {
+	xNaN := isNaNValue(x)
+	yNaN := isNaNValue(y)
+	if xNaN {
+		if yNaN {
+			return 0
+		}
+		return -1
+	}
+	if yNaN {
+		return +1
+	}
+	if x < y {
+		return -1
+	}
+	if x > y {
+		return +1
+	}
+	return 0
+}
+
+// isNaNValue reports whether x is a NaN without requiring the math package
+// (named so it does not collide with the browser global isNaN until Task 0.9).
+// This will always return false if T is not floating-point.
+func isNaNValue[T Ordered](x T) bool {
+	return x != x
+}
+
+// Or returns the first of its arguments that is not equal to the zero
+// value. If no argument is non-zero, it returns the zero value.
+func Or[T comparable](vals ...T) T {
+	var zero T
+	for _, v := range vals {
+		if v != zero {
+			return v
+		}
+	}
+	return zero
+}

package/stdlib/context/context.go

@@ -0,0 +1,115 @@
+//go:build gofront
+
+//gofront:target both
+
+// Package context carries a cancellation signal and request-scoped values
+// across API boundaries.
+//
+// It is the part of the real package that needs no channels or goroutines:
+// Background, TODO, WithCancel and WithValue. The Context interface has no
+// Done method and there are no deadlines or timeouts; poll Err instead.
+package context
+
+import (
+	"errors"
+	"time"
+)
+
+// A Context carries a cancellation signal and values across API boundaries.
+type Context interface {
+	// Deadline returns the time when work done on behalf of this context
+	// should be canceled. No context has a deadline, so ok is always false.
+	Deadline() (deadline time.Time, ok bool)
+
+	// Err returns nil while the context is live, and Canceled once it has
+	// been canceled.
+	Err() error
+
+	// Value returns the value associated with key, or nil.
+	Value(key any) any
+}
+
+// Canceled is the error returned by Context.Err when the context is canceled.
+var Canceled = errors.New("context canceled")
+
+// A CancelFunc tells an operation to abandon its work.
+type CancelFunc func()
+
+type emptyCtx struct {
+	name string
+}
+
+func (*emptyCtx) Deadline() (deadline time.Time, ok bool) { return }
+func (*emptyCtx) Err() error                              { return nil }
+func (*emptyCtx) Value(key any) any                       { return nil }
+func (e *emptyCtx) String() string                        { return e.name }
+
+var (
+	background = &emptyCtx{"context.Background"}
+	todo       = &emptyCtx{"context.TODO"}
+)
+
+// Background returns a non-nil, empty Context. It is never canceled and has
+// no values.
+func Background() Context {
+	return background
+}
+
+// TODO returns a non-nil, empty Context, for code that has not yet decided
+// which Context to use.
+func TODO() Context {
+	return todo
+}
+
+type cancelCtx struct {
+	parent   Context
+	canceled bool
+}
+
+func (c *cancelCtx) Deadline() (deadline time.Time, ok bool) { return }
+
+func (c *cancelCtx) Err() error {
+	if c.canceled {
+		return Canceled
+	}
+	return c.parent.Err()
+}
+
+func (c *cancelCtx) Value(key any) any { return c.parent.Value(key) }
+
+// WithCancel returns a derived context that is canceled when the returned
+// cancel function is called, or when the parent is canceled.
+func WithCancel(parent Context) (ctx Context, cancel CancelFunc) {
+	if parent == nil {
+		panic("cannot create context from nil parent")
+	}
+	c := &cancelCtx{parent: parent}
+	return c, func() { c.canceled = true }
+}
+
+type valueCtx struct {
+	Context
+	key, val any
+}
+
+func (c *valueCtx) Deadline() (deadline time.Time, ok bool) { return c.Context.Deadline() }
+
+func (c *valueCtx) Err() error { return c.Context.Err() }
+
+func (c *valueCtx) Value(key any) any {
+	if c.key == key {
+		return c.val
+	}
+	return c.Context.Value(key)
+}
+
+// WithValue returns a derived context in which key is associated with val.
+func WithValue(parent Context, key, val any) Context {
+	if parent == nil {
+		panic("cannot create context from nil parent")
+	}
+	if key == nil {
+		panic("nil key")
+	}
+	return &valueCtx{parent, key, val}
+}

package/stdlib/crypto/rand/rand.go

@@ -0,0 +1,34 @@
+//go:build gofront
+
+//gofront:target both
+
+// Package rand implements a cryptographically secure random number
+// generator over the host's secure source (crypto.getRandomValues).
+package rand
+
+import "io"
+
+// hostU32 returns four random bytes from the host's secure source.
+//
+//gofront:intrinsic crypto_rand_u32
+func hostU32() uint32
+
+type reader struct{}
+
+func (reader) Read(b []byte) (int, error) { return Read(b) }
+
+// Reader is a global, shared instance of a cryptographically secure random
+// number generator.
+var Reader io.Reader = reader{}
+
+// Read fills b with cryptographically secure random bytes. It never returns
+// an error, and always fills b entirely.
+func Read(b []byte) (n int, err error) {
+	for i := 0; i < len(b); i += 4 {
+		v := hostU32()
+		for j := 0; j < 4 && i+j < len(b); j++ {
+			b[i+j] = byte(v >> (8 * j))
+		}
+	}
+	return len(b), nil
+}

package/stdlib/crypto/sha256/sha256.go

@@ -0,0 +1,249 @@
+//go:build gofront
+
+//gofront:target both
+
+// Copyright 2009 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 sha256 implements the SHA224 and SHA256 hash algorithms as defined
+// in FIPS 180-4.
+package sha256
+
+import "hash"
+
+// The size of a SHA256 checksum in bytes.
+const Size = 32
+
+// The size of a SHA224 checksum in bytes.
+const Size224 = 28
+
+// The blocksize of SHA256 and SHA224 in bytes.
+const BlockSize = 64
+
+const (
+	chunk     = 64
+	init0     = 0x6A09E667
+	init1     = 0xBB67AE85
+	init2     = 0x3C6EF372
+	init3     = 0xA54FF53A
+	init4     = 0x510E527F
+	init5     = 0x9B05688C
+	init6     = 0x1F83D9AB
+	init7     = 0x5BE0CD19
+	init0_224 = 0xC1059ED8
+	init1_224 = 0x367CD507
+	init2_224 = 0x3070DD17
+	init3_224 = 0xF70E5939
+	init4_224 = 0xFFC00B31
+	init5_224 = 0x68581511
+	init6_224 = 0x64F98FA7
+	init7_224 = 0xBEFA4FA4
+)
+
+var _K = [...]uint32{
+	0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+	0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+	0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+	0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+	0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+	0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+	0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+	0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+}
+
+// digest represents the partial evaluation of a checksum.
+type digest struct {
+	h     [8]uint32
+	x     [64]byte
+	nx    int
+	len   uint64
+	is224 bool // mark if this digest is SHA-224
+}
+
+func (d *digest) Reset() {
+	if !d.is224 {
+		d.h[0] = init0
+		d.h[1] = init1
+		d.h[2] = init2
+		d.h[3] = init3
+		d.h[4] = init4
+		d.h[5] = init5
+		d.h[6] = init6
+		d.h[7] = init7
+	} else {
+		d.h[0] = init0_224
+		d.h[1] = init1_224
+		d.h[2] = init2_224
+		d.h[3] = init3_224
+		d.h[4] = init4_224
+		d.h[5] = init5_224
+		d.h[6] = init6_224
+		d.h[7] = init7_224
+	}
+	d.nx = 0
+	d.len = 0
+}
+
+// New returns a new [hash.Hash] computing the SHA256 checksum.
+func New() hash.Hash {
+	d := new(digest)
+	d.Reset()
+	return d
+}
+
+// New224 returns a new [hash.Hash] computing the SHA224 checksum.
+func New224() hash.Hash {
+	d := new(digest)
+	d.is224 = true
+	d.Reset()
+	return d
+}
+
+func (d *digest) Size() int {
+	if !d.is224 {
+		return Size
+	}
+	return Size224
+}
+
+func (d *digest) BlockSize() int { return BlockSize }
+
+func (d *digest) Write(p []byte) (nn int, err error) {
+	nn = len(p)
+	d.len += uint64(nn)
+	if d.nx > 0 {
+		n := copy(d.x[d.nx:], p)
+		d.nx += n
+		if d.nx == chunk {
+			block(d, d.x[:])
+			d.nx = 0
+		}
+		p = p[n:]
+	}
+	if len(p) >= chunk {
+		n := len(p) &^ (chunk - 1)
+		block(d, p[:n])
+		p = p[n:]
+	}
+	if len(p) > 0 {
+		d.nx = copy(d.x[:], p)
+	}
+	return
+}
+
+func (d *digest) Sum(in []byte) []byte {
+	// Make a copy of d so that caller can keep writing and summing.
+	d0 := *d
+	sum := d0.checkSum()
+	if d0.is224 {
+		return append(in, sum[:Size224]...)
+	}
+	return append(in, sum[:]...)
+}
+
+func (d *digest) checkSum() [32]byte {
+	length := d.len
+	// Padding. Add a 1 bit and 0 bits until 56 bytes mod 64.
+	var tmp [64 + 8]byte // padding + length buffer
+	tmp[0] = 0x80
+	var t uint64
+	if length%64 < 56 {
+		t = 56 - length%64
+	} else {
+		t = 64 + 56 - length%64
+	}
+
+	// Length in bits.
+	length <<= 3
+	padlen := tmp[:t+8]
+	for i := uint64(0); i < 8; i++ {
+		padlen[t+i] = byte(length >> (56 - 8*i))
+	}
+	d.Write(padlen)
+
+	if d.nx != 0 {
+		panic("d.nx != 0")
+	}
+
+	var sum [32]byte
+	for i := 0; i < 8; i++ {
+		v := d.h[i]
+		sum[4*i] = byte(v >> 24)
+		sum[4*i+1] = byte(v >> 16)
+		sum[4*i+2] = byte(v >> 8)
+		sum[4*i+3] = byte(v)
+	}
+
+	return sum
+}
+
+// Sum256 returns the SHA256 checksum of the data.
+func Sum256(data []byte) [32]byte {
+	var d digest
+	d.Reset()
+	d.Write(data)
+	return d.checkSum()
+}
+
+// Sum224 returns the SHA224 checksum of the data.
+func Sum224(data []byte) [28]byte {
+	var d digest
+	d.is224 = true
+	d.Reset()
+	d.Write(data)
+	sum := d.checkSum()
+	var out [28]byte
+	copy(out[:], sum[:Size224])
+	return out
+}
+
+func block(dig *digest, p []byte) {
+	var w [64]uint32
+	h0, h1, h2, h3, h4, h5, h6, h7 := dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7]
+	for len(p) >= chunk {
+		// Can interlace the computation of w with the
+		// rounds below if needed for speed.
+		for i := 0; i < 16; i++ {
+			j := i * 4
+			w[i] = uint32(p[j])<<24 | uint32(p[j+1])<<16 | uint32(p[j+2])<<8 | uint32(p[j+3])
+		}
+		for i := 16; i < 64; i++ {
+			v1 := w[i-2]
+			t1 := (v1>>17 | v1<<(32-17)) ^ (v1>>19 | v1<<(32-19)) ^ (v1 >> 10)
+			v2 := w[i-15]
+			t2 := (v2>>7 | v2<<(32-7)) ^ (v2>>18 | v2<<(32-18)) ^ (v2 >> 3)
+			w[i] = t1 + w[i-7] + t2 + w[i-16]
+		}
+
+		a, b, c, d, e, f, g, h := h0, h1, h2, h3, h4, h5, h6, h7
+
+		for i := 0; i < 64; i++ {
+			t1 := h + ((e>>6 | e<<(32-6)) ^ (e>>11 | e<<(32-11)) ^ (e>>25 | e<<(32-25))) + ((e & f) ^ (^e & g)) + _K[i] + w[i]
+
+			t2 := ((a>>2 | a<<(32-2)) ^ (a>>13 | a<<(32-13)) ^ (a>>22 | a<<(32-22))) + ((a & b) ^ (a & c) ^ (b & c))
+
+			h = g
+			g = f
+			f = e
+			e = d + t1
+			d = c
+			c = b
+			b = a
+			a = t1 + t2
+		}
+
+		h0 += a
+		h1 += b
+		h2 += c
+		h3 += d
+		h4 += e
+		h5 += f
+		h6 += g
+		h7 += h
+
+		p = p[chunk:]
+	}
+
+	dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7] = h0, h1, h2, h3, h4, h5, h6, h7
+}