gofront 1.7.0 → 1.9.0

package/stdlib/encoding/hex/hex.go

@@ -0,0 +1,140 @@
+//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 hex implements hexadecimal encoding and decoding.
+package hex
+
+import (
+	"errors"
+	"fmt"
+)
+
+var hextable = []byte("0123456789abcdef")
+
+// ErrLength reports an attempt to decode an odd-length input
+// using [Decode] or [DecodeString].
+// The stream-based Decoder returns [io.ErrUnexpectedEOF] instead of ErrLength.
+var ErrLength = errors.New("encoding/hex: odd length hex string")
+
+// InvalidByteError values describe errors resulting from an invalid byte in a hex string.
+type InvalidByteError byte
+
+func (e InvalidByteError) Error() string {
+	return fmt.Sprintf("encoding/hex: invalid byte: %#U", rune(e))
+}
+
+// EncodedLen returns the length of an encoding of n source bytes.
+// Specifically, it returns n * 2.
+func EncodedLen(n int) int { return n * 2 }
+
+// Encode encodes src into [EncodedLen](len(src))
+// bytes of dst. As a convenience, it returns the number
+// of bytes written to dst, but this value is always [EncodedLen](len(src)).
+// Encode implements hexadecimal encoding.
+func Encode(dst, src []byte) int {
+	j := 0
+	for _, v := range src {
+		dst[j] = hextable[v>>4]
+		dst[j+1] = hextable[v&0x0f]
+		j += 2
+	}
+	return len(src) * 2
+}
+
+// AppendEncode appends the hexadecimally encoded src to dst
+// and returns the extended buffer.
+func AppendEncode(dst, src []byte) []byte {
+	for _, v := range src {
+		dst = append(dst, hextable[v>>4], hextable[v&0x0f])
+	}
+	return dst
+}
+
+// DecodedLen returns the length of a decoding of x source bytes.
+// Specifically, it returns x / 2.
+func DecodedLen(x int) int { return x / 2 }
+
+// fromHexChar converts a hex character into its value and a success flag.
+func fromHexChar(c byte) (byte, bool) {
+	switch {
+	case '0' <= c && c <= '9':
+		return c - '0', true
+	case 'a' <= c && c <= 'f':
+		return c - 'a' + 10, true
+	case 'A' <= c && c <= 'F':
+		return c - 'A' + 10, true
+	}
+
+	return 0, false
+}
+
+// Decode decodes src into [DecodedLen](len(src)) bytes,
+// returning the actual number of bytes written to dst.
+//
+// Decode expects that src contains only hexadecimal
+// characters and that src has even length.
+// If the input is malformed, Decode returns the number
+// of bytes decoded before the error.
+func Decode(dst, src []byte) (int, error) {
+	i, j := 0, 1
+	for ; j < len(src); j += 2 {
+		p := src[j-1]
+		q := src[j]
+
+		a, aok := fromHexChar(p)
+		if !aok {
+			return i, InvalidByteError(p)
+		}
+		b, bok := fromHexChar(q)
+		if !bok {
+			return i, InvalidByteError(q)
+		}
+
+		dst[i] = (a << 4) | b
+		i++
+	}
+	if len(src)%2 == 1 {
+		// Check for invalid char before reporting bad length,
+		// since the invalid char (if present) is an earlier problem.
+		if _, ok := fromHexChar(src[j-1]); !ok {
+			return i, InvalidByteError(src[j-1])
+		}
+		return i, ErrLength
+	}
+	return i, nil
+}
+
+// AppendDecode appends the hexadecimally decoded src to dst
+// and returns the extended buffer.
+// If the input is malformed, it returns the partially decoded src and an error.
+func AppendDecode(dst, src []byte) ([]byte, error) {
+	buf := make([]byte, DecodedLen(len(src)))
+	n, err := Decode(buf, src)
+	return append(dst, buf[:n]...), err
+}
+
+// EncodeToString returns the hexadecimal encoding of src.
+func EncodeToString(src []byte) string {
+	dst := make([]byte, EncodedLen(len(src)))
+	Encode(dst, src)
+	return string(dst)
+}
+
+// DecodeString returns the bytes represented by the hexadecimal string s.
+//
+// DecodeString expects that src contains only hexadecimal
+// characters and that src has even length.
+// If the input is malformed, DecodeString returns
+// the bytes decoded before the error.
+func DecodeString(s string) ([]byte, error) {
+	src := []byte(s)
+	// We can use the source slice itself as the destination
+	// because the decode loop increments by one and then the 'seen' byte is not used anymore.
+	n, err := Decode(src, src)
+	return src[:n], err
+}

