gofront 1.8.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/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/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")
+}

package/stdlib/fmt/errors.go

@@ -0,0 +1,110 @@
+// Copyright 2018 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.
+
+//go:build gofront
+
+//gofront:target both
+
+package fmt
+
+// Errorf formats according to a format specifier and returns the string as a
+// value that satisfies error.
+//
+// If the format specifier includes a %w verb with an error operand,
+// the returned error will implement an Unwrap method returning the operand.
+// If there is more than one %w verb, the returned error will implement an
+// Unwrap method returning a []error containing all the %w operands in the
+// order they appear in the arguments.
+// It is invalid to supply the %w verb with an operand that does not implement
+// the error interface. The %w verb is otherwise a synonym for %v.
+func Errorf(format string, a ...any) error {
+	p := newPrinter()
+	p.wrapErrs = true
+	p.doPrintf(format, a)
+	s := string(p.fmt.bytes())
+	var err error
+	switch len(p.wrappedErrs) {
+	case 0:
+		err = &plainError{s}
+	case 1:
+		w := &wrapError{msg: s}
+		w.err = describe(a[p.wrappedErrs[0]]).Err
+		err = w
+	default:
+		if p.reordered {
+			sortInts(p.wrappedErrs)
+		}
+		var errs []error
+		for i, argNum := range p.wrappedErrs {
+			if i > 0 && p.wrappedErrs[i-1] == argNum {
+				continue
+			}
+			if e := describe(a[argNum]).Err; e != nil {
+				errs = append(errs, e)
+			}
+		}
+		err = &wrapErrors{s, errs}
+	}
+	return err
+}
+
+// sortInts is an insertion sort; it keeps fmt from importing slices.
+func sortInts(x []int) {
+	for i := 1; i < len(x); i++ {
+		for j := i; j > 0 && x[j] < x[j-1]; j-- {
+			x[j], x[j-1] = x[j-1], x[j]
+		}
+	}
+}
+
+// plainError is what errors.New returns, repeated here so that every fmt
+// user does not also compile package errors.
+type plainError struct {
+	s string
+}
+
+func (e *plainError) Error() string {
+	return e.s
+}
+
+// GofrontTypeName is the type %T prints for the error: the one errors.New makes.
+func (e *plainError) GofrontTypeName() string {
+	return "*errors.errorString"
+}
+
+type wrapError struct {
+	msg string
+	err error
+}
+
+func (e *wrapError) Error() string {
+	return e.msg
+}
+
+func (e *wrapError) Unwrap() error {
+	return e.err
+}
+
+type wrapErrors struct {
+	msg  string
+	errs []error
+}
+
+func (e *wrapErrors) Error() string {
+	return e.msg
+}
+
+func (e *wrapErrors) Unwrap() []error {
+	return e.errs
+}
+
+// GofrontTypeName is the type %T prints for the error (see errors.errorString).
+func (e *wrapError) GofrontTypeName() string {
+	return "*fmt.wrapError"
+}
+
+// GofrontTypeName is the type %T prints for the error.
+func (e *wrapErrors) GofrontTypeName() string {
+	return "*fmt.wrapErrors"
+}