package/stdlib/encoding/json/errors.go

@@ -0,0 +1,31 @@
+//go:build gofront
+
+//gofront:target both
+
+package json
+
+import (
+	"internal/jsonrt"
+)
+
+// A SyntaxError is a description of a JSON syntax error.
+// [Unmarshal] will return a SyntaxError if the JSON can't be parsed.
+type SyntaxError = jsonrt.SyntaxError
+
+// An UnmarshalTypeError describes a JSON value that was not appropriate for
+// a value of a specific Go type.
+type UnmarshalTypeError = jsonrt.UnmarshalTypeError
+
+// An InvalidUnmarshalError describes an invalid argument passed to Unmarshal.
+type InvalidUnmarshalError = jsonrt.InvalidUnmarshalError
+
+// An UnsupportedValueError is returned by Marshal when attempting to encode
+// an unsupported value.
+type UnsupportedValueError = jsonrt.UnsupportedValueError
+
+// UnsupportedTypeError is returned by Marshal when attempting to encode an
+// unsupported value type.
+type UnsupportedTypeError = jsonrt.UnsupportedTypeError
+
+// A MarshalerError represents an error from calling a MarshalJSON method.
+type MarshalerError = jsonrt.MarshalerError

package/stdlib/encoding/json/indent.go

@@ -0,0 +1,71 @@
+//go:build gofront
+
+//gofront:target both
+
+package json
+
+import (
+	"bytes"
+	"internal/jsonrt"
+)
+
+var hexDigits = []byte("0123456789abcdef")
+
+func escapeLen(src []byte, i int) int {
+	c := src[i]
+	if c == '<' || c == '>' || c == '&' {
+		return 1
+	}
+	if c == 0xE2 && i+2 < len(src) && src[i+1] == 0x80 && (src[i+2]&^1) == 0xA8 {
+		return 3
+	}
+	return 0
+}
+
+// HTMLEscape appends to dst the JSON-encoded src with <, >, &, U+2028 and U+2029
+// characters inside string literals changed to \u003c, \u003e, \u0026, \u2028, \u2029
+// so that the JSON will be safe to embed inside HTML <script> tags.
+func HTMLEscape(dst *bytes.Buffer, src []byte) {
+	start := 0
+	for i := 0; i < len(src); {
+		n := escapeLen(src, i)
+		if n == 0 {
+			i++
+			continue
+		}
+		if start < i {
+			dst.Write(src[start:i])
+		}
+		if n == 1 {
+			c := src[i]
+			dst.Write([]byte{'\\', 'u', '0', '0', hexDigits[c>>4], hexDigits[c&0xF]})
+			i++
+		} else {
+			dst.Write([]byte{'\\', 'u', '2', '0', '2', hexDigits[src[i+2]&0xF]})
+			i += 3
+		}
+		start = i
+	}
+	if start < len(src) {
+		dst.Write(src[start:])
+	}
+}
+
+// Compact appends to dst the JSON-encoded src with
+// insignificant space characters elided.
+func Compact(dst *bytes.Buffer, src []byte) error {
+	b, err := jsonrt.AppendCompact(nil, src, false)
+	if len(b) > 0 {
+		dst.Write(b)
+	}
+	return err
+}
+
+// Indent appends to dst an indented form of the JSON-encoded src.
+func Indent(dst *bytes.Buffer, src []byte, prefix, indent string) error {
+	b, err := jsonrt.AppendIndent(nil, src, prefix, indent)
+	if len(b) > 0 {
+		dst.Write(b)
+	}
+	return err
+}

package/stdlib/encoding/json/json.go

@@ -0,0 +1,62 @@
+//go:build gofront
+
+//gofront:target both
+
+package json
+
+import (
+	"errors"
+	"internal/jsonrt"
+)
+
+// Marshal returns the JSON encoding of v.
+//
+// The compiler replaces every call with a function generated for the static
+// type of v, so this body runs only when Marshal is used as a value, which
+// the compiler rejects.
+func Marshal(v any) ([]byte, error) {
+	panic("json.Marshal: call sites are rewritten by the compiler")
+}
+
+// MarshalIndent is like Marshal but applies Indent to format the output.
+//
+// The compiler replaces every call with a generated function; see Marshal.
+func MarshalIndent(v any, prefix, indent string) ([]byte, error) {
+	panic("json.MarshalIndent: call sites are rewritten by the compiler")
+}
+
+// Unmarshal parses the JSON-encoded data and stores the result in the value
+// pointed to by v.
+//
+// The compiler replaces every call with a function generated for the static
+// type of v; see Marshal.
+func Unmarshal(data []byte, v any) error {
+	panic("json.Unmarshal: call sites are rewritten by the compiler")
+}
+
+// Valid reports whether data is a valid JSON encoding.
+func Valid(data []byte) bool {
+	return jsonrt.Valid(data)
+}
+
+// RawMessage is a raw encoded JSON value. It implements Marshaler and
+// Unmarshaler and can be used to delay JSON decoding or precompute a JSON
+// encoding.
+type RawMessage []byte
+
+// MarshalJSON returns m as the JSON encoding of m.
+func (m RawMessage) MarshalJSON() ([]byte, error) {
+	if m == nil {
+		return []byte("null"), nil
+	}
+	return m, nil
+}
+
+// UnmarshalJSON sets *m to a copy of data.
+func (m *RawMessage) UnmarshalJSON(data []byte) error {
+	if m == nil {
+		return errors.New("json.RawMessage: UnmarshalJSON on nil pointer")
+	}
+	*m = append((*m)[0:0], data...)
+	return nil
+}

package/stdlib/encoding/json/number.go

@@ -0,0 +1,12 @@
+//go:build gofront
+
+//gofront:target both
+
+package json
+
+import (
+	"internal/jsonrt"
+)
+
+// A Number represents a JSON number literal.
+type Number = jsonrt.Number

package/stdlib/encoding/json/stream.go

@@ -0,0 +1,173 @@
+//go:build gofront
+
+//gofront:target both
+
+package json
+
+import (
+	"bytes"
+	"internal/jsonrt"
+	"io"
+)
+
+// An Encoder writes JSON values to an output stream.
+type Encoder struct {
+	w          io.Writer
+	err        error
+	prefix     string
+	indent     string
+	escapeHTML bool
+}
+
+// NewEncoder returns a new encoder that writes to w.
+func NewEncoder(w io.Writer) *Encoder {
+	return &Encoder{w: w, escapeHTML: true}
+}
+
+// SetIndent instructs the encoder to format each subsequent encoded
+// value as if indented by the package-level function Indent.
+// Calling SetIndent("", "") turns off indentation.
+func (enc *Encoder) SetIndent(prefix, indent string) {
+	enc.prefix = prefix
+	enc.indent = indent
+}
+
+// SetEscapeHTML specifies whether problematic HTML characters
+// should be escaped inside JSON-quoted strings.
+// The default behavior is true.
+func (enc *Encoder) SetEscapeHTML(on bool) {
+	enc.escapeHTML = on
+}
+
+// Err returns the first error the encoder encountered, if any.
+func (enc *Encoder) Err() error {
+	return enc.err
+}
+
+// EscapeHTML returns whether HTML escaping is enabled.
+func (enc *Encoder) EscapeHTML() bool {
+	return enc.escapeHTML
+}
+
+// EncodeRaw formats b with indentation if configured and writes it to the output stream.
+func (enc *Encoder) EncodeRaw(b []byte) error {
+	if enc.err != nil {
+		return enc.err
+	}
+	if enc.indent != "" || enc.prefix != "" {
+		var buf bytes.Buffer
+		if err := Indent(&buf, b, enc.prefix, enc.indent); err != nil {
+			return err
+		}
+		b = buf.Bytes()
+	}
+	b = append(b, '\n')
+	if _, err := enc.w.Write(b); err != nil {
+		enc.err = err
+		return err
+	}
+	return nil
+}
+
+// Encode writes the JSON encoding of v to the stream, followed by a newline character.
+func (enc *Encoder) Encode(v any) error {
+	if enc.err != nil {
+		return enc.err
+	}
+	return enc.EncodeRaw(nil)
+}
+
+// A Decoder reads and decodes JSON values from an input stream.
+type Decoder struct {
+	r                     *jsonrt.Reader
+	useNumber             bool
+	disallowUnknownFields bool
+	offset                int64
+}
+
+// NewDecoder returns a new decoder that reads from r.
+func NewDecoder(r io.Reader) *Decoder {
+	return &Decoder{r: jsonrt.NewReader(r)}
+}
+
+// UseNumber causes the Decoder to unmarshal a number into an interface{} as a
+// Number instead of as a float64.
+func (dec *Decoder) UseNumber() {
+	dec.useNumber = true
+}
+
+// DisallowUnknownFields causes the Decoder to return an error when the destination
+// is a struct and the input contains object keys which do not match any
+// non-ignored, exported fields in the destination.
+func (dec *Decoder) DisallowUnknownFields() {
+	dec.disallowUnknownFields = true
+}
+
+// InputOffset returns the input stream byte offset of the current decoder position.
+// The offset gives the location of the end of the most recently returned token
+// and the beginning of the immediately following token.
+func (dec *Decoder) InputOffset() int64 {
+	return dec.offset
+}
+
+// Buffered returns a reader of the data remaining in the Decoder's
+// buffer. The reader is valid until the next call to Decode.
+func (dec *Decoder) Buffered() io.Reader {
+	p := dec.r.Buffered()
+	if len(p) > 0 {
+		return bytes.NewReader(p)
+	}
+	return bytes.NewReader(nil)
+}
+
+// More reports whether there is another element in the current array
+// or object being parsed, or whether there is another value in the stream.
+func (dec *Decoder) More() bool {
+	for {
+		b, err := dec.r.ReadByte()
+		if err != nil {
+			return false
+		}
+		if isSpace(b) {
+			dec.offset++
+			continue
+		}
+		dec.r.UnreadByte()
+		if b == ']' || b == '}' {
+			return false
+		}
+		return true
+	}
+}
+
+// ScanNext consumes whitespace, scans the next JSON value, and updates dec.offset.
+func (dec *Decoder) ScanNext() ([]byte, error) {
+	data, skipped, err := jsonrt.ScanNext(dec.r)
+	dec.offset += skipped
+	if err != nil {
+		return nil, err
+	}
+	dec.offset += int64(len(data))
+	return data, nil
+}
+
+// SetupDec configures a jsonrt.Dec with this decoder's options.
+func (dec *Decoder) SetupDec(d *jsonrt.Dec) {
+	d.UseNumber = dec.useNumber
+	d.DisallowUnknownFields = dec.disallowUnknownFields
+}
+
+func isSpace(c byte) bool {
+	return c <= ' ' && (c == ' ' || c == '\t' || c == '\r' || c == '\n')
+}
+
+// Decode reads the next JSON-encoded value from its input and stores it in the
+// value pointed to by v.
+func (dec *Decoder) Decode(v any) error {
+	data, err := dec.ScanNext()
+	if err != nil {
+		return err
+	}
+	_ = data
+	return nil
+}

package/stdlib/errors/errors.go

@@ -0,0 +1,174 @@
+//go:build gofront
+
+//gofront:target both
+
+// Copyright 2011 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 errors implements functions to manipulate errors.
+//
+// New, Unwrap, Is, Join and ErrUnsupported are written in Go over the
+// real package's algorithms. As stores through a pointer target whose type
+// only the compiler knows, which Go source cannot express without
+// reflection: every call is rewritten to a function generated for its
+// target type (src/lower/errors-as.js).
+//
+// Is does not check that target is comparable before comparing, as Go
+// does with reflection: an error whose dynamic type is a slice, map or
+// func panics when it is compared.
+package errors
+
+// New returns an error that formats as the given text.
+// Each call to New returns a distinct error value even if the text is identical.
+func New(text string) error {
+	return &errorString{text}
+}
+
+// errorString is a trivial implementation of error.
+type errorString struct {
+	s string
+}
+
+func (e *errorString) Error() string {
+	return e.s
+}
+
+// GofrontTypeName is the type %T prints for the error. Package fmt cannot
+// name the unexported type, so the error says it.
+func (e *errorString) GofrontTypeName() string {
+	return "*errors.errorString"
+}
+
+// GofrontFmt is how package fmt prints the error with a verb that does not
+// apply to it (%v only reaches it from a failed verb): Go prints the pointer
+// to the struct, whose one field is a string.
+func (e *errorString) GofrontFmt(verb rune) string {
+	if verb == 'v' {
+		return "&{" + e.s + "}"
+	}
+	return "&{%!" + string(verb) + "(string=" + e.s + ")}"
+}
+
+// ErrUnsupported indicates that a requested operation cannot be performed,
+// because it is unsupported.
+var ErrUnsupported = New("unsupported operation")
+
+// Unwrap returns the result of calling the Unwrap method on err, if err's
+// type contains an Unwrap method returning error.
+// Otherwise, Unwrap returns nil.
+//
+// Unwrap only calls a method of the form "Unwrap() error".
+// In particular Unwrap does not unwrap errors returned by [Join].
+func Unwrap(err error) error {
+	u, ok := err.(interface {
+		Unwrap() error
+	})
+	if !ok {
+		return nil
+	}
+	return u.Unwrap()
+}
+
+// Is reports whether any error in err's tree matches target.
+//
+// The tree consists of err itself, followed by the errors obtained by
+// repeatedly calling its Unwrap() error or Unwrap() []error method.
+// When err wraps multiple errors, Is examines err followed by a
+// depth-first traversal of its children.
+//
+// An error is considered to match a target if it is equal to that target or if
+// it implements a method Is(error) bool such that Is(target) returns true.
+func Is(err, target error) bool {
+	if err == nil || target == nil {
+		return err == target
+	}
+	return is(err, target)
+}
+
+func is(err, target error) bool {
+	for {
+		if err == target {
+			return true
+		}
+		if x, ok := err.(interface{ Is(error) bool }); ok && x.Is(target) {
+			return true
+		}
+		switch x := err.(type) {
+		case interface{ Unwrap() error }:
+			err = x.Unwrap()
+			if err == nil {
+				return false
+			}
+		case interface{ Unwrap() []error }:
+			for _, err := range x.Unwrap() {
+				if is(err, target) {
+					return true
+				}
+			}
+			return false
+		default:
+			return false
+		}
+	}
+}
+
+// Join returns an error that wraps the given errors.
+// Any nil error values are discarded.
+// Join returns nil if every value in errs is nil.
+// The error formats as the concatenation of the strings obtained
+// by calling the Error method of each element of errs, with a newline
+// between each string.
+//
+// A non-nil error returned by Join implements the Unwrap() []error method.
+func Join(errs ...error) error {
+	n := 0
+	for _, err := range errs {
+		if err != nil {
+			n++
+		}
+	}
+	if n == 0 {
+		return nil
+	}
+	e := &joinError{
+		errs: make([]error, 0, n),
+	}
+	for _, err := range errs {
+		if err != nil {
+			e.errs = append(e.errs, err)
+		}
+	}
+	return e
+}
+
+type joinError struct {
+	errs []error
+}
+
+// GofrontTypeName is the type %T prints for the error (see errorString).
+func (e *joinError) GofrontTypeName() string {
+	return "*errors.joinError"
+}
+
+func (e *joinError) Error() string {
+	s := e.errs[0].Error()
+	for _, err := range e.errs[1:] {
+		s += "\n" + err.Error()
+	}
+	return s
+}
+
+func (e *joinError) Unwrap() []error {
+	return e.errs
+}
+
+// As finds the first error in err's tree that matches target, and if one is
+// found, sets target to that error value and returns true.
+//
+// The compiler replaces every call with a generated function for the static
+// type of target, so this body runs only when As is used as a value, which
+// the compiler rejects.
+func As(err error, target any) bool {
+	panic("errors.As: call sites are rewritten by the compiler")
+}