[feature] Clean up/uncache remote media (#407)

* Add whereNotEmptyAndNotNull

* Add GetRemoteOlderThanDays

* Add GetRemoteOlderThanDays

* Add PruneRemote to Manager interface

* Start implementing PruneRemote

* add new attachment + status to tests

* fix up and test GetRemoteOlderThan

* fix bad import

* PruneRemote: return number pruned

* add Cached column to mediaattachment

* update + test pruneRemote

* update mediaTest

* use Cached column

* upstep bun to latest version

* embed structs in mediaAttachment

* migrate mediaAttachment to new format

* don't default cached to true

* select only remote media

* update db dependencies

* step bun back to last working version

* update pruneRemote to use Cached field

* fix storage path of test attachments

* add recache logic to manager

* fix trimmed aspect ratio

* test prune and recache

* return errwithcode

* tidy up different paths for emoji vs attachment

* fix incorrect thumbnail type being stored

* expose TransportController to media processor

* implement tee-ing recached content

* add thoughts of dog to test fedi attachments

* test get remote files

* add comment on PruneRemote

* add postData cleanup to recache

* test thumbnail fetching

* add incredible diagram

* go mod tidy

* buffer pipes for recache streaming

* test for client stops reading after 1kb

* add media-remote-cache-days to config

* add cron package

* wrap logrus so it's available to cron

* start and stop cron jobs gracefully

vendor/github.com/jackc/pgconn/CHANGELOG.md

@@ -1,3 +1,10 @@
+# 1.11.0 (February 7, 2022)
+
+* Support port in ip from LookupFunc to override config (James Hartig)
+* Fix TLS connection timeout (Blake Embrey)
+* Add support for read-only, primary, standby, prefer-standby target_session_attributes (Oscar)
+* Fix connect when receiving NoticeResponse
+
 # 1.10.1 (November 20, 2021)
 
 * Close without waiting for response (Kei Kamikawa)

vendor/github.com/jackc/pgconn/config.go

@@ -248,21 +248,21 @@ func ParseConfig(connString string) (*Config, error) {
 	config.LookupFunc = makeDefaultResolver().LookupHost
 
 	notRuntimeParams := map[string]struct{}{
-		"host":                 struct{}{},
-		"port":                 struct{}{},
-		"database":             struct{}{},
-		"user":                 struct{}{},
-		"password":             struct{}{},
-		"passfile":             struct{}{},
-		"connect_timeout":      struct{}{},
-		"sslmode":              struct{}{},
-		"sslkey":               struct{}{},
-		"sslcert":              struct{}{},
-		"sslrootcert":          struct{}{},
-		"target_session_attrs": struct{}{},
-		"min_read_buffer_size": struct{}{},
-		"service":              struct{}{},
-		"servicefile":          struct{}{},
+		"host":                 {},
+		"port":                 {},
+		"database":             {},
+		"user":                 {},
+		"password":             {},
+		"passfile":             {},
+		"connect_timeout":      {},
+		"sslmode":              {},
+		"sslkey":               {},
+		"sslcert":              {},
+		"sslrootcert":          {},
+		"target_session_attrs": {},
+		"min_read_buffer_size": {},
+		"service":              {},
+		"servicefile":          {},
 	}
 
 	for k, v := range settings {
@@ -329,10 +329,19 @@ func ParseConfig(connString string) (*Config, error) {
 		}
 	}
 
-	if settings["target_session_attrs"] == "read-write" {
+	switch tsa := settings["target_session_attrs"]; tsa {
+	case "read-write":
 		config.ValidateConnect = ValidateConnectTargetSessionAttrsReadWrite
-	} else if settings["target_session_attrs"] != "any" {
-		return nil, &parseConfigError{connString: connString, msg: fmt.Sprintf("unknown target_session_attrs value: %v", settings["target_session_attrs"])}
+	case "read-only":
+		config.ValidateConnect = ValidateConnectTargetSessionAttrsReadOnly
+	case "primary":
+		config.ValidateConnect = ValidateConnectTargetSessionAttrsPrimary
+	case "standby":
+		config.ValidateConnect = ValidateConnectTargetSessionAttrsStandby
+	case "any", "prefer-standby":
+		// do nothing
+	default:
+		return nil, &parseConfigError{connString: connString, msg: fmt.Sprintf("unknown target_session_attrs value: %v", tsa)}
 	}
 
 	return config, nil
@@ -727,3 +736,48 @@ func ValidateConnectTargetSessionAttrsReadWrite(ctx context.Context, pgConn *PgC
 
 	return nil
 }
+
+// ValidateConnectTargetSessionAttrsReadOnly is an ValidateConnectFunc that implements libpq compatible
+// target_session_attrs=read-only.
+func ValidateConnectTargetSessionAttrsReadOnly(ctx context.Context, pgConn *PgConn) error {
+	result := pgConn.ExecParams(ctx, "show transaction_read_only", nil, nil, nil, nil).Read()
+	if result.Err != nil {
+		return result.Err
+	}
+
+	if string(result.Rows[0][0]) != "on" {
+		return errors.New("connection is not read only")
+	}
+
+	return nil
+}
+
+// ValidateConnectTargetSessionAttrsStandby is an ValidateConnectFunc that implements libpq compatible
+// target_session_attrs=standby.
+func ValidateConnectTargetSessionAttrsStandby(ctx context.Context, pgConn *PgConn) error {
+	result := pgConn.ExecParams(ctx, "select pg_is_in_recovery()", nil, nil, nil, nil).Read()
+	if result.Err != nil {
+		return result.Err
+	}
+
+	if string(result.Rows[0][0]) != "t" {
+		return errors.New("server is not in hot standby mode")
+	}
+
+	return nil
+}
+
+// ValidateConnectTargetSessionAttrsPrimary is an ValidateConnectFunc that implements libpq compatible
+// target_session_attrs=primary.
+func ValidateConnectTargetSessionAttrsPrimary(ctx context.Context, pgConn *PgConn) error {
+	result := pgConn.ExecParams(ctx, "select pg_is_in_recovery()", nil, nil, nil, nil).Read()
+	if result.Err != nil {
+		return result.Err
+	}
+
+	if string(result.Rows[0][0]) == "t" {
+		return errors.New("server is in standby mode")
+	}
+
+	return nil
+}

vendor/github.com/jackc/pgconn/pgconn.go

@@ -11,6 +11,7 @@ import (
 	"io"
 	"math"
 	"net"
+	"strconv"
 	"strings"
 	"sync"
 	"time"
@@ -44,7 +45,8 @@ type Notification struct {
 // DialFunc is a function that can be used to connect to a PostgreSQL server.
 type DialFunc func(ctx context.Context, network, addr string) (net.Conn, error)
 
-// LookupFunc is a function that can be used to lookup IPs addrs from host.
+// LookupFunc is a function that can be used to lookup IPs addrs from host. Optionally an ip:port combination can be
+// returned in order to override the connection string's port.
 type LookupFunc func(ctx context.Context, host string) (addrs []string, err error)
 
 // BuildFrontendFunc is a function that can be used to create Frontend implementation for connection.
@@ -196,11 +198,24 @@ func expandWithIPs(ctx context.Context, lookupFn LookupFunc, fallbacks []*Fallba
 		}
 
 		for _, ip := range ips {
-			configs = append(configs, &FallbackConfig{
-				Host:      ip,
-				Port:      fb.Port,
-				TLSConfig: fb.TLSConfig,
-			})
+			splitIP, splitPort, err := net.SplitHostPort(ip)
+			if err == nil {
+				port, err := strconv.ParseUint(splitPort, 10, 16)
+				if err != nil {
+					return nil, fmt.Errorf("error parsing port (%s) from lookup: %w", splitPort, err)
+				}
+				configs = append(configs, &FallbackConfig{
+					Host:      splitIP,
+					Port:      uint16(port),
+					TLSConfig: fb.TLSConfig,
+				})
+			} else {
+				configs = append(configs, &FallbackConfig{
+					Host:      ip,
+					Port:      fb.Port,
+					TLSConfig: fb.TLSConfig,
+				})
+			}
 		}
 	}
 
@@ -215,7 +230,7 @@ func connect(ctx context.Context, config *Config, fallbackConfig *FallbackConfig
 
 	var err error
 	network, address := NetworkAddress(fallbackConfig.Host, fallbackConfig.Port)
-	pgConn.conn, err = config.DialFunc(ctx, network, address)
+	netConn, err := config.DialFunc(ctx, network, address)
 	if err != nil {
 		var netErr net.Error
 		if errors.As(err, &netErr) && netErr.Timeout() {
@@ -224,24 +239,27 @@ func connect(ctx context.Context, config *Config, fallbackConfig *FallbackConfig
 		return nil, &connectError{config: config, msg: "dial error", err: err}
 	}
 
-	pgConn.parameterStatuses = make(map[string]string)
+	pgConn.conn = netConn
+	pgConn.contextWatcher = newContextWatcher(netConn)
+	pgConn.contextWatcher.Watch(ctx)
 
 	if fallbackConfig.TLSConfig != nil {
-		if err := pgConn.startTLS(fallbackConfig.TLSConfig); err != nil {
-			pgConn.conn.Close()
+		tlsConn, err := startTLS(netConn, fallbackConfig.TLSConfig)
+		pgConn.contextWatcher.Unwatch() // Always unwatch `netConn` after TLS.
+		if err != nil {
+			netConn.Close()
 			return nil, &connectError{config: config, msg: "tls error", err: err}
 		}
+
+		pgConn.conn = tlsConn
+		pgConn.contextWatcher = newContextWatcher(tlsConn)
+		pgConn.contextWatcher.Watch(ctx)
 	}
 
-	pgConn.status = connStatusConnecting
-	pgConn.contextWatcher = ctxwatch.NewContextWatcher(
-		func() { pgConn.conn.SetDeadline(time.Date(1, 1, 1, 1, 1, 1, 1, time.UTC)) },
-		func() { pgConn.conn.SetDeadline(time.Time{}) },
-	)
-
-	pgConn.contextWatcher.Watch(ctx)
 	defer pgConn.contextWatcher.Unwatch()
 
+	pgConn.parameterStatuses = make(map[string]string)
+	pgConn.status = connStatusConnecting
 	pgConn.frontend = config.BuildFrontend(pgConn.conn, pgConn.conn)
 
 	startupMsg := pgproto3.StartupMessage{
@@ -317,7 +335,7 @@ func connect(ctx context.Context, config *Config, fallbackConfig *FallbackConfig
 				}
 			}
 			return pgConn, nil
-		case *pgproto3.ParameterStatus:
+		case *pgproto3.ParameterStatus, *pgproto3.NoticeResponse:
 			// handled by ReceiveMessage
 		case *pgproto3.ErrorResponse:
 			pgConn.conn.Close()
@@ -329,24 +347,29 @@ func connect(ctx context.Context, config *Config, fallbackConfig *FallbackConfig
 	}
 }
 
-func (pgConn *PgConn) startTLS(tlsConfig *tls.Config) (err error) {
-	err = binary.Write(pgConn.conn, binary.BigEndian, []int32{8, 80877103})
+func newContextWatcher(conn net.Conn) *ctxwatch.ContextWatcher {
+	return ctxwatch.NewContextWatcher(
+		func() { conn.SetDeadline(time.Date(1, 1, 1, 1, 1, 1, 1, time.UTC)) },
+		func() { conn.SetDeadline(time.Time{}) },
+	)
+}
+
+func startTLS(conn net.Conn, tlsConfig *tls.Config) (net.Conn, error) {
+	err := binary.Write(conn, binary.BigEndian, []int32{8, 80877103})
 	if err != nil {
-		return
+		return nil, err
 	}
 
 	response := make([]byte, 1)
-	if _, err = io.ReadFull(pgConn.conn, response); err != nil {
-		return
+	if _, err = io.ReadFull(conn, response); err != nil {
+		return nil, err
 	}
 
 	if response[0] != 'S' {
-		return errors.New("server refused TLS connection")
+		return nil, errors.New("server refused TLS connection")
 	}
 
-	pgConn.conn = tls.Client(pgConn.conn, tlsConfig)
-
-	return nil
+	return tls.Client(conn, tlsConfig), nil
 }
 
 func (pgConn *PgConn) txPasswordMessage(password string) (err error) {
@@ -1694,10 +1717,7 @@ func Construct(hc *HijackedConn) (*PgConn, error) {
 		cleanupDone: make(chan struct{}),
 	}
 
-	pgConn.contextWatcher = ctxwatch.NewContextWatcher(
-		func() { pgConn.conn.SetDeadline(time.Date(1, 1, 1, 1, 1, 1, 1, time.UTC)) },
-		func() { pgConn.conn.SetDeadline(time.Time{}) },
-	)
+	pgConn.contextWatcher = newContextWatcher(pgConn.conn)
 
 	return pgConn, nil
 }

vendor/github.com/jackc/pgtype/CHANGELOG.md

@@ -1,3 +1,10 @@
+# 1.10.0 (February 7, 2022)
+
+* Normalize UTC timestamps to comply with stdlib (Torkel Rogstad)
+* Assign Numeric to *big.Rat (Oleg Lomaka)
+* Fix typo in float8 error message (Pinank Solanki)
+* Scan type aliases for floating point types (Collin Forsyth)
+
 # 1.9.1 (November 28, 2021)
 
 * Fix: binary timestamp is assumed to be in UTC (restored behavior changed in v1.9.0)

vendor/github.com/jackc/pgtype/convert.go

@@ -337,6 +337,10 @@ func float64AssignTo(srcVal float64, srcStatus Status, dst interface{}) error {
 			if v := reflect.ValueOf(dst); v.Kind() == reflect.Ptr {
 				el := v.Elem()
 				switch el.Kind() {
+				// if dst is a type alias of a float32 or 64, set dst val
+				case reflect.Float32, reflect.Float64:
+					el.SetFloat(srcVal)
+					return nil
 				// if dst is a pointer to pointer, strip the pointer and try again
 				case reflect.Ptr:
 					if el.IsNil() {

vendor/github.com/jackc/pgtype/float8.go

@@ -204,7 +204,7 @@ func (dst *Float8) DecodeBinary(ci *ConnInfo, src []byte) error {
 	}
 
 	if len(src) != 8 {
-		return fmt.Errorf("invalid length for float4: %v", len(src))
+		return fmt.Errorf("invalid length for float8: %v", len(src))
 	}
 
 	n := int64(binary.BigEndian.Uint64(src))

vendor/github.com/jackc/pgtype/numeric.go

@@ -369,6 +369,12 @@ func (src *Numeric) AssignTo(dst interface{}) error {
 				return fmt.Errorf("%d is greater than maximum value for %T", normalizedInt, *v)
 			}
 			*v = normalizedInt.Uint64()
+		case *big.Rat:
+			rat, err := src.toBigRat()
+			if err != nil {
+				return err
+			}
+			v.Set(rat)
 		default:
 			if nextDst, retry := GetAssignToDstType(dst); retry {
 				return src.AssignTo(nextDst)
@@ -406,6 +412,26 @@ func (dst *Numeric) toBigInt() (*big.Int, error) {
 	return num, nil
 }
 
+func (dst *Numeric) toBigRat() (*big.Rat, error) {
+	if dst.NaN {
+		return nil, fmt.Errorf("%v is not a number", dst)
+	} else if dst.InfinityModifier == Infinity {
+		return nil, fmt.Errorf("%v is infinity", dst)
+	} else if dst.InfinityModifier == NegativeInfinity {
+		return nil, fmt.Errorf("%v is -infinity", dst)
+	}
+
+	num := new(big.Rat).SetInt(dst.Int)
+	if dst.Exp > 0 {
+		mul := new(big.Int).Exp(big10, big.NewInt(int64(dst.Exp)), nil)
+		num.Mul(num, new(big.Rat).SetInt(mul))
+	} else if dst.Exp < 0 {
+		mul := new(big.Int).Exp(big10, big.NewInt(int64(-dst.Exp)), nil)
+		num.Quo(num, new(big.Rat).SetInt(mul))
+	}
+	return num, nil
+}
+
 func (src *Numeric) toFloat64() (float64, error) {
 	if src.NaN {
 		return math.NaN(), nil

vendor/github.com/jackc/pgtype/timestamptz.go

@@ -124,7 +124,7 @@ func (dst *Timestamptz) DecodeText(ci *ConnInfo, src []byte) error {
 			return err
 		}
 
-		*dst = Timestamptz{Time: tim, Status: Present}
+		*dst = Timestamptz{Time: normalizePotentialUTC(tim), Status: Present}
 	}
 
 	return nil
@@ -231,6 +231,9 @@ func (src Timestamptz) Value() (driver.Value, error) {
 		if src.InfinityModifier != None {
 			return src.InfinityModifier.String(), nil
 		}
+		if src.Time.Location().String() == time.UTC.String() {
+			return src.Time.UTC(), nil
+		}
 		return src.Time, nil
 	case Null:
 		return nil, nil
@@ -289,8 +292,23 @@ func (dst *Timestamptz) UnmarshalJSON(b []byte) error {
 			return err
 		}
 
-		*dst = Timestamptz{Time: tim, Status: Present}
+		*dst = Timestamptz{Time: normalizePotentialUTC(tim), Status: Present}
 	}
 
 	return nil
 }
+
+// Normalize timestamps in UTC location to behave similarly to how the Golang
+// standard library does it: UTC timestamps lack a .loc value.
+//
+// Reason for this: when comparing two timestamps with reflect.DeepEqual (generally
+// speaking not a good idea, but several testing libraries (for example testify)
+// does this), their location data needs to be equal for them to be considered
+// equal.
+func normalizePotentialUTC(timestamp time.Time) time.Time {
+	if timestamp.Location().String() != time.UTC.String() {
+		return timestamp
+	}
+
+	return timestamp.UTC()
+}

vendor/github.com/jackc/pgx/v4/CHANGELOG.md

@@ -1,3 +1,10 @@
+# 4.15.0 (February 7, 2022)
+
+* Upgrade to pgconn v1.11.0
+* Upgrade to pgtype v1.10.0
+* Upgrade puddle to v1.2.1
+* Make BatchResults.Close safe to be called multiple times
+
 # 4.14.1 (November 28, 2021)
 
 * Upgrade pgtype to v1.9.1 (fixes unintentional change to timestamp binary decoding)

vendor/github.com/jackc/pgx/v4/batch.go

@@ -3,6 +3,7 @@ package pgx
 import (
 	"context"
 	"errors"
+	"fmt"
 
 	"github.com/jackc/pgconn"
 )
@@ -46,17 +47,18 @@ type BatchResults interface {
 
 	// Close closes the batch operation. This must be called before the underlying connection can be used again. Any error
 	// that occurred during a batch operation may have made it impossible to resyncronize the connection with the server.
-	// In this case the underlying connection will have been closed.
+	// In this case the underlying connection will have been closed. Close is safe to call multiple times.
 	Close() error
 }
 
 type batchResults struct {
-	ctx  context.Context
-	conn *Conn
-	mrr  *pgconn.MultiResultReader
-	err  error
-	b    *Batch
-	ix   int
+	ctx    context.Context
+	conn   *Conn
+	mrr    *pgconn.MultiResultReader
+	err    error
+	b      *Batch
+	ix     int
+	closed bool
 }
 
 // Exec reads the results from the next query in the batch as if the query has been sent with Exec.
@@ -64,6 +66,9 @@ func (br *batchResults) Exec() (pgconn.CommandTag, error) {
 	if br.err != nil {
 		return nil, br.err
 	}
+	if br.closed {
+		return nil, fmt.Errorf("batch already closed")
+	}
 
 	query, arguments, _ := br.nextQueryAndArgs()
 
@@ -114,6 +119,11 @@ func (br *batchResults) Query() (Rows, error) {
 		return &connRows{err: br.err, closed: true}, br.err
 	}
 
+	if br.closed {
+		alreadyClosedErr := fmt.Errorf("batch already closed")
+		return &connRows{err: alreadyClosedErr, closed: true}, alreadyClosedErr
+	}
+
 	rows := br.conn.getRows(br.ctx, query, arguments)
 
 	if !br.mrr.NextResult() {
@@ -140,6 +150,10 @@ func (br *batchResults) Query() (Rows, error) {
 
 // QueryFunc reads the results from the next query in the batch as if the query has been sent with Conn.QueryFunc.
 func (br *batchResults) QueryFunc(scans []interface{}, f func(QueryFuncRow) error) (pgconn.CommandTag, error) {
+	if br.closed {
+		return nil, fmt.Errorf("batch already closed")
+	}
+
 	rows, err := br.Query()
 	if err != nil {
 		return nil, err
@@ -179,6 +193,11 @@ func (br *batchResults) Close() error {
 		return br.err
 	}
 
+	if br.closed {
+		return nil
+	}
+	br.closed = true
+
 	// log any queries that haven't yet been logged by Exec or Query
 	for {
 		query, args, ok := br.nextQueryAndArgs()

vendor/github.com/jackc/pgx/v4/rows.go

@@ -41,10 +41,13 @@ type Rows interface {
 
 	// Scan reads the values from the current row into dest values positionally.
 	// dest can include pointers to core types, values implementing the Scanner
-	// interface, and nil. nil will skip the value entirely.
+	// interface, and nil. nil will skip the value entirely. It is an error to
+	// call Scan without first calling Next() and checking that it returned true.
 	Scan(dest ...interface{}) error
 
-	// Values returns the decoded row values.
+	// Values returns the decoded row values. As with Scan(), it is an error to
+	// call Values without first calling Next() and checking that it returned
+	// true.
 	Values() ([]interface{}, error)
 
 	// RawValues returns the unparsed bytes of the row values. The returned [][]byte is only valid until the next Next

vendor/github.com/robfig/cron/v3/.gitignore

@@ -0,0 +1,22 @@
+# Compiled Object files, Static and Dynamic libs (Shared Objects)
+*.o
+*.a
+*.so
+
+# Folders
+_obj
+_test
+
+# Architecture specific extensions/prefixes
+*.[568vq]
+[568vq].out
+
+*.cgo1.go
+*.cgo2.c
+_cgo_defun.c
+_cgo_gotypes.go
+_cgo_export.*
+
+_testmain.go
+
+*.exe

vendor/github.com/robfig/cron/v3/.travis.yml

@@ -0,0 +1 @@
+language: go

vendor/github.com/robfig/cron/v3/LICENSE

@@ -0,0 +1,21 @@
+Copyright (C) 2012 Rob Figueiredo
+All Rights Reserved.
+
+MIT LICENSE
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

vendor/github.com/robfig/cron/v3/README.md

@@ -0,0 +1,125 @@
+[![GoDoc](http://godoc.org/github.com/robfig/cron?status.png)](http://godoc.org/github.com/robfig/cron)
+[![Build Status](https://travis-ci.org/robfig/cron.svg?branch=master)](https://travis-ci.org/robfig/cron)
+
+# cron
+
+Cron V3 has been released!
+
+To download the specific tagged release, run:
+
+	go get github.com/robfig/cron/v3@v3.0.0
+
+Import it in your program as:
+
+	import "github.com/robfig/cron/v3"
+
+It requires Go 1.11 or later due to usage of Go Modules.
+
+Refer to the documentation here:
+http://godoc.org/github.com/robfig/cron
+
+The rest of this document describes the the advances in v3 and a list of
+breaking changes for users that wish to upgrade from an earlier version.
+
+## Upgrading to v3 (June 2019)
+
+cron v3 is a major upgrade to the library that addresses all outstanding bugs,
+feature requests, and rough edges. It is based on a merge of master which
+contains various fixes to issues found over the years and the v2 branch which
+contains some backwards-incompatible features like the ability to remove cron
+jobs. In addition, v3 adds support for Go Modules, cleans up rough edges like
+the timezone support, and fixes a number of bugs.
+
+New features:
+
+- Support for Go modules. Callers must now import this library as
+  `github.com/robfig/cron/v3`, instead of `gopkg.in/...`
+
+- Fixed bugs:
+  - 0f01e6b parser: fix combining of Dow and Dom (#70)
+  - dbf3220 adjust times when rolling the clock forward to handle non-existent midnight (#157)
+  - eeecf15 spec_test.go: ensure an error is returned on 0 increment (#144)
+  - 70971dc cron.Entries(): update request for snapshot to include a reply channel (#97)
+  - 1cba5e6 cron: fix: removing a job causes the next scheduled job to run too late (#206)
+
+- Standard cron spec parsing by default (first field is "minute"), with an easy
+  way to opt into the seconds field (quartz-compatible). Although, note that the
+  year field (optional in Quartz) is not supported.
+
+- Extensible, key/value logging via an interface that complies with
+  the https://github.com/go-logr/logr project.
+
+- The new Chain & JobWrapper types allow you to install "interceptors" to add
+  cross-cutting behavior like the following:
+  - Recover any panics from jobs
+  - Delay a job's execution if the previous run hasn't completed yet
+  - Skip a job's execution if the previous run hasn't completed yet
+  - Log each job's invocations
+  - Notification when jobs are completed
+
+It is backwards incompatible with both v1 and v2. These updates are required:
+
+- The v1 branch accepted an optional seconds field at the beginning of the cron
+  spec. This is non-standard and has led to a lot of confusion. The new default
+  parser conforms to the standard as described by [the Cron wikipedia page].
+
+  UPDATING: To retain the old behavior, construct your Cron with a custom
+  parser:
+
+      // Seconds field, required
+      cron.New(cron.WithSeconds())
+
+      // Seconds field, optional
+      cron.New(
+          cron.WithParser(
+              cron.SecondOptional | cron.Minute | cron.Hour | cron.Dom | cron.Month | cron.Dow | cron.Descriptor))
+
+- The Cron type now accepts functional options on construction rather than the
+  previous ad-hoc behavior modification mechanisms (setting a field, calling a setter).
+
+  UPDATING: Code that sets Cron.ErrorLogger or calls Cron.SetLocation must be
+  updated to provide those values on construction.
+
+- CRON_TZ is now the recommended way to specify the timezone of a single
+  schedule, which is sanctioned by the specification. The legacy "TZ=" prefix
+  will continue to be supported since it is unambiguous and easy to do so.
+
+  UPDATING: No update is required.
+
+- By default, cron will no longer recover panics in jobs that it runs.
+  Recovering can be surprising (see issue #192) and seems to be at odds with
+  typical behavior of libraries. Relatedly, the `cron.WithPanicLogger` option
+  has been removed to accommodate the more general JobWrapper type.
+
+  UPDATING: To opt into panic recovery and configure the panic logger:
+
+      cron.New(cron.WithChain(
+          cron.Recover(logger),  // or use cron.DefaultLogger
+      ))
+
+- In adding support for https://github.com/go-logr/logr, `cron.WithVerboseLogger` was
+  removed, since it is duplicative with the leveled logging.
+
+  UPDATING: Callers should use `WithLogger` and specify a logger that does not
+  discard `Info` logs. For convenience, one is provided that wraps `*log.Logger`:
+
+      cron.New(
+          cron.WithLogger(cron.VerbosePrintfLogger(logger)))
+
+
+### Background - Cron spec format
+
+There are two cron spec formats in common usage:
+
+- The "standard" cron format, described on [the Cron wikipedia page] and used by
+  the cron Linux system utility.
+
+- The cron format used by [the Quartz Scheduler], commonly used for scheduled
+  jobs in Java software
+
+[the Cron wikipedia page]: https://en.wikipedia.org/wiki/Cron
+[the Quartz Scheduler]: http://www.quartz-scheduler.org/documentation/quartz-2.3.0/tutorials/tutorial-lesson-06.html
+
+The original version of this package included an optional "seconds" field, which
+made it incompatible with both of these formats. Now, the "standard" format is
+the default format accepted, and the Quartz format is opt-in.

vendor/github.com/robfig/cron/v3/chain.go

@@ -0,0 +1,92 @@
+package cron
+
+import (
+	"fmt"
+	"runtime"
+	"sync"
+	"time"
+)
+
+// JobWrapper decorates the given Job with some behavior.
+type JobWrapper func(Job) Job
+
+// Chain is a sequence of JobWrappers that decorates submitted jobs with
+// cross-cutting behaviors like logging or synchronization.
+type Chain struct {
+	wrappers []JobWrapper
+}
+
+// NewChain returns a Chain consisting of the given JobWrappers.
+func NewChain(c ...JobWrapper) Chain {
+	return Chain{c}
+}
+
+// Then decorates the given job with all JobWrappers in the chain.
+//
+// This:
+//     NewChain(m1, m2, m3).Then(job)
+// is equivalent to:
+//     m1(m2(m3(job)))
+func (c Chain) Then(j Job) Job {
+	for i := range c.wrappers {
+		j = c.wrappers[len(c.wrappers)-i-1](j)
+	}
+	return j
+}
+
+// Recover panics in wrapped jobs and log them with the provided logger.
+func Recover(logger Logger) JobWrapper {
+	return func(j Job) Job {
+		return FuncJob(func() {
+			defer func() {
+				if r := recover(); r != nil {
+					const size = 64 << 10
+					buf := make([]byte, size)
+					buf = buf[:runtime.Stack(buf, false)]
+					err, ok := r.(error)
+					if !ok {
+						err = fmt.Errorf("%v", r)
+					}
+					logger.Error(err, "panic", "stack", "...\n"+string(buf))
+				}
+			}()
+			j.Run()
+		})
+	}
+}
+
+// DelayIfStillRunning serializes jobs, delaying subsequent runs until the
+// previous one is complete. Jobs running after a delay of more than a minute
+// have the delay logged at Info.
+func DelayIfStillRunning(logger Logger) JobWrapper {
+	return func(j Job) Job {
+		var mu sync.Mutex
+		return FuncJob(func() {
+			start := time.Now()
+			mu.Lock()
+			defer mu.Unlock()
+			if dur := time.Since(start); dur > time.Minute {
+				logger.Info("delay", "duration", dur)
+			}
+			j.Run()
+		})
+	}
+}
+
+// SkipIfStillRunning skips an invocation of the Job if a previous invocation is
+// still running. It logs skips to the given logger at Info level.
+func SkipIfStillRunning(logger Logger) JobWrapper {
+	return func(j Job) Job {
+		var ch = make(chan struct{}, 1)
+		ch <- struct{}{}
+		return FuncJob(func() {
+			select {
+			case v := <-ch:
+				j.Run()
+				ch <- v
+			default:
+				logger.Info("skip")
+			}
+		})
+	}
+}

vendor/github.com/robfig/cron/v3/constantdelay.go

@@ -0,0 +1,27 @@
+package cron
+
+import "time"
+
+// ConstantDelaySchedule represents a simple recurring duty cycle, e.g. "Every 5 minutes".
+// It does not support jobs more frequent than once a second.
+type ConstantDelaySchedule struct {
+	Delay time.Duration
+}
+
+// Every returns a crontab Schedule that activates once every duration.
+// Delays of less than a second are not supported (will round up to 1 second).
+// Any fields less than a Second are truncated.
+func Every(duration time.Duration) ConstantDelaySchedule {
+	if duration < time.Second {
+		duration = time.Second
+	}
+	return ConstantDelaySchedule{
+		Delay: duration - time.Duration(duration.Nanoseconds())%time.Second,
+	}
+}
+
+// Next returns the next time this should be run.
+// This rounds so that the next activation time will be on the second.
+func (schedule ConstantDelaySchedule) Next(t time.Time) time.Time {
+	return t.Add(schedule.Delay - time.Duration(t.Nanosecond())*time.Nanosecond)
+}

vendor/github.com/robfig/cron/v3/cron.go

@@ -0,0 +1,355 @@
+package cron
+
+import (
+	"context"
+	"sort"
+	"sync"
+	"time"
+)
+
+// Cron keeps track of any number of entries, invoking the associated func as
+// specified by the schedule. It may be started, stopped, and the entries may
+// be inspected while running.
+type Cron struct {
+	entries   []*Entry
+	chain     Chain
+	stop      chan struct{}
+	add       chan *Entry
+	remove    chan EntryID
+	snapshot  chan chan []Entry
+	running   bool
+	logger    Logger
+	runningMu sync.Mutex
+	location  *time.Location
+	parser    ScheduleParser
+	nextID    EntryID
+	jobWaiter sync.WaitGroup
+}
+
+// ScheduleParser is an interface for schedule spec parsers that return a Schedule
+type ScheduleParser interface {
+	Parse(spec string) (Schedule, error)
+}
+
+// Job is an interface for submitted cron jobs.
+type Job interface {
+	Run()
+}
+
+// Schedule describes a job's duty cycle.
+type Schedule interface {
+	// Next returns the next activation time, later than the given time.
+	// Next is invoked initially, and then each time the job is run.
+	Next(time.Time) time.Time
+}
+
+// EntryID identifies an entry within a Cron instance
+type EntryID int
+
+// Entry consists of a schedule and the func to execute on that schedule.
+type Entry struct {
+	// ID is the cron-assigned ID of this entry, which may be used to look up a
+	// snapshot or remove it.
+	ID EntryID
+
+	// Schedule on which this job should be run.
+	Schedule Schedule
+
+	// Next time the job will run, or the zero time if Cron has not been
+	// started or this entry's schedule is unsatisfiable
+	Next time.Time
+
+	// Prev is the last time this job was run, or the zero time if never.
+	Prev time.Time
+
+	// WrappedJob is the thing to run when the Schedule is activated.
+	WrappedJob Job
+
+	// Job is the thing that was submitted to cron.
+	// It is kept around so that user code that needs to get at the job later,
+	// e.g. via Entries() can do so.
+	Job Job
+}
+
+// Valid returns true if this is not the zero entry.
+func (e Entry) Valid() bool { return e.ID != 0 }
+
+// byTime is a wrapper for sorting the entry array by time
+// (with zero time at the end).
+type byTime []*Entry
+
+func (s byTime) Len() int      { return len(s) }
+func (s byTime) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
+func (s byTime) Less(i, j int) bool {
+	// Two zero times should return false.
+	// Otherwise, zero is "greater" than any other time.
+	// (To sort it at the end of the list.)
+	if s[i].Next.IsZero() {
+		return false
+	}
+	if s[j].Next.IsZero() {
+		return true
+	}
+	return s[i].Next.Before(s[j].Next)
+}
+
+// New returns a new Cron job runner, modified by the given options.
+//
+// Available Settings
+//
+//   Time Zone
+//     Description: The time zone in which schedules are interpreted
+//     Default:     time.Local
+//
+//   Parser
+//     Description: Parser converts cron spec strings into cron.Schedules.
+//     Default:     Accepts this spec: https://en.wikipedia.org/wiki/Cron
+//
+//   Chain
+//     Description: Wrap submitted jobs to customize behavior.
+//     Default:     A chain that recovers panics and logs them to stderr.
+//
+// See "cron.With*" to modify the default behavior.
+func New(opts ...Option) *Cron {
+	c := &Cron{
+		entries:   nil,
+		chain:     NewChain(),
+		add:       make(chan *Entry),
+		stop:      make(chan struct{}),
+		snapshot:  make(chan chan []Entry),
+		remove:    make(chan EntryID),
+		running:   false,
+		runningMu: sync.Mutex{},
+		logger:    DefaultLogger,
+		location:  time.Local,
+		parser:    standardParser,
+	}
+	for _, opt := range opts {
+		opt(c)
+	}
+	return c
+}
+
+// FuncJob is a wrapper that turns a func() into a cron.Job
+type FuncJob func()
+
+func (f FuncJob) Run() { f() }
+
+// AddFunc adds a func to the Cron to be run on the given schedule.
+// The spec is parsed using the time zone of this Cron instance as the default.
+// An opaque ID is returned that can be used to later remove it.
+func (c *Cron) AddFunc(spec string, cmd func()) (EntryID, error) {
+	return c.AddJob(spec, FuncJob(cmd))
+}
+
+// AddJob adds a Job to the Cron to be run on the given schedule.
+// The spec is parsed using the time zone of this Cron instance as the default.
+// An opaque ID is returned that can be used to later remove it.
+func (c *Cron) AddJob(spec string, cmd Job) (EntryID, error) {
+	schedule, err := c.parser.Parse(spec)
+	if err != nil {
+		return 0, err
+	}
+	return c.Schedule(schedule, cmd), nil
+}
+
+// Schedule adds a Job to the Cron to be run on the given schedule.
+// The job is wrapped with the configured Chain.
+func (c *Cron) Schedule(schedule Schedule, cmd Job) EntryID {
+	c.runningMu.Lock()
+	defer c.runningMu.Unlock()
+	c.nextID++
+	entry := &Entry{
+		ID:         c.nextID,
+		Schedule:   schedule,
+		WrappedJob: c.chain.Then(cmd),
+		Job:        cmd,
+	}
+	if !c.running {
+		c.entries = append(c.entries, entry)
+	} else {
+		c.add <- entry
+	}
+	return entry.ID
+}
+
+// Entries returns a snapshot of the cron entries.
+func (c *Cron) Entries() []Entry {
+	c.runningMu.Lock()
+	defer c.runningMu.Unlock()
+	if c.running {
+		replyChan := make(chan []Entry, 1)
+		c.snapshot <- replyChan
+		return <-replyChan
+	}
+	return c.entrySnapshot()
+}
+
+// Location gets the time zone location
+func (c *Cron) Location() *time.Location {
+	return c.location
+}
+
+// Entry returns a snapshot of the given entry, or nil if it couldn't be found.
+func (c *Cron) Entry(id EntryID) Entry {
+	for _, entry := range c.Entries() {
+		if id == entry.ID {
+			return entry
+		}
+	}
+	return Entry{}
+}
+
+// Remove an entry from being run in the future.
+func (c *Cron) Remove(id EntryID) {
+	c.runningMu.Lock()
+	defer c.runningMu.Unlock()
+	if c.running {
+		c.remove <- id
+	} else {
+		c.removeEntry(id)
+	}
+}
+
+// Start the cron scheduler in its own goroutine, or no-op if already started.
+func (c *Cron) Start() {
+	c.runningMu.Lock()
+	defer c.runningMu.Unlock()
+	if c.running {
+		return
+	}
+	c.running = true
+	go c.run()
+}
+
+// Run the cron scheduler, or no-op if already running.
+func (c *Cron) Run() {
+	c.runningMu.Lock()
+	if c.running {
+		c.runningMu.Unlock()
+		return
+	}
+	c.running = true
+	c.runningMu.Unlock()
+	c.run()
+}
+
+// run the scheduler.. this is private just due to the need to synchronize
+// access to the 'running' state variable.
+func (c *Cron) run() {
+	c.logger.Info("start")
+
+	// Figure out the next activation times for each entry.
+	now := c.now()
+	for _, entry := range c.entries {
+		entry.Next = entry.Schedule.Next(now)
+		c.logger.Info("schedule", "now", now, "entry", entry.ID, "next", entry.Next)
+	}
+
+	for {
+		// Determine the next entry to run.
+		sort.Sort(byTime(c.entries))
+
+		var timer *time.Timer
+		if len(c.entries) == 0 || c.entries[0].Next.IsZero() {
+			// If there are no entries yet, just sleep - it still handles new entries
+			// and stop requests.
+			timer = time.NewTimer(100000 * time.Hour)
+		} else {
+			timer = time.NewTimer(c.entries[0].Next.Sub(now))
+		}
+
+		for {
+			select {
+			case now = <-timer.C:
+				now = now.In(c.location)
+				c.logger.Info("wake", "now", now)
+
+				// Run every entry whose next time was less than now
+				for _, e := range c.entries {
+					if e.Next.After(now) || e.Next.IsZero() {
+						break
+					}
+					c.startJob(e.WrappedJob)
+					e.Prev = e.Next
+					e.Next = e.Schedule.Next(now)
+					c.logger.Info("run", "now", now, "entry", e.ID, "next", e.Next)
+				}
+
+			case newEntry := <-c.add:
+				timer.Stop()
+				now = c.now()
+				newEntry.Next = newEntry.Schedule.Next(now)
+				c.entries = append(c.entries, newEntry)
+				c.logger.Info("added", "now", now, "entry", newEntry.ID, "next", newEntry.Next)
+
+			case replyChan := <-c.snapshot:
+				replyChan <- c.entrySnapshot()
+				continue
+
+			case <-c.stop:
+				timer.Stop()
+				c.logger.Info("stop")
+				return
+
+			case id := <-c.remove:
+				timer.Stop()
+				now = c.now()
+				c.removeEntry(id)
+				c.logger.Info("removed", "entry", id)
+			}
+
+			break
+		}
+	}
+}
+
+// startJob runs the given job in a new goroutine.
+func (c *Cron) startJob(j Job) {
+	c.jobWaiter.Add(1)
+	go func() {
+		defer c.jobWaiter.Done()
+		j.Run()
+	}()
+}
+
+// now returns current time in c location
+func (c *Cron) now() time.Time {
+	return time.Now().In(c.location)
+}
+
+// Stop stops the cron scheduler if it is running; otherwise it does nothing.
+// A context is returned so the caller can wait for running jobs to complete.
+func (c *Cron) Stop() context.Context {
+	c.runningMu.Lock()
+	defer c.runningMu.Unlock()
+	if c.running {
+		c.stop <- struct{}{}
+		c.running = false
+	}
+	ctx, cancel := context.WithCancel(context.Background())
+	go func() {
+		c.jobWaiter.Wait()
+		cancel()
+	}()
+	return ctx
+}
+
+// entrySnapshot returns a copy of the current cron entry list.
+func (c *Cron) entrySnapshot() []Entry {
+	var entries = make([]Entry, len(c.entries))
+	for i, e := range c.entries {
+		entries[i] = *e
+	}
+	return entries
+}
+
+func (c *Cron) removeEntry(id EntryID) {
+	var entries []*Entry
+	for _, e := range c.entries {
+		if e.ID != id {
+			entries = append(entries, e)
+		}
+	}
+	c.entries = entries
+}

vendor/github.com/robfig/cron/v3/doc.go

@@ -0,0 +1,231 @@
+/*
+Package cron implements a cron spec parser and job runner.
+
+Installation
+
+To download the specific tagged release, run:
+
+	go get github.com/robfig/cron/v3@v3.0.0
+
+Import it in your program as:
+
+	import "github.com/robfig/cron/v3"
+
+It requires Go 1.11 or later due to usage of Go Modules.
+
+Usage
+
+Callers may register Funcs to be invoked on a given schedule.  Cron will run
+them in their own goroutines.
+
+	c := cron.New()
+	c.AddFunc("30 * * * *", func() { fmt.Println("Every hour on the half hour") })
+	c.AddFunc("30 3-6,20-23 * * *", func() { fmt.Println(".. in the range 3-6am, 8-11pm") })
+	c.AddFunc("CRON_TZ=Asia/Tokyo 30 04 * * *", func() { fmt.Println("Runs at 04:30 Tokyo time every day") })
+	c.AddFunc("@hourly",      func() { fmt.Println("Every hour, starting an hour from now") })
+	c.AddFunc("@every 1h30m", func() { fmt.Println("Every hour thirty, starting an hour thirty from now") })
+	c.Start()
+	..
+	// Funcs are invoked in their own goroutine, asynchronously.
+	...
+	// Funcs may also be added to a running Cron
+	c.AddFunc("@daily", func() { fmt.Println("Every day") })
+	..
+	// Inspect the cron job entries' next and previous run times.
+	inspect(c.Entries())
+	..
+	c.Stop()  // Stop the scheduler (does not stop any jobs already running).
+
+CRON Expression Format
+
+A cron expression represents a set of times, using 5 space-separated fields.
+
+	Field name   | Mandatory? | Allowed values  | Allowed special characters
+	----------   | ---------- | --------------  | --------------------------
+	Minutes      | Yes        | 0-59            | * / , -
+	Hours        | Yes        | 0-23            | * / , -
+	Day of month | Yes        | 1-31            | * / , - ?
+	Month        | Yes        | 1-12 or JAN-DEC | * / , -
+	Day of week  | Yes        | 0-6 or SUN-SAT  | * / , - ?
+
+Month and Day-of-week field values are case insensitive.  "SUN", "Sun", and
+"sun" are equally accepted.
+
+The specific interpretation of the format is based on the Cron Wikipedia page:
+https://en.wikipedia.org/wiki/Cron
+
+Alternative Formats
+
+Alternative Cron expression formats support other fields like seconds. You can
+implement that by creating a custom Parser as follows.
+
+	cron.New(
+		cron.WithParser(
+			cron.NewParser(
+				cron.SecondOptional | cron.Minute | cron.Hour | cron.Dom | cron.Month | cron.Dow | cron.Descriptor)))
+
+Since adding Seconds is the most common modification to the standard cron spec,
+cron provides a builtin function to do that, which is equivalent to the custom
+parser you saw earlier, except that its seconds field is REQUIRED:
+
+	cron.New(cron.WithSeconds())
+
+That emulates Quartz, the most popular alternative Cron schedule format:
+http://www.quartz-scheduler.org/documentation/quartz-2.x/tutorials/crontrigger.html
+
+Special Characters
+
+Asterisk ( * )
+
+The asterisk indicates that the cron expression will match for all values of the
+field; e.g., using an asterisk in the 5th field (month) would indicate every
+month.
+
+Slash ( / )
+
+Slashes are used to describe increments of ranges. For example 3-59/15 in the
+1st field (minutes) would indicate the 3rd minute of the hour and every 15
+minutes thereafter. The form "*\/..." is equivalent to the form "first-last/...",
+that is, an increment over the largest possible range of the field.  The form
+"N/..." is accepted as meaning "N-MAX/...", that is, starting at N, use the
+increment until the end of that specific range.  It does not wrap around.
+
+Comma ( , )
+
+Commas are used to separate items of a list. For example, using "MON,WED,FRI" in
+the 5th field (day of week) would mean Mondays, Wednesdays and Fridays.
+
+Hyphen ( - )
+
+Hyphens are used to define ranges. For example, 9-17 would indicate every
+hour between 9am and 5pm inclusive.
+
+Question mark ( ? )
+
+Question mark may be used instead of '*' for leaving either day-of-month or
+day-of-week blank.
+
+Predefined schedules
+
+You may use one of several pre-defined schedules in place of a cron expression.
+
+	Entry                  | Description                                | Equivalent To
+	-----                  | -----------                                | -------------
+	@yearly (or @annually) | Run once a year, midnight, Jan. 1st        | 0 0 1 1 *
+	@monthly               | Run once a month, midnight, first of month | 0 0 1 * *
+	@weekly                | Run once a week, midnight between Sat/Sun  | 0 0 * * 0
+	@daily (or @midnight)  | Run once a day, midnight                   | 0 0 * * *
+	@hourly                | Run once an hour, beginning of hour        | 0 * * * *
+
+Intervals
+
+You may also schedule a job to execute at fixed intervals, starting at the time it's added
+or cron is run. This is supported by formatting the cron spec like this:
+
+    @every <duration>
+
+where "duration" is a string accepted by time.ParseDuration
+(http://golang.org/pkg/time/#ParseDuration).
+
+For example, "@every 1h30m10s" would indicate a schedule that activates after
+1 hour, 30 minutes, 10 seconds, and then every interval after that.
+
+Note: The interval does not take the job runtime into account.  For example,
+if a job takes 3 minutes to run, and it is scheduled to run every 5 minutes,
+it will have only 2 minutes of idle time between each run.
+
+Time zones
+
+By default, all interpretation and scheduling is done in the machine's local
+time zone (time.Local). You can specify a different time zone on construction:
+
+      cron.New(
+          cron.WithLocation(time.UTC))
+
+Individual cron schedules may also override the time zone they are to be
+interpreted in by providing an additional space-separated field at the beginning
+of the cron spec, of the form "CRON_TZ=Asia/Tokyo".
+
+For example:
+
+	# Runs at 6am in time.Local
+	cron.New().AddFunc("0 6 * * ?", ...)
+
+	# Runs at 6am in America/New_York
+	nyc, _ := time.LoadLocation("America/New_York")
+	c := cron.New(cron.WithLocation(nyc))
+	c.AddFunc("0 6 * * ?", ...)
+
+	# Runs at 6am in Asia/Tokyo
+	cron.New().AddFunc("CRON_TZ=Asia/Tokyo 0 6 * * ?", ...)
+
+	# Runs at 6am in Asia/Tokyo
+	c := cron.New(cron.WithLocation(nyc))
+	c.SetLocation("America/New_York")
+	c.AddFunc("CRON_TZ=Asia/Tokyo 0 6 * * ?", ...)
+
+The prefix "TZ=(TIME ZONE)" is also supported for legacy compatibility.
+
+Be aware that jobs scheduled during daylight-savings leap-ahead transitions will
+not be run!
+
+Job Wrappers
+
+A Cron runner may be configured with a chain of job wrappers to add
+cross-cutting functionality to all submitted jobs. For example, they may be used
+to achieve the following effects:
+
+  - Recover any panics from jobs (activated by default)
+  - Delay a job's execution if the previous run hasn't completed yet
+  - Skip a job's execution if the previous run hasn't completed yet
+  - Log each job's invocations
+
+Install wrappers for all jobs added to a cron using the `cron.WithChain` option:
+
+	cron.New(cron.WithChain(
+		cron.SkipIfStillRunning(logger),
+	))
+
+Install wrappers for individual jobs by explicitly wrapping them:
+
+	job = cron.NewChain(
+		cron.SkipIfStillRunning(logger),
+	).Then(job)
+
+Thread safety
+
+Since the Cron service runs concurrently with the calling code, some amount of
+care must be taken to ensure proper synchronization.
+
+All cron methods are designed to be correctly synchronized as long as the caller
+ensures that invocations have a clear happens-before ordering between them.
+
+Logging
+
+Cron defines a Logger interface that is a subset of the one defined in
+github.com/go-logr/logr. It has two logging levels (Info and Error), and
+parameters are key/value pairs. This makes it possible for cron logging to plug
+into structured logging systems. An adapter, [Verbose]PrintfLogger, is provided
+to wrap the standard library *log.Logger.
+
+For additional insight into Cron operations, verbose logging may be activated
+which will record job runs, scheduling decisions, and added or removed jobs.
+Activate it with a one-off logger as follows:
+
+	cron.New(
+		cron.WithLogger(
+			cron.VerbosePrintfLogger(log.New(os.Stdout, "cron: ", log.LstdFlags))))
+
+
+Implementation
+
+Cron entries are stored in an array, sorted by their next activation time.  Cron
+sleeps until the next job is due to be run.
+
+Upon waking:
+ - it runs each entry that is active on that second
+ - it calculates the next run times for the jobs that were run
+ - it re-sorts the array of entries by next activation time.
+ - it goes to sleep until the soonest job.
+*/
+package cron

vendor/github.com/robfig/cron/v3/logger.go

@@ -0,0 +1,86 @@
+package cron
+
+import (
+	"io/ioutil"
+	"log"
+	"os"
+	"strings"
+	"time"
+)
+
+// DefaultLogger is used by Cron if none is specified.
+var DefaultLogger Logger = PrintfLogger(log.New(os.Stdout, "cron: ", log.LstdFlags))
+
+// DiscardLogger can be used by callers to discard all log messages.
+var DiscardLogger Logger = PrintfLogger(log.New(ioutil.Discard, "", 0))
+
+// Logger is the interface used in this package for logging, so that any backend
+// can be plugged in. It is a subset of the github.com/go-logr/logr interface.
+type Logger interface {
+	// Info logs routine messages about cron's operation.
+	Info(msg string, keysAndValues ...interface{})
+	// Error logs an error condition.
+	Error(err error, msg string, keysAndValues ...interface{})
+}
+
+// PrintfLogger wraps a Printf-based logger (such as the standard library "log")
+// into an implementation of the Logger interface which logs errors only.
+func PrintfLogger(l interface{ Printf(string, ...interface{}) }) Logger {
+	return printfLogger{l, false}
+}
+
+// VerbosePrintfLogger wraps a Printf-based logger (such as the standard library
+// "log") into an implementation of the Logger interface which logs everything.
+func VerbosePrintfLogger(l interface{ Printf(string, ...interface{}) }) Logger {
+	return printfLogger{l, true}
+}
+
+type printfLogger struct {
+	logger  interface{ Printf(string, ...interface{}) }
+	logInfo bool
+}
+
+func (pl printfLogger) Info(msg string, keysAndValues ...interface{}) {
+	if pl.logInfo {
+		keysAndValues = formatTimes(keysAndValues)
+		pl.logger.Printf(
+			formatString(len(keysAndValues)),
+			append([]interface{}{msg}, keysAndValues...)...)
+	}
+}
+
+func (pl printfLogger) Error(err error, msg string, keysAndValues ...interface{}) {
+	keysAndValues = formatTimes(keysAndValues)
+	pl.logger.Printf(
+		formatString(len(keysAndValues)+2),
+		append([]interface{}{msg, "error", err}, keysAndValues...)...)
+}
+
+// formatString returns a logfmt-like format string for the number of
+// key/values.
+func formatString(numKeysAndValues int) string {
+	var sb strings.Builder
+	sb.WriteString("%s")
+	if numKeysAndValues > 0 {
+		sb.WriteString(", ")
+	}
+	for i := 0; i < numKeysAndValues/2; i++ {
+		if i > 0 {
+			sb.WriteString(", ")
+		}
+		sb.WriteString("%v=%v")
+	}
+	return sb.String()
+}
+
+// formatTimes formats any time.Time values as RFC3339.
+func formatTimes(keysAndValues []interface{}) []interface{} {
+	var formattedArgs []interface{}
+	for _, arg := range keysAndValues {
+		if t, ok := arg.(time.Time); ok {
+			arg = t.Format(time.RFC3339)
+		}
+		formattedArgs = append(formattedArgs, arg)
+	}
+	return formattedArgs
+}

vendor/github.com/robfig/cron/v3/option.go

@@ -0,0 +1,45 @@
+package cron
+
+import (
+	"time"
+)
+
+// Option represents a modification to the default behavior of a Cron.
+type Option func(*Cron)
+
+// WithLocation overrides the timezone of the cron instance.
+func WithLocation(loc *time.Location) Option {
+	return func(c *Cron) {
+		c.location = loc
+	}
+}
+
+// WithSeconds overrides the parser used for interpreting job schedules to
+// include a seconds field as the first one.
+func WithSeconds() Option {
+	return WithParser(NewParser(
+		Second | Minute | Hour | Dom | Month | Dow | Descriptor,
+	))
+}
+
+// WithParser overrides the parser used for interpreting job schedules.
+func WithParser(p ScheduleParser) Option {
+	return func(c *Cron) {
+		c.parser = p
+	}
+}
+
+// WithChain specifies Job wrappers to apply to all jobs added to this cron.
+// Refer to the Chain* functions in this package for provided wrappers.
+func WithChain(wrappers ...JobWrapper) Option {
+	return func(c *Cron) {
+		c.chain = NewChain(wrappers...)
+	}
+}
+
+// WithLogger uses the provided logger.
+func WithLogger(logger Logger) Option {
+	return func(c *Cron) {
+		c.logger = logger
+	}
+}

vendor/github.com/robfig/cron/v3/parser.go

@@ -0,0 +1,434 @@
+package cron
+
+import (
+	"fmt"
+	"math"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// Configuration options for creating a parser. Most options specify which
+// fields should be included, while others enable features. If a field is not
+// included the parser will assume a default value. These options do not change
+// the order fields are parse in.
+type ParseOption int
+
+const (
+	Second         ParseOption = 1 << iota // Seconds field, default 0
+	SecondOptional                         // Optional seconds field, default 0
+	Minute                                 // Minutes field, default 0
+	Hour                                   // Hours field, default 0
+	Dom                                    // Day of month field, default *
+	Month                                  // Month field, default *
+	Dow                                    // Day of week field, default *
+	DowOptional                            // Optional day of week field, default *
+	Descriptor                             // Allow descriptors such as @monthly, @weekly, etc.
+)
+
+var places = []ParseOption{
+	Second,
+	Minute,
+	Hour,
+	Dom,
+	Month,
+	Dow,
+}
+
+var defaults = []string{
+	"0",
+	"0",
+	"0",
+	"*",
+	"*",
+	"*",
+}
+
+// A custom Parser that can be configured.
+type Parser struct {
+	options ParseOption
+}
+
+// NewParser creates a Parser with custom options.
+//
+// It panics if more than one Optional is given, since it would be impossible to
+// correctly infer which optional is provided or missing in general.
+//
+// Examples
+//
+//  // Standard parser without descriptors
+//  specParser := NewParser(Minute | Hour | Dom | Month | Dow)
+//  sched, err := specParser.Parse("0 0 15 */3 *")
+//
+//  // Same as above, just excludes time fields
+//  subsParser := NewParser(Dom | Month | Dow)
+//  sched, err := specParser.Parse("15 */3 *")
+//
+//  // Same as above, just makes Dow optional
+//  subsParser := NewParser(Dom | Month | DowOptional)
+//  sched, err := specParser.Parse("15 */3")
+//
+func NewParser(options ParseOption) Parser {
+	optionals := 0
+	if options&DowOptional > 0 {
+		optionals++
+	}
+	if options&SecondOptional > 0 {
+		optionals++
+	}
+	if optionals > 1 {
+		panic("multiple optionals may not be configured")
+	}
+	return Parser{options}
+}
+
+// Parse returns a new crontab schedule representing the given spec.
+// It returns a descriptive error if the spec is not valid.
+// It accepts crontab specs and features configured by NewParser.
+func (p Parser) Parse(spec string) (Schedule, error) {
+	if len(spec) == 0 {
+		return nil, fmt.Errorf("empty spec string")
+	}
+
+	// Extract timezone if present
+	var loc = time.Local
+	if strings.HasPrefix(spec, "TZ=") || strings.HasPrefix(spec, "CRON_TZ=") {
+		var err error
+		i := strings.Index(spec, " ")
+		eq := strings.Index(spec, "=")
+		if loc, err = time.LoadLocation(spec[eq+1 : i]); err != nil {
+			return nil, fmt.Errorf("provided bad location %s: %v", spec[eq+1:i], err)
+		}
+		spec = strings.TrimSpace(spec[i:])
+	}
+
+	// Handle named schedules (descriptors), if configured
+	if strings.HasPrefix(spec, "@") {
+		if p.options&Descriptor == 0 {
+			return nil, fmt.Errorf("parser does not accept descriptors: %v", spec)
+		}
+		return parseDescriptor(spec, loc)
+	}
+
+	// Split on whitespace.
+	fields := strings.Fields(spec)
+
+	// Validate & fill in any omitted or optional fields
+	var err error
+	fields, err = normalizeFields(fields, p.options)
+	if err != nil {
+		return nil, err
+	}
+
+	field := func(field string, r bounds) uint64 {
+		if err != nil {
+			return 0
+		}
+		var bits uint64
+		bits, err = getField(field, r)
+		return bits
+	}
+
+	var (
+		second     = field(fields[0], seconds)
+		minute     = field(fields[1], minutes)
+		hour       = field(fields[2], hours)
+		dayofmonth = field(fields[3], dom)
+		month      = field(fields[4], months)
+		dayofweek  = field(fields[5], dow)
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	return &SpecSchedule{
+		Second:   second,
+		Minute:   minute,
+		Hour:     hour,
+		Dom:      dayofmonth,
+		Month:    month,
+		Dow:      dayofweek,
+		Location: loc,
+	}, nil
+}
+
+// normalizeFields takes a subset set of the time fields and returns the full set
+// with defaults (zeroes) populated for unset fields.
+//
+// As part of performing this function, it also validates that the provided
+// fields are compatible with the configured options.
+func normalizeFields(fields []string, options ParseOption) ([]string, error) {
+	// Validate optionals & add their field to options
+	optionals := 0
+	if options&SecondOptional > 0 {
+		options |= Second
+		optionals++
+	}
+	if options&DowOptional > 0 {
+		options |= Dow
+		optionals++
+	}
+	if optionals > 1 {
+		return nil, fmt.Errorf("multiple optionals may not be configured")
+	}
+
+	// Figure out how many fields we need
+	max := 0
+	for _, place := range places {
+		if options&place > 0 {
+			max++
+		}
+	}
+	min := max - optionals
+
+	// Validate number of fields
+	if count := len(fields); count < min || count > max {
+		if min == max {
+			return nil, fmt.Errorf("expected exactly %d fields, found %d: %s", min, count, fields)
+		}
+		return nil, fmt.Errorf("expected %d to %d fields, found %d: %s", min, max, count, fields)
+	}
+
+	// Populate the optional field if not provided
+	if min < max && len(fields) == min {
+		switch {
+		case options&DowOptional > 0:
+			fields = append(fields, defaults[5]) // TODO: improve access to default
+		case options&SecondOptional > 0:
+			fields = append([]string{defaults[0]}, fields...)
+		default:
+			return nil, fmt.Errorf("unknown optional field")
+		}
+	}
+
+	// Populate all fields not part of options with their defaults
+	n := 0
+	expandedFields := make([]string, len(places))
+	copy(expandedFields, defaults)
+	for i, place := range places {
+		if options&place > 0 {
+			expandedFields[i] = fields[n]
+			n++
+		}
+	}
+	return expandedFields, nil
+}
+
+var standardParser = NewParser(
+	Minute | Hour | Dom | Month | Dow | Descriptor,
+)
+
+// ParseStandard returns a new crontab schedule representing the given
+// standardSpec (https://en.wikipedia.org/wiki/Cron). It requires 5 entries
+// representing: minute, hour, day of month, month and day of week, in that
+// order. It returns a descriptive error if the spec is not valid.
+//
+// It accepts
+//   - Standard crontab specs, e.g. "* * * * ?"
+//   - Descriptors, e.g. "@midnight", "@every 1h30m"
+func ParseStandard(standardSpec string) (Schedule, error) {
+	return standardParser.Parse(standardSpec)
+}
+
+// getField returns an Int with the bits set representing all of the times that
+// the field represents or error parsing field value.  A "field" is a comma-separated
+// list of "ranges".
+func getField(field string, r bounds) (uint64, error) {
+	var bits uint64
+	ranges := strings.FieldsFunc(field, func(r rune) bool { return r == ',' })
+	for _, expr := range ranges {
+		bit, err := getRange(expr, r)
+		if err != nil {
+			return bits, err
+		}
+		bits |= bit
+	}
+	return bits, nil
+}
+
+// getRange returns the bits indicated by the given expression:
+//   number | number "-" number [ "/" number ]
+// or error parsing range.
+func getRange(expr string, r bounds) (uint64, error) {
+	var (
+		start, end, step uint
+		rangeAndStep     = strings.Split(expr, "/")
+		lowAndHigh       = strings.Split(rangeAndStep[0], "-")
+		singleDigit      = len(lowAndHigh) == 1
+		err              error
+	)
+
+	var extra uint64
+	if lowAndHigh[0] == "*" || lowAndHigh[0] == "?" {
+		start = r.min
+		end = r.max
+		extra = starBit
+	} else {
+		start, err = parseIntOrName(lowAndHigh[0], r.names)
+		if err != nil {
+			return 0, err
+		}
+		switch len(lowAndHigh) {
+		case 1:
+			end = start
+		case 2:
+			end, err = parseIntOrName(lowAndHigh[1], r.names)
+			if err != nil {
+				return 0, err
+			}
+		default:
+			return 0, fmt.Errorf("too many hyphens: %s", expr)
+		}
+	}
+
+	switch len(rangeAndStep) {
+	case 1:
+		step = 1
+	case 2:
+		step, err = mustParseInt(rangeAndStep[1])
+		if err != nil {
+			return 0, err
+		}
+
+		// Special handling: "N/step" means "N-max/step".
+		if singleDigit {
+			end = r.max
+		}
+		if step > 1 {
+			extra = 0
+		}
+	default:
+		return 0, fmt.Errorf("too many slashes: %s", expr)
+	}
+
+	if start < r.min {
+		return 0, fmt.Errorf("beginning of range (%d) below minimum (%d): %s", start, r.min, expr)
+	}
+	if end > r.max {
+		return 0, fmt.Errorf("end of range (%d) above maximum (%d): %s", end, r.max, expr)
+	}
+	if start > end {
+		return 0, fmt.Errorf("beginning of range (%d) beyond end of range (%d): %s", start, end, expr)
+	}
+	if step == 0 {
+		return 0, fmt.Errorf("step of range should be a positive number: %s", expr)
+	}
+
+	return getBits(start, end, step) | extra, nil
+}
+
+// parseIntOrName returns the (possibly-named) integer contained in expr.
+func parseIntOrName(expr string, names map[string]uint) (uint, error) {
+	if names != nil {
+		if namedInt, ok := names[strings.ToLower(expr)]; ok {
+			return namedInt, nil
+		}
+	}
+	return mustParseInt(expr)
+}
+
+// mustParseInt parses the given expression as an int or returns an error.
+func mustParseInt(expr string) (uint, error) {
+	num, err := strconv.Atoi(expr)
+	if err != nil {
+		return 0, fmt.Errorf("failed to parse int from %s: %s", expr, err)
+	}
+	if num < 0 {
+		return 0, fmt.Errorf("negative number (%d) not allowed: %s", num, expr)
+	}
+
+	return uint(num), nil
+}
+
+// getBits sets all bits in the range [min, max], modulo the given step size.
+func getBits(min, max, step uint) uint64 {
+	var bits uint64
+
+	// If step is 1, use shifts.
+	if step == 1 {
+		return ^(math.MaxUint64 << (max + 1)) & (math.MaxUint64 << min)
+	}
+
+	// Else, use a simple loop.
+	for i := min; i <= max; i += step {
+		bits |= 1 << i
+	}
+	return bits
+}
+
+// all returns all bits within the given bounds.  (plus the star bit)
+func all(r bounds) uint64 {
+	return getBits(r.min, r.max, 1) | starBit
+}
+
+// parseDescriptor returns a predefined schedule for the expression, or error if none matches.
+func parseDescriptor(descriptor string, loc *time.Location) (Schedule, error) {
+	switch descriptor {
+	case "@yearly", "@annually":
+		return &SpecSchedule{
+			Second:   1 << seconds.min,
+			Minute:   1 << minutes.min,
+			Hour:     1 << hours.min,
+			Dom:      1 << dom.min,
+			Month:    1 << months.min,
+			Dow:      all(dow),
+			Location: loc,
+		}, nil
+
+	case "@monthly":
+		return &SpecSchedule{
+			Second:   1 << seconds.min,
+			Minute:   1 << minutes.min,
+			Hour:     1 << hours.min,
+			Dom:      1 << dom.min,
+			Month:    all(months),
+			Dow:      all(dow),
+			Location: loc,
+		}, nil
+
+	case "@weekly":
+		return &SpecSchedule{
+			Second:   1 << seconds.min,
+			Minute:   1 << minutes.min,
+			Hour:     1 << hours.min,
+			Dom:      all(dom),
+			Month:    all(months),
+			Dow:      1 << dow.min,
+			Location: loc,
+		}, nil
+
+	case "@daily", "@midnight":
+		return &SpecSchedule{
+			Second:   1 << seconds.min,
+			Minute:   1 << minutes.min,
+			Hour:     1 << hours.min,
+			Dom:      all(dom),
+			Month:    all(months),
+			Dow:      all(dow),
+			Location: loc,
+		}, nil
+
+	case "@hourly":
+		return &SpecSchedule{
+			Second:   1 << seconds.min,
+			Minute:   1 << minutes.min,
+			Hour:     all(hours),
+			Dom:      all(dom),
+			Month:    all(months),
+			Dow:      all(dow),
+			Location: loc,
+		}, nil
+
+	}
+
+	const every = "@every "
+	if strings.HasPrefix(descriptor, every) {
+		duration, err := time.ParseDuration(descriptor[len(every):])
+		if err != nil {
+			return nil, fmt.Errorf("failed to parse duration %s: %s", descriptor, err)
+		}
+		return Every(duration), nil
+	}
+
+	return nil, fmt.Errorf("unrecognized descriptor: %s", descriptor)
+}

vendor/github.com/robfig/cron/v3/spec.go

@@ -0,0 +1,188 @@
+package cron
+
+import "time"
+
+// SpecSchedule specifies a duty cycle (to the second granularity), based on a
+// traditional crontab specification. It is computed initially and stored as bit sets.
+type SpecSchedule struct {
+	Second, Minute, Hour, Dom, Month, Dow uint64
+
+	// Override location for this schedule.
+	Location *time.Location
+}
+
+// bounds provides a range of acceptable values (plus a map of name to value).
+type bounds struct {
+	min, max uint
+	names    map[string]uint
+}
+
+// The bounds for each field.
+var (
+	seconds = bounds{0, 59, nil}
+	minutes = bounds{0, 59, nil}
+	hours   = bounds{0, 23, nil}
+	dom     = bounds{1, 31, nil}
+	months  = bounds{1, 12, map[string]uint{
+		"jan": 1,
+		"feb": 2,
+		"mar": 3,
+		"apr": 4,
+		"may": 5,
+		"jun": 6,
+		"jul": 7,
+		"aug": 8,
+		"sep": 9,
+		"oct": 10,
+		"nov": 11,
+		"dec": 12,
+	}}
+	dow = bounds{0, 6, map[string]uint{
+		"sun": 0,
+		"mon": 1,
+		"tue": 2,
+		"wed": 3,
+		"thu": 4,
+		"fri": 5,
+		"sat": 6,
+	}}
+)
+
+const (
+	// Set the top bit if a star was included in the expression.
+	starBit = 1 << 63
+)
+
+// Next returns the next time this schedule is activated, greater than the given
+// time.  If no time can be found to satisfy the schedule, return the zero time.
+func (s *SpecSchedule) Next(t time.Time) time.Time {
+	// General approach
+	//
+	// For Month, Day, Hour, Minute, Second:
+	// Check if the time value matches.  If yes, continue to the next field.
+	// If the field doesn't match the schedule, then increment the field until it matches.
+	// While incrementing the field, a wrap-around brings it back to the beginning
+	// of the field list (since it is necessary to re-verify previous field
+	// values)
+
+	// Convert the given time into the schedule's timezone, if one is specified.
+	// Save the original timezone so we can convert back after we find a time.
+	// Note that schedules without a time zone specified (time.Local) are treated
+	// as local to the time provided.
+	origLocation := t.Location()
+	loc := s.Location
+	if loc == time.Local {
+		loc = t.Location()
+	}
+	if s.Location != time.Local {
+		t = t.In(s.Location)
+	}
+
+	// Start at the earliest possible time (the upcoming second).
+	t = t.Add(1*time.Second - time.Duration(t.Nanosecond())*time.Nanosecond)
+
+	// This flag indicates whether a field has been incremented.
+	added := false
+
+	// If no time is found within five years, return zero.
+	yearLimit := t.Year() + 5
+
+WRAP:
+	if t.Year() > yearLimit {
+		return time.Time{}
+	}
+
+	// Find the first applicable month.
+	// If it's this month, then do nothing.
+	for 1<<uint(t.Month())&s.Month == 0 {
+		// If we have to add a month, reset the other parts to 0.
+		if !added {
+			added = true
+			// Otherwise, set the date at the beginning (since the current time is irrelevant).
+			t = time.Date(t.Year(), t.Month(), 1, 0, 0, 0, 0, loc)
+		}
+		t = t.AddDate(0, 1, 0)
+
+		// Wrapped around.
+		if t.Month() == time.January {
+			goto WRAP
+		}
+	}
+
+	// Now get a day in that month.
+	//
+	// NOTE: This causes issues for daylight savings regimes where midnight does
+	// not exist.  For example: Sao Paulo has DST that transforms midnight on
+	// 11/3 into 1am. Handle that by noticing when the Hour ends up != 0.
+	for !dayMatches(s, t) {
+		if !added {
+			added = true
+			t = time.Date(t.Year(), t.Month(), t.Day(), 0, 0, 0, 0, loc)
+		}
+		t = t.AddDate(0, 0, 1)
+		// Notice if the hour is no longer midnight due to DST.
+		// Add an hour if it's 23, subtract an hour if it's 1.
+		if t.Hour() != 0 {
+			if t.Hour() > 12 {
+				t = t.Add(time.Duration(24-t.Hour()) * time.Hour)
+			} else {
+				t = t.Add(time.Duration(-t.Hour()) * time.Hour)
+			}
+		}
+
+		if t.Day() == 1 {
+			goto WRAP
+		}
+	}
+
+	for 1<<uint(t.Hour())&s.Hour == 0 {
+		if !added {
+			added = true
+			t = time.Date(t.Year(), t.Month(), t.Day(), t.Hour(), 0, 0, 0, loc)
+		}
+		t = t.Add(1 * time.Hour)
+
+		if t.Hour() == 0 {
+			goto WRAP
+		}
+	}
+
+	for 1<<uint(t.Minute())&s.Minute == 0 {
+		if !added {
+			added = true
+			t = t.Truncate(time.Minute)
+		}
+		t = t.Add(1 * time.Minute)
+
+		if t.Minute() == 0 {
+			goto WRAP
+		}
+	}
+
+	for 1<<uint(t.Second())&s.Second == 0 {
+		if !added {
+			added = true
+			t = t.Truncate(time.Second)
+		}
+		t = t.Add(1 * time.Second)
+
+		if t.Second() == 0 {
+			goto WRAP
+		}
+	}
+
+	return t.In(origLocation)
+}
+
+// dayMatches returns true if the schedule's day-of-week and day-of-month
+// restrictions are satisfied by the given time.
+func dayMatches(s *SpecSchedule, t time.Time) bool {
+	var (
+		domMatch bool = 1<<uint(t.Day())&s.Dom > 0
+		dowMatch bool = 1<<uint(t.Weekday())&s.Dow > 0
+	)
+	if s.Dom&starBit > 0 || s.Dow&starBit > 0 {
+		return domMatch && dowMatch
+	}
+	return domMatch || dowMatch
+}

vendor/github.com/uptrace/bun/CHANGELOG.md

@@ -1,3 +1,26 @@
+## [1.0.20](https://github.com/uptrace/bun/compare/v1.0.19...v1.0.20) (2021-12-19)
+
+
+### Bug Fixes
+
+* add Event.QueryTemplate and change Event.Query to be always formatted ([52b1ccd](https://github.com/uptrace/bun/commit/52b1ccdf3578418aa427adef9dcf942d90ae4fdd))
+* change GetTableName to return formatted table name in case ModelTableExpr ([95144dd](https://github.com/uptrace/bun/commit/95144dde937b4ac88b36b0bd8b01372421069b44))
+* change ScanAndCount to work with transactions ([5b3f2c0](https://github.com/uptrace/bun/commit/5b3f2c021c424da366caffd33589e8adde821403))
+* **dbfixture:** directly call funcs bypassing template eval ([a61974b](https://github.com/uptrace/bun/commit/a61974ba2d24361c5357fb9bda1f3eceec5a45cd))
+* don't append CASCADE by default in drop table/column queries ([26457ea](https://github.com/uptrace/bun/commit/26457ea5cb20862d232e6e5fa4dbdeac5d444bf1))
+* **migrate:** mark migrations as applied on error so the migration can be rolled back ([8ce33fb](https://github.com/uptrace/bun/commit/8ce33fbbac8e33077c20daf19a14c5ff2291bcae))
+* respect nullzero when appending struct fields. Fixes [#339](https://github.com/uptrace/bun/issues/339) ([ffd02f3](https://github.com/uptrace/bun/commit/ffd02f3170b3cccdd670a48d563cfb41094c05d6))
+* reuse tx for relation join ([#366](https://github.com/uptrace/bun/issues/366)) ([60bdb1a](https://github.com/uptrace/bun/commit/60bdb1ac84c0a699429eead3b7fdfbf14fe69ac6))
+
+
+### Features
+
+* add `Dialect()` to Transaction and IDB interface ([693f1e1](https://github.com/uptrace/bun/commit/693f1e135999fc31cf83b99a2530a695b20f4e1b))
+* add model embedding via embed:prefix_ ([9a2cedc](https://github.com/uptrace/bun/commit/9a2cedc8b08fa8585d4bfced338bd0a40d736b1d))
+* change the default logoutput to stderr ([4bf5773](https://github.com/uptrace/bun/commit/4bf577382f19c64457cbf0d64490401450954654)), closes [#349](https://github.com/uptrace/bun/issues/349)
+
+
+
 ## [1.0.19](https://github.com/uptrace/bun/compare/v1.0.18...v1.0.19) (2021-11-30)
 
 

vendor/github.com/uptrace/bun/README.md

@@ -43,8 +43,147 @@ Projects using Bun:
   demand.
 - [RealWorld app](https://github.com/go-bun/bun-realworld-app)
 
+## Benchmark
+[https://github.com/davars/dbeval](https://github.com/davars/dbeval)
 <details>
-  <summary>github.com/frederikhors/orm-benchmark results</summary>
+<summary>results</summary>
+
+```
+BenchmarkInsert
+BenchmarkInsert/*dbeval.Memory/Authors
+BenchmarkInsert/*dbeval.Memory/Authors-4         	   84450	     12104 ns/op	    2623 B/op	      70 allocs/op
+BenchmarkInsert/*dbeval.Xorm/Authors
+BenchmarkInsert/*dbeval.Xorm/Authors-4           	    7291	    153505 ns/op	    9024 B/op	     311 allocs/op
+BenchmarkInsert/*dbeval.UpperDB/Authors
+BenchmarkInsert/*dbeval.UpperDB/Authors-4        	    4608	    223672 ns/op	   24160 B/op	    1100 allocs/op
+BenchmarkInsert/*dbeval.Bun/Authors
+BenchmarkInsert/*dbeval.Bun/Authors-4            	    6034	    186439 ns/op	    6818 B/op	      80 allocs/op
+BenchmarkInsert/*dbeval.PQ/Authors
+BenchmarkInsert/*dbeval.PQ/Authors-4             	    1141	    907494 ns/op	    6487 B/op	     193 allocs/op
+BenchmarkInsert/*dbeval.SQLX/Authors
+BenchmarkInsert/*dbeval.SQLX/Authors-4           	    1165	    916987 ns/op	   10089 B/op	     271 allocs/op
+BenchmarkInsert/*dbeval.Ozzo/Authors
+BenchmarkInsert/*dbeval.Ozzo/Authors-4           	    1105	   1058082 ns/op	   27826 B/op	     588 allocs/op
+BenchmarkInsert/*dbeval.PGXStdlib/Authors
+BenchmarkInsert/*dbeval.PGXStdlib/Authors-4      	    1228	    900207 ns/op	    6032 B/op	     180 allocs/op
+BenchmarkInsert/*dbeval.Gorm/Authors
+BenchmarkInsert/*dbeval.Gorm/Authors-4           	     946	   1184285 ns/op	   35634 B/op	     918 allocs/op
+BenchmarkInsert/*dbeval.PGX/Authors
+BenchmarkInsert/*dbeval.PGX/Authors-4            	    1116	    923728 ns/op	    3839 B/op	     130 allocs/op
+BenchmarkInsert/*dbeval.DBR/Authors
+BenchmarkInsert/*dbeval.DBR/Authors-4            	    5800	    183982 ns/op	    8646 B/op	     230 allocs/op
+BenchmarkInsert/*dbeval.GoPG/Authors
+BenchmarkInsert/*dbeval.GoPG/Authors-4           	    6110	    173923 ns/op	    2906 B/op	      87 allocs/op
+
+BenchmarkInsert/*dbeval.DBR/Articles
+BenchmarkInsert/*dbeval.DBR/Articles-4           	    1706	    684466 ns/op	  133346 B/op	    1614 allocs/op
+BenchmarkInsert/*dbeval.PQ/Articles
+BenchmarkInsert/*dbeval.PQ/Articles-4            	     884	   1249791 ns/op	  100403 B/op	    1491 allocs/op
+BenchmarkInsert/*dbeval.PGX/Articles
+BenchmarkInsert/*dbeval.PGX/Articles-4           	     916	   1288143 ns/op	   83539 B/op	    1392 allocs/op
+BenchmarkInsert/*dbeval.GoPG/Articles
+BenchmarkInsert/*dbeval.GoPG/Articles-4          	    1726	    622639 ns/op	   78638 B/op	    1359 allocs/op
+BenchmarkInsert/*dbeval.SQLX/Articles
+BenchmarkInsert/*dbeval.SQLX/Articles-4          	     860	   1262599 ns/op	   92030 B/op	    1574 allocs/op
+BenchmarkInsert/*dbeval.Gorm/Articles
+BenchmarkInsert/*dbeval.Gorm/Articles-4          	     782	   1421550 ns/op	  136534 B/op	    2411 allocs/op
+BenchmarkInsert/*dbeval.PGXStdlib/Articles
+BenchmarkInsert/*dbeval.PGXStdlib/Articles-4     	     938	   1230576 ns/op	   86743 B/op	    1441 allocs/op
+BenchmarkInsert/*dbeval.Bun/Articles
+BenchmarkInsert/*dbeval.Bun/Articles-4           	    1843	    626681 ns/op	  101610 B/op	    1323 allocs/op
+BenchmarkInsert/*dbeval.Xorm/Articles
+BenchmarkInsert/*dbeval.Xorm/Articles-4          	    1677	    650244 ns/op	  126677 B/op	    1752 allocs/op
+BenchmarkInsert/*dbeval.Memory/Articles
+BenchmarkInsert/*dbeval.Memory/Articles-4        	    1988	   1223308 ns/op	   77576 B/op	    1310 allocs/op
+BenchmarkInsert/*dbeval.UpperDB/Articles
+BenchmarkInsert/*dbeval.UpperDB/Articles-4       	    1696	    687130 ns/op	  139680 B/op	    2862 allocs/op
+BenchmarkInsert/*dbeval.Ozzo/Articles
+BenchmarkInsert/*dbeval.Ozzo/Articles-4          	     697	   1496859 ns/op	  114780 B/op	    1950 allocs/op
+
+BenchmarkFindAuthorByID
+BenchmarkFindAuthorByID/*dbeval.UpperDB
+BenchmarkFindAuthorByID/*dbeval.UpperDB-4        	   10184	    117527 ns/op	    9953 B/op	     441 allocs/op
+BenchmarkFindAuthorByID/*dbeval.Bun
+BenchmarkFindAuthorByID/*dbeval.Bun-4            	   20716	     54261 ns/op	    5096 B/op	      15 allocs/op
+BenchmarkFindAuthorByID/*dbeval.Ozzo
+BenchmarkFindAuthorByID/*dbeval.Ozzo-4           	   11166	     91043 ns/op	    3088 B/op	      64 allocs/op
+BenchmarkFindAuthorByID/*dbeval.PQ
+BenchmarkFindAuthorByID/*dbeval.PQ-4             	   13875	     86171 ns/op	     844 B/op	      24 allocs/op
+BenchmarkFindAuthorByID/*dbeval.PGX
+BenchmarkFindAuthorByID/*dbeval.PGX-4            	   13846	     79983 ns/op	     719 B/op	      15 allocs/op
+BenchmarkFindAuthorByID/*dbeval.Memory
+BenchmarkFindAuthorByID/*dbeval.Memory-4         	14113720	        82.33 ns/op	       0 B/op	       0 allocs/op
+BenchmarkFindAuthorByID/*dbeval.Xorm
+BenchmarkFindAuthorByID/*dbeval.Xorm-4           	   12027	     98519 ns/op	    3633 B/op	     106 allocs/op
+BenchmarkFindAuthorByID/*dbeval.Gorm
+BenchmarkFindAuthorByID/*dbeval.Gorm-4           	   11521	    102241 ns/op	    6592 B/op	     143 allocs/op
+BenchmarkFindAuthorByID/*dbeval.PGXStdlib
+BenchmarkFindAuthorByID/*dbeval.PGXStdlib-4      	   13933	     82626 ns/op	    1174 B/op	      28 allocs/op
+BenchmarkFindAuthorByID/*dbeval.DBR
+BenchmarkFindAuthorByID/*dbeval.DBR-4            	   21920	     51175 ns/op	    1756 B/op	      39 allocs/op
+BenchmarkFindAuthorByID/*dbeval.SQLX
+BenchmarkFindAuthorByID/*dbeval.SQLX-4           	   13603	     80788 ns/op	    1327 B/op	      32 allocs/op
+BenchmarkFindAuthorByID/*dbeval.GoPG
+BenchmarkFindAuthorByID/*dbeval.GoPG-4           	   23174	     50042 ns/op	     869 B/op	      17 allocs/op
+
+BenchmarkFindAuthorByName
+BenchmarkFindAuthorByName/*dbeval.SQLX
+BenchmarkFindAuthorByName/*dbeval.SQLX-4         	    1070	   1065272 ns/op	  126348 B/op	    4018 allocs/op
+BenchmarkFindAuthorByName/*dbeval.Bun
+BenchmarkFindAuthorByName/*dbeval.Bun-4          	     877	   1231377 ns/op	  115803 B/op	    5005 allocs/op
+BenchmarkFindAuthorByName/*dbeval.Xorm
+BenchmarkFindAuthorByName/*dbeval.Xorm-4         	     471	   2345445 ns/op	  455711 B/op	   19080 allocs/op
+BenchmarkFindAuthorByName/*dbeval.DBR
+BenchmarkFindAuthorByName/*dbeval.DBR-4          	     954	   1089977 ns/op	  120070 B/op	    6023 allocs/op
+BenchmarkFindAuthorByName/*dbeval.PQ
+BenchmarkFindAuthorByName/*dbeval.PQ-4           	    1333	    784400 ns/op	   87159 B/op	    4006 allocs/op
+BenchmarkFindAuthorByName/*dbeval.GoPG
+BenchmarkFindAuthorByName/*dbeval.GoPG-4         	    1580	    770966 ns/op	   87525 B/op	    3028 allocs/op
+BenchmarkFindAuthorByName/*dbeval.UpperDB
+BenchmarkFindAuthorByName/*dbeval.UpperDB-4      	     789	   1314164 ns/op	  190689 B/op	    6428 allocs/op
+BenchmarkFindAuthorByName/*dbeval.Ozzo
+BenchmarkFindAuthorByName/*dbeval.Ozzo-4         	     948	   1255282 ns/op	  238764 B/op	    6053 allocs/op
+BenchmarkFindAuthorByName/*dbeval.PGXStdlib
+BenchmarkFindAuthorByName/*dbeval.PGXStdlib-4    	    1279	    920391 ns/op	  126163 B/op	    4014 allocs/op
+BenchmarkFindAuthorByName/*dbeval.PGX
+BenchmarkFindAuthorByName/*dbeval.PGX-4          	    1364	    780970 ns/op	  101967 B/op	    2028 allocs/op
+BenchmarkFindAuthorByName/*dbeval.Gorm
+BenchmarkFindAuthorByName/*dbeval.Gorm-4         	     340	   3445818 ns/op	 1573637 B/op	   27102 allocs/op
+BenchmarkFindAuthorByName/*dbeval.Memory
+BenchmarkFindAuthorByName/*dbeval.Memory-4       	38081223	        31.24 ns/op	       0 B/op	       0 allocs/op
+
+BenchmarkRecentArticles
+BenchmarkRecentArticles/*dbeval.PGXStdlib
+BenchmarkRecentArticles/*dbeval.PGXStdlib-4      	     358	   3344119 ns/op	 3425578 B/op	   14177 allocs/op
+BenchmarkRecentArticles/*dbeval.GoPG
+BenchmarkRecentArticles/*dbeval.GoPG-4           	     364	   3156372 ns/op	 1794091 B/op	   10032 allocs/op
+BenchmarkRecentArticles/*dbeval.Xorm
+BenchmarkRecentArticles/*dbeval.Xorm-4           	     157	   7567835 ns/op	 5018011 B/op	   81425 allocs/op
+BenchmarkRecentArticles/*dbeval.Gorm
+BenchmarkRecentArticles/*dbeval.Gorm-4           	     139	   7980084 ns/op	 6776277 B/op	   85418 allocs/op
+BenchmarkRecentArticles/*dbeval.SQLX
+BenchmarkRecentArticles/*dbeval.SQLX-4           	     338	   3289802 ns/op	 3425890 B/op	   14181 allocs/op
+BenchmarkRecentArticles/*dbeval.Ozzo
+BenchmarkRecentArticles/*dbeval.Ozzo-4           	     320	   3508322 ns/op	 4025966 B/op	   18207 allocs/op
+BenchmarkRecentArticles/*dbeval.DBR
+BenchmarkRecentArticles/*dbeval.DBR-4            	     237	   5248644 ns/op	 3331003 B/op	   21370 allocs/op
+BenchmarkRecentArticles/*dbeval.Bun
+BenchmarkRecentArticles/*dbeval.Bun-4            	     280	   4528582 ns/op	 1864362 B/op	   15965 allocs/op
+BenchmarkRecentArticles/*dbeval.UpperDB
+BenchmarkRecentArticles/*dbeval.UpperDB-4        	     297	   3704663 ns/op	 3607287 B/op	   18542 allocs/op
+BenchmarkRecentArticles/*dbeval.PQ
+BenchmarkRecentArticles/*dbeval.PQ-4             	     308	   3489229 ns/op	 3277050 B/op	   17359 allocs/op
+BenchmarkRecentArticles/*dbeval.Memory
+BenchmarkRecentArticles/*dbeval.Memory-4         	29590380	        42.27 ns/op	       0 B/op	       0 allocs/op
+BenchmarkRecentArticles/*dbeval.PGX
+BenchmarkRecentArticles/*dbeval.PGX-4            	     356	   3345500 ns/op	 3297316 B/op	    6226 allocs/op
+```
+
+</details>
+
+[https://github.com/frederikhors/orm-benchmark](https://github.com/frederikhors/orm-benchmark)
+<details>
+<summary>results</summary>
 
 ```
   4000 times - Insert

vendor/github.com/uptrace/bun/db.go

@@ -32,6 +32,7 @@ func WithDiscardUnknownColumns() DBOption {
 
 type DB struct {
 	*sql.DB
+
 	dialect  schema.Dialect
 	features feature.Feature
 
@@ -125,7 +126,7 @@ func (db *DB) NewDropColumn() *DropColumnQuery {
 
 func (db *DB) ResetModel(ctx context.Context, models ...interface{}) error {
 	for _, model := range models {
-		if _, err := db.NewDropTable().Model(model).IfExists().Exec(ctx); err != nil {
+		if _, err := db.NewDropTable().Model(model).IfExists().Cascade().Exec(ctx); err != nil {
 			return err
 		}
 		if _, err := db.NewCreateTable().Model(model).Exec(ctx); err != nil {
@@ -226,8 +227,9 @@ func (db *DB) Exec(query string, args ...interface{}) (sql.Result, error) {
 func (db *DB) ExecContext(
 	ctx context.Context, query string, args ...interface{},
 ) (sql.Result, error) {
-	ctx, event := db.beforeQuery(ctx, nil, query, args, nil)
-	res, err := db.DB.ExecContext(ctx, db.format(query, args))
+	formattedQuery := db.format(query, args)
+	ctx, event := db.beforeQuery(ctx, nil, query, args, formattedQuery, nil)
+	res, err := db.DB.ExecContext(ctx, formattedQuery)
 	db.afterQuery(ctx, event, res, err)
 	return res, err
 }
@@ -239,8 +241,9 @@ func (db *DB) Query(query string, args ...interface{}) (*sql.Rows, error) {
 func (db *DB) QueryContext(
 	ctx context.Context, query string, args ...interface{},
 ) (*sql.Rows, error) {
-	ctx, event := db.beforeQuery(ctx, nil, query, args, nil)
-	rows, err := db.DB.QueryContext(ctx, db.format(query, args))
+	formattedQuery := db.format(query, args)
+	ctx, event := db.beforeQuery(ctx, nil, query, args, formattedQuery, nil)
+	rows, err := db.DB.QueryContext(ctx, formattedQuery)
 	db.afterQuery(ctx, event, nil, err)
 	return rows, err
 }
@@ -250,8 +253,9 @@ func (db *DB) QueryRow(query string, args ...interface{}) *sql.Row {
 }
 
 func (db *DB) QueryRowContext(ctx context.Context, query string, args ...interface{}) *sql.Row {
-	ctx, event := db.beforeQuery(ctx, nil, query, args, nil)
-	row := db.DB.QueryRowContext(ctx, db.format(query, args))
+	formattedQuery := db.format(query, args)
+	ctx, event := db.beforeQuery(ctx, nil, query, args, formattedQuery, nil)
+	row := db.DB.QueryRowContext(ctx, formattedQuery)
 	db.afterQuery(ctx, event, nil, row.Err())
 	return row
 }
@@ -281,8 +285,9 @@ func (db *DB) Conn(ctx context.Context) (Conn, error) {
 func (c Conn) ExecContext(
 	ctx context.Context, query string, args ...interface{},
 ) (sql.Result, error) {
-	ctx, event := c.db.beforeQuery(ctx, nil, query, args, nil)
-	res, err := c.Conn.ExecContext(ctx, c.db.format(query, args))
+	formattedQuery := c.db.format(query, args)
+	ctx, event := c.db.beforeQuery(ctx, nil, query, args, formattedQuery, nil)
+	res, err := c.Conn.ExecContext(ctx, formattedQuery)
 	c.db.afterQuery(ctx, event, res, err)
 	return res, err
 }
@@ -290,19 +295,25 @@ func (c Conn) ExecContext(
 func (c Conn) QueryContext(
 	ctx context.Context, query string, args ...interface{},
 ) (*sql.Rows, error) {
-	ctx, event := c.db.beforeQuery(ctx, nil, query, args, nil)
-	rows, err := c.Conn.QueryContext(ctx, c.db.format(query, args))
+	formattedQuery := c.db.format(query, args)
+	ctx, event := c.db.beforeQuery(ctx, nil, query, args, formattedQuery, nil)
+	rows, err := c.Conn.QueryContext(ctx, formattedQuery)
 	c.db.afterQuery(ctx, event, nil, err)
 	return rows, err
 }
 
 func (c Conn) QueryRowContext(ctx context.Context, query string, args ...interface{}) *sql.Row {
-	ctx, event := c.db.beforeQuery(ctx, nil, query, args, nil)
-	row := c.Conn.QueryRowContext(ctx, c.db.format(query, args))
+	formattedQuery := c.db.format(query, args)
+	ctx, event := c.db.beforeQuery(ctx, nil, query, args, formattedQuery, nil)
+	row := c.Conn.QueryRowContext(ctx, formattedQuery)
 	c.db.afterQuery(ctx, event, nil, row.Err())
 	return row
 }
 
+func (c Conn) Dialect() schema.Dialect {
+	return c.db.Dialect()
+}
+
 func (c Conn) NewValues(model interface{}) *ValuesQuery {
 	return NewValuesQuery(c.db, model).Conn(c)
 }
@@ -408,7 +419,7 @@ func (db *DB) Begin() (Tx, error) {
 }
 
 func (db *DB) BeginTx(ctx context.Context, opts *sql.TxOptions) (Tx, error) {
-	ctx, event := db.beforeQuery(ctx, nil, "BEGIN", nil, nil)
+	ctx, event := db.beforeQuery(ctx, nil, "BEGIN", nil, "BEGIN", nil)
 	tx, err := db.DB.BeginTx(ctx, opts)
 	db.afterQuery(ctx, event, nil, err)
 	if err != nil {
@@ -422,14 +433,14 @@ func (db *DB) BeginTx(ctx context.Context, opts *sql.TxOptions) (Tx, error) {
 }
 
 func (tx Tx) Commit() error {
-	ctx, event := tx.db.beforeQuery(tx.ctx, nil, "COMMIT", nil, nil)
+	ctx, event := tx.db.beforeQuery(tx.ctx, nil, "COMMIT", nil, "COMMIT", nil)
 	err := tx.Tx.Commit()
 	tx.db.afterQuery(ctx, event, nil, err)
 	return err
 }
 
 func (tx Tx) Rollback() error {
-	ctx, event := tx.db.beforeQuery(tx.ctx, nil, "ROLLBACK", nil, nil)
+	ctx, event := tx.db.beforeQuery(tx.ctx, nil, "ROLLBACK", nil, "ROLLBACK", nil)
 	err := tx.Tx.Rollback()
 	tx.db.afterQuery(ctx, event, nil, err)
 	return err
@@ -442,8 +453,9 @@ func (tx Tx) Exec(query string, args ...interface{}) (sql.Result, error) {
 func (tx Tx) ExecContext(
 	ctx context.Context, query string, args ...interface{},
 ) (sql.Result, error) {
-	ctx, event := tx.db.beforeQuery(ctx, nil, query, args, nil)
-	res, err := tx.Tx.ExecContext(ctx, tx.db.format(query, args))
+	formattedQuery := tx.db.format(query, args)
+	ctx, event := tx.db.beforeQuery(ctx, nil, query, args, formattedQuery, nil)
+	res, err := tx.Tx.ExecContext(ctx, formattedQuery)
 	tx.db.afterQuery(ctx, event, res, err)
 	return res, err
 }
@@ -455,8 +467,9 @@ func (tx Tx) Query(query string, args ...interface{}) (*sql.Rows, error) {
 func (tx Tx) QueryContext(
 	ctx context.Context, query string, args ...interface{},
 ) (*sql.Rows, error) {
-	ctx, event := tx.db.beforeQuery(ctx, nil, query, args, nil)
-	rows, err := tx.Tx.QueryContext(ctx, tx.db.format(query, args))
+	formattedQuery := tx.db.format(query, args)
+	ctx, event := tx.db.beforeQuery(ctx, nil, query, args, formattedQuery, nil)
+	rows, err := tx.Tx.QueryContext(ctx, formattedQuery)
 	tx.db.afterQuery(ctx, event, nil, err)
 	return rows, err
 }
@@ -466,14 +479,19 @@ func (tx Tx) QueryRow(query string, args ...interface{}) *sql.Row {
 }
 
 func (tx Tx) QueryRowContext(ctx context.Context, query string, args ...interface{}) *sql.Row {
-	ctx, event := tx.db.beforeQuery(ctx, nil, query, args, nil)
-	row := tx.Tx.QueryRowContext(ctx, tx.db.format(query, args))
+	formattedQuery := tx.db.format(query, args)
+	ctx, event := tx.db.beforeQuery(ctx, nil, query, args, formattedQuery, nil)
+	row := tx.Tx.QueryRowContext(ctx, formattedQuery)
 	tx.db.afterQuery(ctx, event, nil, row.Err())
 	return row
 }
 
 //------------------------------------------------------------------------------
 
+func (tx Tx) Dialect() schema.Dialect {
+	return tx.db.Dialect()
+}
+
 func (tx Tx) NewValues(model interface{}) *ValuesQuery {
 	return NewValuesQuery(tx.db, model).Conn(tx)
 }

vendor/github.com/uptrace/bun/hook.go

@@ -13,9 +13,10 @@ import (
 type QueryEvent struct {
 	DB *DB
 
-	QueryAppender schema.QueryAppender // Deprecated: use IQuery instead
+	QueryAppender schema.QueryAppender // DEPRECATED: use IQuery instead
 	IQuery        Query
 	Query         string
+	QueryTemplate string
 	QueryArgs     []interface{}
 	Model         Model
 
@@ -51,8 +52,9 @@ type QueryHook interface {
 func (db *DB) beforeQuery(
 	ctx context.Context,
 	iquery Query,
-	query string,
+	queryTemplate string,
 	queryArgs []interface{},
+	query string,
 	model Model,
 ) (context.Context, *QueryEvent) {
 	atomic.AddUint32(&db.stats.Queries, 1)
@@ -68,6 +70,7 @@ func (db *DB) beforeQuery(
 		QueryAppender: iquery,
 		IQuery:        iquery,
 		Query:         query,
+		QueryTemplate: queryTemplate,
 		QueryArgs:     queryArgs,
 
 		StartTime: time.Now(),

vendor/github.com/uptrace/bun/migrate/migrator.go

@@ -5,7 +5,6 @@ import (
 	"errors"
 	"fmt"
 	"io/ioutil"
-	"log"
 	"path/filepath"
 	"regexp"
 	"time"
@@ -59,11 +58,16 @@ func (m *Migrator) DB() *bun.DB {
 
 // MigrationsWithStatus returns migrations with status in ascending order.
 func (m *Migrator) MigrationsWithStatus(ctx context.Context) (MigrationSlice, error) {
+	sorted, _, err := m.migrationsWithStatus(ctx)
+	return sorted, err
+}
+
+func (m *Migrator) migrationsWithStatus(ctx context.Context) (MigrationSlice, int64, error) {
 	sorted := m.migrations.Sorted()
 
 	applied, err := m.selectAppliedMigrations(ctx)
 	if err != nil {
-		return nil, err
+		return nil, 0, err
 	}
 
 	appliedMap := migrationMap(applied)
@@ -76,7 +80,7 @@ func (m *Migrator) MigrationsWithStatus(ctx context.Context) (MigrationSlice, er
 		}
 	}
 
-	return sorted, nil
+	return sorted, applied.LastGroupID(), nil
 }
 
 func (m *Migrator) Init(ctx context.Context) error {
@@ -128,7 +132,7 @@ func (m *Migrator) Migrate(ctx context.Context, opts ...MigrationOption) (*Migra
 	}
 	defer m.Unlock(ctx) //nolint:errcheck
 
-	migrations, err := m.MigrationsWithStatus(ctx)
+	migrations, lastGroupID, err := m.migrationsWithStatus(ctx)
 	if err != nil {
 		return nil, err
 	}
@@ -139,21 +143,22 @@ func (m *Migrator) Migrate(ctx context.Context, opts ...MigrationOption) (*Migra
 	if len(group.Migrations) == 0 {
 		return group, nil
 	}
-	group.ID = migrations.LastGroupID() + 1
+	group.ID = lastGroupID + 1
 
 	for i := range group.Migrations {
 		migration := &group.Migrations[i]
 		migration.GroupID = group.ID
 
+		// Always mark migration as applied so the rollback has a chance to fix the database.
+		if err := m.MarkApplied(ctx, migration); err != nil {
+			return nil, err
+		}
+
 		if !cfg.nop && migration.Up != nil {
 			if err := migration.Up(ctx, m.db); err != nil {
 				return group, err
 			}
 		}
-
-		if err := m.MarkApplied(ctx, migration); err != nil {
-			return nil, err
-		}
 	}
 
 	return group, nil
@@ -195,36 +200,6 @@ func (m *Migrator) Rollback(ctx context.Context, opts ...MigrationOption) (*Migr
 	return lastGroup, nil
 }
 
-type MigrationStatus struct {
-	Migrations    MigrationSlice
-	NewMigrations MigrationSlice
-	LastGroup     *MigrationGroup
-}
-
-func (m *Migrator) Status(ctx context.Context) (*MigrationStatus, error) {
-	log.Printf(
-		"DEPRECATED: bun: replace Status(ctx) with " +
-			"MigrationsWithStatus(ctx)")
-
-	migrations, err := m.MigrationsWithStatus(ctx)
-	if err != nil {
-		return nil, err
-	}
-	return &MigrationStatus{
-		Migrations:    migrations,
-		NewMigrations: migrations.Unapplied(),
-		LastGroup:     migrations.LastGroup(),
-	}, nil
-}
-
-func (m *Migrator) MarkCompleted(ctx context.Context) (*MigrationGroup, error) {
-	log.Printf(
-		"DEPRECATED: bun: replace MarkCompleted(ctx) with " +
-			"Migrate(ctx, migrate.WithNopMigration())")
-
-	return m.Migrate(ctx, WithNopMigration())
-}
-
 type goMigrationConfig struct {
 	packageName string
 }
@@ -320,7 +295,7 @@ func (m *Migrator) genMigrationName(name string) (string, error) {
 	return fmt.Sprintf("%s_%s", version, name), nil
 }
 
-// MarkApplied marks the migration as applied (applied).
+// MarkApplied marks the migration as applied (completed).
 func (m *Migrator) MarkApplied(ctx context.Context, migration *Migration) error {
 	_, err := m.db.NewInsert().Model(migration).
 		ModelTableExpr(m.table).

vendor/github.com/uptrace/bun/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bun",
-  "version": "1.0.19",
+  "version": "1.0.20",
   "main": "index.js",
   "repository": "git@github.com:uptrace/bun.git",
   "author": "Vladimir Mihailenco <vladimir.webdev@gmail.com>",

vendor/github.com/uptrace/bun/query_base.go

@@ -43,6 +43,7 @@ var (
 // IDB is a common interface for *bun.DB, bun.Conn, and bun.Tx.
 type IDB interface {
 	IConn
+	Dialect() schema.Dialect
 
 	NewValues(model interface{}) *ValuesQuery
 	NewSelect() *SelectQuery
@@ -59,9 +60,9 @@ type IDB interface {
 }
 
 var (
-	_ IConn = (*DB)(nil)
-	_ IConn = (*Conn)(nil)
-	_ IConn = (*Tx)(nil)
+	_ IDB = (*DB)(nil)
+	_ IDB = (*Conn)(nil)
+	_ IDB = (*Tx)(nil)
 )
 
 type baseQuery struct {
@@ -74,10 +75,10 @@ type baseQuery struct {
 	tableModel TableModel
 	table      *schema.Table
 
-	with       []withQuery
-	modelTable schema.QueryWithArgs
-	tables     []schema.QueryWithArgs
-	columns    []schema.QueryWithArgs
+	with           []withQuery
+	modelTableName schema.QueryWithArgs
+	tables         []schema.QueryWithArgs
+	columns        []schema.QueryWithArgs
 
 	flags internal.Flag
 }
@@ -86,13 +87,6 @@ func (q *baseQuery) DB() *DB {
 	return q.db
 }
 
-type query interface {
-	GetModel() Model
-	GetTableName() string
-}
-
-var _ query = (*baseQuery)(nil)
-
 func (q *baseQuery) GetModel() Model {
 	return q.model
 }
@@ -103,15 +97,16 @@ func (q *baseQuery) GetTableName() string {
 	}
 
 	for _, wq := range q.with {
-		if v, ok := wq.query.(query); ok {
+		if v, ok := wq.query.(Query); ok {
 			if model := v.GetModel(); model != nil {
 				return v.GetTableName()
 			}
 		}
 	}
 
-	if q.modelTable.Query != "" {
-		return q.modelTable.Query
+	if q.modelTableName.Query != "" {
+		b, _ := q.modelTableName.AppendQuery(q.db.fmter, nil)
+		return string(b)
 	}
 	if len(q.tables) > 0 {
 		return q.tables[0].Query
@@ -304,8 +299,8 @@ func (q *baseQuery) _excludeColumn(column string) bool {
 //------------------------------------------------------------------------------
 
 func (q *baseQuery) modelHasTableName() bool {
-	if !q.modelTable.IsZero() {
-		return q.modelTable.Query != ""
+	if !q.modelTableName.IsZero() {
+		return q.modelTableName.Query != ""
 	}
 	return q.table != nil
 }
@@ -332,8 +327,8 @@ func (q *baseQuery) _appendTables(
 	startLen := len(b)
 
 	if q.modelHasTableName() {
-		if !q.modelTable.IsZero() {
-			b, err = q.modelTable.AppendQuery(fmter, b)
+		if !q.modelTableName.IsZero() {
+			b, err = q.modelTableName.AppendQuery(fmter, b)
 			if err != nil {
 				return nil, err
 			}
@@ -372,8 +367,8 @@ func (q *baseQuery) appendFirstTableWithAlias(
 func (q *baseQuery) _appendFirstTable(
 	fmter schema.Formatter, b []byte, withAlias bool,
 ) ([]byte, error) {
-	if !q.modelTable.IsZero() {
-		return q.modelTable.AppendQuery(fmter, b)
+	if !q.modelTableName.IsZero() {
+		return q.modelTableName.AppendQuery(fmter, b)
 	}
 
 	if q.table != nil {
@@ -473,7 +468,7 @@ func (q *baseQuery) scan(
 	model Model,
 	hasDest bool,
 ) (sql.Result, error) {
-	ctx, event := q.db.beforeQuery(ctx, iquery, query, nil, q.model)
+	ctx, event := q.db.beforeQuery(ctx, iquery, query, nil, query, q.model)
 
 	rows, err := q.conn.QueryContext(ctx, query)
 	if err != nil {
@@ -503,16 +498,10 @@ func (q *baseQuery) exec(
 	iquery Query,
 	query string,
 ) (sql.Result, error) {
-	ctx, event := q.db.beforeQuery(ctx, iquery, query, nil, q.model)
-
+	ctx, event := q.db.beforeQuery(ctx, iquery, query, nil, query, q.model)
 	res, err := q.conn.ExecContext(ctx, query)
-	if err != nil {
-		q.db.afterQuery(ctx, event, nil, err)
-		return res, err
-	}
-
-	q.db.afterQuery(ctx, event, res, err)
-	return res, nil
+	q.db.afterQuery(ctx, event, nil, err)
+	return res, err
 }
 
 //------------------------------------------------------------------------------
@@ -607,34 +596,30 @@ func (q *whereBaseQuery) addWhereCols(cols []string) {
 		q.setErr(err)
 		return
 	}
-
-	var fields []*schema.Field
-
-	if cols == nil {
-		if err := q.table.CheckPKs(); err != nil {
-			q.setErr(err)
-			return
-		}
-		fields = q.table.PKs
-	} else {
-		fields = make([]*schema.Field, len(cols))
-		for i, col := range cols {
-			field, err := q.table.Field(col)
-			if err != nil {
-				q.setErr(err)
-				return
-			}
-			fields[i] = field
-		}
-	}
-
 	if q.whereFields != nil {
 		err := errors.New("bun: WherePK can only be called once")
 		q.setErr(err)
 		return
 	}
 
-	q.whereFields = fields
+	if cols == nil {
+		if err := q.table.CheckPKs(); err != nil {
+			q.setErr(err)
+			return
+		}
+		q.whereFields = q.table.PKs
+		return
+	}
+
+	q.whereFields = make([]*schema.Field, len(cols))
+	for i, col := range cols {
+		field, err := q.table.Field(col)
+		if err != nil {
+			q.setErr(err)
+			return
+		}
+		q.whereFields[i] = field
+	}
 }
 
 func (q *whereBaseQuery) mustAppendWhere(
@@ -951,6 +936,7 @@ func (q setQuery) appendSet(fmter schema.Formatter, b []byte) (_ []byte, err err
 //------------------------------------------------------------------------------
 
 type cascadeQuery struct {
+	cascade  bool
 	restrict bool
 }
 
@@ -958,10 +944,11 @@ func (q cascadeQuery) appendCascade(fmter schema.Formatter, b []byte) []byte {
 	if !fmter.HasFeature(feature.TableCascade) {
 		return b
 	}
+	if q.cascade {
+		b = append(b, " CASCADE"...)
+	}
 	if q.restrict {
 		b = append(b, " RESTRICT"...)
-	} else {
-		b = append(b, " CASCADE"...)
 	}
 	return b
 }

vendor/github.com/uptrace/bun/query_column_add.go

@@ -15,6 +15,8 @@ type AddColumnQuery struct {
 	ifNotExists bool
 }
 
+var _ Query = (*AddColumnQuery)(nil)
+
 func NewAddColumnQuery(db *DB) *AddColumnQuery {
 	q := &AddColumnQuery{
 		baseQuery: baseQuery{
@@ -50,7 +52,7 @@ func (q *AddColumnQuery) TableExpr(query string, args ...interface{}) *AddColumn
 }
 
 func (q *AddColumnQuery) ModelTableExpr(query string, args ...interface{}) *AddColumnQuery {
-	q.modelTable = schema.SafeQuery(query, args)
+	q.modelTableName = schema.SafeQuery(query, args)
 	return q
 }
 

vendor/github.com/uptrace/bun/query_column_drop.go

@@ -13,6 +13,8 @@ type DropColumnQuery struct {
 	baseQuery
 }
 
+var _ Query = (*DropColumnQuery)(nil)
+
 func NewDropColumnQuery(db *DB) *DropColumnQuery {
 	q := &DropColumnQuery{
 		baseQuery: baseQuery{
@@ -48,7 +50,7 @@ func (q *DropColumnQuery) TableExpr(query string, args ...interface{}) *DropColu
 }
 
 func (q *DropColumnQuery) ModelTableExpr(query string, args ...interface{}) *DropColumnQuery {
-	q.modelTable = schema.SafeQuery(query, args)
+	q.modelTableName = schema.SafeQuery(query, args)
 	return q
 }
 

vendor/github.com/uptrace/bun/query_delete.go

@@ -15,6 +15,8 @@ type DeleteQuery struct {
 	returningQuery
 }
 
+var _ Query = (*DeleteQuery)(nil)
+
 func NewDeleteQuery(db *DB) *DeleteQuery {
 	q := &DeleteQuery{
 		whereBaseQuery: whereBaseQuery{
@@ -60,7 +62,7 @@ func (q *DeleteQuery) TableExpr(query string, args ...interface{}) *DeleteQuery
 }
 
 func (q *DeleteQuery) ModelTableExpr(query string, args ...interface{}) *DeleteQuery {
-	q.modelTable = schema.SafeQuery(query, args)
+	q.modelTableName = schema.SafeQuery(query, args)
 	return q
 }
 
@@ -134,6 +136,10 @@ func (q *DeleteQuery) Operation() string {
 }
 
 func (q *DeleteQuery) AppendQuery(fmter schema.Formatter, b []byte) (_ []byte, err error) {
+	if q.err != nil {
+		return nil, q.err
+	}
+
 	fmter = formatterWithModel(fmter, q)
 
 	if q.isSoftDelete() {

vendor/github.com/uptrace/bun/query_index_create.go

@@ -22,6 +22,8 @@ type CreateIndexQuery struct {
 	include []schema.QueryWithArgs
 }
 
+var _ Query = (*CreateIndexQuery)(nil)
+
 func NewCreateIndexQuery(db *DB) *CreateIndexQuery {
 	q := &CreateIndexQuery{
 		whereBaseQuery: whereBaseQuery{
@@ -86,7 +88,7 @@ func (q *CreateIndexQuery) TableExpr(query string, args ...interface{}) *CreateI
 }
 
 func (q *CreateIndexQuery) ModelTableExpr(query string, args ...interface{}) *CreateIndexQuery {
-	q.modelTable = schema.SafeQuery(query, args)
+	q.modelTableName = schema.SafeQuery(query, args)
 	return q
 }
 

vendor/github.com/uptrace/bun/query_index_drop.go

@@ -18,6 +18,8 @@ type DropIndexQuery struct {
 	index schema.QueryWithArgs
 }
 
+var _ Query = (*DropIndexQuery)(nil)
+
 func NewDropIndexQuery(db *DB) *DropIndexQuery {
 	q := &DropIndexQuery{
 		baseQuery: baseQuery{
@@ -50,6 +52,11 @@ func (q *DropIndexQuery) IfExists() *DropIndexQuery {
 	return q
 }
 
+func (q *DropIndexQuery) Cascade() *DropIndexQuery {
+	q.cascade = true
+	return q
+}
+
 func (q *DropIndexQuery) Restrict() *DropIndexQuery {
 	q.restrict = true
 	return q

vendor/github.com/uptrace/bun/query_insert.go

@@ -24,6 +24,8 @@ type InsertQuery struct {
 	replace bool
 }
 
+var _ Query = (*InsertQuery)(nil)
+
 func NewInsertQuery(db *DB) *InsertQuery {
 	q := &InsertQuery{
 		whereBaseQuery: whereBaseQuery{
@@ -71,7 +73,7 @@ func (q *InsertQuery) TableExpr(query string, args ...interface{}) *InsertQuery
 }
 
 func (q *InsertQuery) ModelTableExpr(query string, args ...interface{}) *InsertQuery {
-	q.modelTable = schema.SafeQuery(query, args)
+	q.modelTableName = schema.SafeQuery(query, args)
 	return q
 }
 
@@ -159,6 +161,10 @@ func (q *InsertQuery) Operation() string {
 }
 
 func (q *InsertQuery) AppendQuery(fmter schema.Formatter, b []byte) (_ []byte, err error) {
+	if q.err != nil {
+		return nil, q.err
+	}
+
 	fmter = formatterWithModel(fmter, q)
 
 	b, err = q.appendWith(fmter, b)

vendor/github.com/uptrace/bun/query_select.go

@@ -34,6 +34,8 @@ type SelectQuery struct {
 	union []union
 }
 
+var _ Query = (*SelectQuery)(nil)
+
 func NewSelectQuery(db *DB) *SelectQuery {
 	return &SelectQuery{
 		whereBaseQuery: whereBaseQuery{
@@ -90,7 +92,7 @@ func (q *SelectQuery) TableExpr(query string, args ...interface{}) *SelectQuery
 }
 
 func (q *SelectQuery) ModelTableExpr(query string, args ...interface{}) *SelectQuery {
-	q.modelTable = schema.SafeQuery(query, args)
+	q.modelTableName = schema.SafeQuery(query, args)
 	return q
 }
 
@@ -342,9 +344,9 @@ func (q *SelectQuery) selectJoins(ctx context.Context, joins []relationJoin) err
 		case schema.HasOneRelation, schema.BelongsToRelation:
 			err = q.selectJoins(ctx, j.JoinModel.getJoins())
 		case schema.HasManyRelation:
-			err = j.selectMany(ctx, q.db.NewSelect())
+			err = j.selectMany(ctx, q.db.NewSelect().Conn(q.conn))
 		case schema.ManyToManyRelation:
-			err = j.selectM2M(ctx, q.db.NewSelect())
+			err = j.selectM2M(ctx, q.db.NewSelect().Conn(q.conn))
 		default:
 			panic("not reached")
 		}
@@ -369,6 +371,10 @@ func (q *SelectQuery) AppendQuery(fmter schema.Formatter, b []byte) (_ []byte, e
 func (q *SelectQuery) appendQuery(
 	fmter schema.Formatter, b []byte, count bool,
 ) (_ []byte, err error) {
+	if q.err != nil {
+		return nil, q.err
+	}
+
 	fmter = formatterWithModel(fmter, q)
 
 	cteCount := count && (len(q.group) > 0 || q.distinctOn != nil)
@@ -767,7 +773,7 @@ func (q *SelectQuery) Count(ctx context.Context) (int, error) {
 	}
 
 	query := internal.String(queryBytes)
-	ctx, event := q.db.beforeQuery(ctx, qq, query, nil, q.model)
+	ctx, event := q.db.beforeQuery(ctx, qq, query, nil, query, q.model)
 
 	var num int
 	err = q.conn.QueryRowContext(ctx, query).Scan(&num)
@@ -778,6 +784,13 @@ func (q *SelectQuery) Count(ctx context.Context) (int, error) {
 }
 
 func (q *SelectQuery) ScanAndCount(ctx context.Context, dest ...interface{}) (int, error) {
+	if _, ok := q.conn.(*DB); ok {
+		return q.scanAndCountConc(ctx, dest...)
+	}
+	return q.scanAndCountSeq(ctx, dest...)
+}
+
+func (q *SelectQuery) scanAndCountConc(ctx context.Context, dest ...interface{}) (int, error) {
 	var count int
 	var wg sync.WaitGroup
 	var mu sync.Mutex
@@ -817,6 +830,21 @@ func (q *SelectQuery) ScanAndCount(ctx context.Context, dest ...interface{}) (in
 	return count, firstErr
 }
 
+func (q *SelectQuery) scanAndCountSeq(ctx context.Context, dest ...interface{}) (int, error) {
+	var firstErr error
+
+	if q.limit >= 0 {
+		firstErr = q.Scan(ctx, dest...)
+	}
+
+	count, err := q.Count(ctx)
+	if err != nil && firstErr == nil {
+		firstErr = err
+	}
+
+	return count, firstErr
+}
+
 func (q *SelectQuery) Exists(ctx context.Context) (bool, error) {
 	if q.err != nil {
 		return false, q.err
@@ -830,7 +858,7 @@ func (q *SelectQuery) Exists(ctx context.Context) (bool, error) {
 	}
 
 	query := internal.String(queryBytes)
-	ctx, event := q.db.beforeQuery(ctx, qq, query, nil, q.model)
+	ctx, event := q.db.beforeQuery(ctx, qq, query, nil, query, q.model)
 
 	var exists bool
 	err = q.conn.QueryRowContext(ctx, query).Scan(&exists)

vendor/github.com/uptrace/bun/query_table_create.go

@@ -24,6 +24,8 @@ type CreateTableQuery struct {
 	tablespace  schema.QueryWithArgs
 }
 
+var _ Query = (*CreateTableQuery)(nil)
+
 func NewCreateTableQuery(db *DB) *CreateTableQuery {
 	q := &CreateTableQuery{
 		baseQuery: baseQuery{
@@ -59,7 +61,7 @@ func (q *CreateTableQuery) TableExpr(query string, args ...interface{}) *CreateT
 }
 
 func (q *CreateTableQuery) ModelTableExpr(query string, args ...interface{}) *CreateTableQuery {
-	q.modelTable = schema.SafeQuery(query, args)
+	q.modelTableName = schema.SafeQuery(query, args)
 	return q
 }
 

vendor/github.com/uptrace/bun/query_table_drop.go

@@ -15,6 +15,8 @@ type DropTableQuery struct {
 	ifExists bool
 }
 
+var _ Query = (*DropTableQuery)(nil)
+
 func NewDropTableQuery(db *DB) *DropTableQuery {
 	q := &DropTableQuery{
 		baseQuery: baseQuery{
@@ -50,7 +52,7 @@ func (q *DropTableQuery) TableExpr(query string, args ...interface{}) *DropTable
 }
 
 func (q *DropTableQuery) ModelTableExpr(query string, args ...interface{}) *DropTableQuery {
-	q.modelTable = schema.SafeQuery(query, args)
+	q.modelTableName = schema.SafeQuery(query, args)
 	return q
 }
 
@@ -61,6 +63,11 @@ func (q *DropTableQuery) IfExists() *DropTableQuery {
 	return q
 }
 
+func (q *DropTableQuery) Cascade() *DropTableQuery {
+	q.cascade = true
+	return q
+}
+
 func (q *DropTableQuery) Restrict() *DropTableQuery {
 	q.restrict = true
 	return q

vendor/github.com/uptrace/bun/query_table_truncate.go

@@ -16,6 +16,8 @@ type TruncateTableQuery struct {
 	continueIdentity bool
 }
 
+var _ Query = (*TruncateTableQuery)(nil)
+
 func NewTruncateTableQuery(db *DB) *TruncateTableQuery {
 	q := &TruncateTableQuery{
 		baseQuery: baseQuery{
@@ -57,6 +59,11 @@ func (q *TruncateTableQuery) ContinueIdentity() *TruncateTableQuery {
 	return q
 }
 
+func (q *TruncateTableQuery) Cascade() *TruncateTableQuery {
+	q.cascade = true
+	return q
+}
+
 func (q *TruncateTableQuery) Restrict() *TruncateTableQuery {
 	q.restrict = true
 	return q

vendor/github.com/uptrace/bun/query_update.go

@@ -20,6 +20,8 @@ type UpdateQuery struct {
 	omitZero bool
 }
 
+var _ Query = (*UpdateQuery)(nil)
+
 func NewUpdateQuery(db *DB) *UpdateQuery {
 	q := &UpdateQuery{
 		whereBaseQuery: whereBaseQuery{
@@ -67,7 +69,7 @@ func (q *UpdateQuery) TableExpr(query string, args ...interface{}) *UpdateQuery
 }
 
 func (q *UpdateQuery) ModelTableExpr(query string, args ...interface{}) *UpdateQuery {
-	q.modelTable = schema.SafeQuery(query, args)
+	q.modelTableName = schema.SafeQuery(query, args)
 	return q
 }
 
@@ -170,6 +172,10 @@ func (q *UpdateQuery) Operation() string {
 }
 
 func (q *UpdateQuery) AppendQuery(fmter schema.Formatter, b []byte) (_ []byte, err error) {
+	if q.err != nil {
+		return nil, q.err
+	}
+
 	fmter = formatterWithModel(fmter, q)
 
 	b, err = q.appendWith(fmter, b)

vendor/github.com/uptrace/bun/query_values.go

@@ -16,7 +16,10 @@ type ValuesQuery struct {
 	withOrder bool
 }
 
-var _ schema.NamedArgAppender = (*ValuesQuery)(nil)
+var (
+	_ Query                   = (*ValuesQuery)(nil)
+	_ schema.NamedArgAppender = (*ValuesQuery)(nil)
+)
 
 func NewValuesQuery(db *DB, model interface{}) *ValuesQuery {
 	q := &ValuesQuery{

vendor/github.com/uptrace/bun/schema/formatter.go

@@ -177,8 +177,6 @@ type NamedArgAppender interface {
 	AppendNamedArg(fmter Formatter, b []byte, name string) ([]byte, bool)
 }
 
-//------------------------------------------------------------------------------
-
 type namedArgList struct {
 	arg  NamedArgAppender
 	next *namedArgList
@@ -219,13 +217,13 @@ func (a *namedArg) AppendNamedArg(fmter Formatter, b []byte, name string) ([]byt
 
 //------------------------------------------------------------------------------
 
-var _ NamedArgAppender = (*structArgs)(nil)
-
 type structArgs struct {
 	table *Table
 	strct reflect.Value
 }
 
+var _ NamedArgAppender = (*structArgs)(nil)
+
 func newStructArgs(fmter Formatter, strct interface{}) (*structArgs, bool) {
 	v := reflect.ValueOf(strct)
 	if !v.IsValid() {

vendor/github.com/uptrace/bun/schema/table.go

@@ -203,7 +203,7 @@ func (t *Table) fieldByGoName(name string) *Field {
 func (t *Table) initFields() {
 	t.Fields = make([]*Field, 0, t.Type.NumField())
 	t.FieldMap = make(map[string]*Field, t.Type.NumField())
-	t.addFields(t.Type, nil)
+	t.addFields(t.Type, "", nil)
 
 	if len(t.PKs) == 0 {
 		for _, name := range []string{"id", "uuid", "pk_" + t.ModelName} {
@@ -230,7 +230,7 @@ func (t *Table) initFields() {
 	}
 }
 
-func (t *Table) addFields(typ reflect.Type, baseIndex []int) {
+func (t *Table) addFields(typ reflect.Type, prefix string, index []int) {
 	for i := 0; i < typ.NumField(); i++ {
 		f := typ.Field(i)
 		unexported := f.PkgPath != ""
@@ -242,10 +242,6 @@ func (t *Table) addFields(typ reflect.Type, baseIndex []int) {
 			continue
 		}
 
-		// Make a copy so the slice is not shared between fields.
-		index := make([]int, len(baseIndex))
-		copy(index, baseIndex)
-
 		if f.Anonymous {
 			if f.Name == "BaseModel" && f.Type == baseModelType {
 				if len(index) == 0 {
@@ -258,7 +254,7 @@ func (t *Table) addFields(typ reflect.Type, baseIndex []int) {
 			if fieldType.Kind() != reflect.Struct {
 				continue
 			}
-			t.addFields(fieldType, append(index, f.Index...))
+			t.addFields(fieldType, "", withIndex(index, f.Index))
 
 			tag := tagparser.Parse(f.Tag.Get("bun"))
 			if _, inherit := tag.Options["inherit"]; inherit {
@@ -274,7 +270,7 @@ func (t *Table) addFields(typ reflect.Type, baseIndex []int) {
 			continue
 		}
 
-		if field := t.newField(f, index); field != nil {
+		if field := t.newField(f, prefix, index); field != nil {
 			t.addField(field)
 		}
 	}
@@ -315,10 +311,20 @@ func (t *Table) processBaseModelField(f reflect.StructField) {
 }
 
 //nolint
-func (t *Table) newField(f reflect.StructField, index []int) *Field {
-	sqlName := internal.Underscore(f.Name)
+func (t *Table) newField(f reflect.StructField, prefix string, index []int) *Field {
 	tag := tagparser.Parse(f.Tag.Get("bun"))
 
+	if prefix, ok := tag.Option("embed"); ok {
+		fieldType := indirectType(f.Type)
+		if fieldType.Kind() != reflect.Struct {
+			panic(fmt.Errorf("bun: embed %s.%s: got %s, wanted reflect.Struct",
+				t.TypeName, f.Name, fieldType.Kind()))
+		}
+		t.addFields(fieldType, prefix, withIndex(index, f.Index))
+		return nil
+	}
+
+	sqlName := internal.Underscore(f.Name)
 	if tag.Name != "" && tag.Name != sqlName {
 		if isKnownFieldOption(tag.Name) {
 			internal.Warn.Printf(
@@ -328,10 +334,10 @@ func (t *Table) newField(f reflect.StructField, index []int) *Field {
 		}
 		sqlName = tag.Name
 	}
-
 	if s, ok := tag.Option("column"); ok {
 		sqlName = s
 	}
+	sqlName = prefix + sqlName
 
 	for name := range tag.Options {
 		if !isKnownFieldOption(name) {
@@ -339,7 +345,7 @@ func (t *Table) newField(f reflect.StructField, index []int) *Field {
 		}
 	}
 
-	index = append(index, f.Index...)
+	index = withIndex(index, f.Index)
 	if field := t.fieldWithLock(sqlName); field != nil {
 		if indexEqual(field.Index, index) {
 			return field
@@ -795,7 +801,7 @@ func (t *Table) inlineFields(field *Field, seen map[reflect.Type]struct{}) {
 		f.GoName = field.GoName + "_" + f.GoName
 		f.Name = field.Name + "__" + f.Name
 		f.SQLName = t.quoteIdent(f.Name)
-		f.Index = appendNew(field.Index, f.Index...)
+		f.Index = withIndex(field.Index, f.Index)
 
 		t.fieldsMapMu.Lock()
 		if _, ok := t.FieldMap[f.Name]; !ok {
@@ -834,7 +840,7 @@ func (t *Table) AppendNamedArg(
 	fmter Formatter, b []byte, name string, strct reflect.Value,
 ) ([]byte, bool) {
 	if field, ok := t.FieldMap[name]; ok {
-		return fmter.appendArg(b, field.Value(strct).Interface()), true
+		return field.AppendValue(fmter, b, strct), true
 	}
 	return b, false
 }
@@ -853,13 +859,6 @@ func (t *Table) quoteIdent(s string) Safe {
 	return Safe(NewFormatter(t.dialect).AppendIdent(nil, s))
 }
 
-func appendNew(dst []int, src ...int) []int {
-	cp := make([]int, len(dst)+len(src))
-	copy(cp, dst)
-	copy(cp[len(dst):], src)
-	return cp
-}
-
 func isKnownTableOption(name string) bool {
 	switch name {
 	case "table", "alias", "select":
@@ -991,3 +990,10 @@ func softDeleteFieldUpdaterFallback(field *Field) func(fv reflect.Value, tm time
 		return field.ScanWithCheck(fv, tm)
 	}
 }
+
+func withIndex(a, b []int) []int {
+	dest := make([]int, 0, len(a)+len(b))
+	dest = append(dest, a...)
+	dest = append(dest, b...)
+	return dest
+}

vendor/github.com/uptrace/bun/version.go

@@ -2,5 +2,5 @@ package bun
 
 // Version is the current release version.
 func Version() string {
-	return "1.0.19"
+	return "1.0.20"
 }

vendor/golang.org/x/sys/unix/mkerrors.sh

@@ -261,6 +261,7 @@ struct ltchars {
 #include <linux/vm_sockets.h>
 #include <linux/wait.h>
 #include <linux/watchdog.h>
+#include <linux/wireguard.h>
 
 #include <mtd/ubi-user.h>
 #include <mtd/mtd-user.h>
@@ -606,6 +607,7 @@ ccflags="$@"
 		$2 ~ /^MTD/ ||
 		$2 ~ /^OTP/ ||
 		$2 ~ /^MEM/ ||
+		$2 ~ /^WG/ ||
 		$2 ~ /^BLK[A-Z]*(GET$|SET$|BUF$|PART$|SIZE)/ {printf("\t%s = C.%s\n", $2, $2)}
 		$2 ~ /^__WCOREFLAG$/ {next}
 		$2 ~ /^__W[A-Z0-9]+$/ {printf("\t%s = C.%s\n", substr($2,3), $2)}

vendor/golang.org/x/sys/unix/zerrors_linux.go

@@ -741,6 +741,7 @@ const (
 	ETH_P_QINQ2                                 = 0x9200
 	ETH_P_QINQ3                                 = 0x9300
 	ETH_P_RARP                                  = 0x8035
+	ETH_P_REALTEK                               = 0x8899
 	ETH_P_SCA                                   = 0x6007
 	ETH_P_SLOW                                  = 0x8809
 	ETH_P_SNAP                                  = 0x5
@@ -810,10 +811,12 @@ const (
 	FAN_EPIDFD                                  = -0x2
 	FAN_EVENT_INFO_TYPE_DFID                    = 0x3
 	FAN_EVENT_INFO_TYPE_DFID_NAME               = 0x2
+	FAN_EVENT_INFO_TYPE_ERROR                   = 0x5
 	FAN_EVENT_INFO_TYPE_FID                     = 0x1
 	FAN_EVENT_INFO_TYPE_PIDFD                   = 0x4
 	FAN_EVENT_METADATA_LEN                      = 0x18
 	FAN_EVENT_ON_CHILD                          = 0x8000000
+	FAN_FS_ERROR                                = 0x8000
 	FAN_MARK_ADD                                = 0x1
 	FAN_MARK_DONT_FOLLOW                        = 0x4
 	FAN_MARK_FILESYSTEM                         = 0x100
@@ -1827,6 +1830,8 @@ const (
 	PERF_MEM_BLK_DATA                           = 0x2
 	PERF_MEM_BLK_NA                             = 0x1
 	PERF_MEM_BLK_SHIFT                          = 0x28
+	PERF_MEM_HOPS_0                             = 0x1
+	PERF_MEM_HOPS_SHIFT                         = 0x2b
 	PERF_MEM_LOCK_LOCKED                        = 0x2
 	PERF_MEM_LOCK_NA                            = 0x1
 	PERF_MEM_LOCK_SHIFT                         = 0x18
@@ -1986,6 +1991,9 @@ const (
 	PR_SCHED_CORE_CREATE                        = 0x1
 	PR_SCHED_CORE_GET                           = 0x0
 	PR_SCHED_CORE_MAX                           = 0x4
+	PR_SCHED_CORE_SCOPE_PROCESS_GROUP           = 0x2
+	PR_SCHED_CORE_SCOPE_THREAD                  = 0x0
+	PR_SCHED_CORE_SCOPE_THREAD_GROUP            = 0x1
 	PR_SCHED_CORE_SHARE_FROM                    = 0x3
 	PR_SCHED_CORE_SHARE_TO                      = 0x2
 	PR_SET_CHILD_SUBREAPER                      = 0x24
@@ -2167,12 +2175,23 @@ const (
 	RTCF_NAT                                    = 0x800000
 	RTCF_VALVE                                  = 0x200000
 	RTC_AF                                      = 0x20
+	RTC_BSM_DIRECT                              = 0x1
+	RTC_BSM_DISABLED                            = 0x0
+	RTC_BSM_LEVEL                               = 0x2
+	RTC_BSM_STANDBY                             = 0x3
 	RTC_FEATURE_ALARM                           = 0x0
+	RTC_FEATURE_ALARM_RES_2S                    = 0x3
 	RTC_FEATURE_ALARM_RES_MINUTE                = 0x1
-	RTC_FEATURE_CNT                             = 0x3
+	RTC_FEATURE_BACKUP_SWITCH_MODE              = 0x6
+	RTC_FEATURE_CNT                             = 0x7
+	RTC_FEATURE_CORRECTION                      = 0x5
 	RTC_FEATURE_NEED_WEEK_DAY                   = 0x2
+	RTC_FEATURE_UPDATE_INTERRUPT                = 0x4
 	RTC_IRQF                                    = 0x80
 	RTC_MAX_FREQ                                = 0x2000
+	RTC_PARAM_BACKUP_SWITCH_MODE                = 0x2
+	RTC_PARAM_CORRECTION                        = 0x1
+	RTC_PARAM_FEATURES                          = 0x0
 	RTC_PF                                      = 0x40
 	RTC_UF                                      = 0x10
 	RTF_ADDRCLASSMASK                           = 0xf8000000
@@ -2532,6 +2551,8 @@ const (
 	SO_VM_SOCKETS_BUFFER_MIN_SIZE               = 0x1
 	SO_VM_SOCKETS_BUFFER_SIZE                   = 0x0
 	SO_VM_SOCKETS_CONNECT_TIMEOUT               = 0x6
+	SO_VM_SOCKETS_CONNECT_TIMEOUT_NEW           = 0x8
+	SO_VM_SOCKETS_CONNECT_TIMEOUT_OLD           = 0x6
 	SO_VM_SOCKETS_NONBLOCK_TXRX                 = 0x7
 	SO_VM_SOCKETS_PEER_HOST_VM_ID               = 0x3
 	SO_VM_SOCKETS_TRUSTED                       = 0x5
@@ -2826,6 +2847,13 @@ const (
 	WDIOS_TEMPPANIC                             = 0x4
 	WDIOS_UNKNOWN                               = -0x1
 	WEXITED                                     = 0x4
+	WGALLOWEDIP_A_MAX                           = 0x3
+	WGDEVICE_A_MAX                              = 0x8
+	WGPEER_A_MAX                                = 0xa
+	WG_CMD_MAX                                  = 0x1
+	WG_GENL_NAME                                = "wireguard"
+	WG_GENL_VERSION                             = 0x1
+	WG_KEY_LEN                                  = 0x20
 	WIN_ACKMEDIACHANGE                          = 0xdb
 	WIN_CHECKPOWERMODE1                         = 0xe5
 	WIN_CHECKPOWERMODE2                         = 0x98

vendor/golang.org/x/sys/unix/zerrors_linux_386.go

@@ -250,6 +250,8 @@ const (
 	RTC_EPOCH_SET                    = 0x4004700e
 	RTC_IRQP_READ                    = 0x8004700b
 	RTC_IRQP_SET                     = 0x4004700c
+	RTC_PARAM_GET                    = 0x40187013
+	RTC_PARAM_SET                    = 0x40187014
 	RTC_PIE_OFF                      = 0x7006
 	RTC_PIE_ON                       = 0x7005
 	RTC_PLL_GET                      = 0x801c7011
@@ -327,6 +329,7 @@ const (
 	SO_RCVTIMEO                      = 0x14
 	SO_RCVTIMEO_NEW                  = 0x42
 	SO_RCVTIMEO_OLD                  = 0x14
+	SO_RESERVE_MEM                   = 0x49
 	SO_REUSEADDR                     = 0x2
 	SO_REUSEPORT                     = 0xf
 	SO_RXQ_OVFL                      = 0x28

vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go

@@ -251,6 +251,8 @@ const (
 	RTC_EPOCH_SET                    = 0x4008700e
 	RTC_IRQP_READ                    = 0x8008700b
 	RTC_IRQP_SET                     = 0x4008700c
+	RTC_PARAM_GET                    = 0x40187013
+	RTC_PARAM_SET                    = 0x40187014
 	RTC_PIE_OFF                      = 0x7006
 	RTC_PIE_ON                       = 0x7005
 	RTC_PLL_GET                      = 0x80207011
@@ -328,6 +330,7 @@ const (
 	SO_RCVTIMEO                      = 0x14
 	SO_RCVTIMEO_NEW                  = 0x42
 	SO_RCVTIMEO_OLD                  = 0x14
+	SO_RESERVE_MEM                   = 0x49
 	SO_REUSEADDR                     = 0x2
 	SO_REUSEPORT                     = 0xf
 	SO_RXQ_OVFL                      = 0x28

vendor/golang.org/x/sys/unix/zerrors_linux_arm.go

@@ -257,6 +257,8 @@ const (
 	RTC_EPOCH_SET                    = 0x4004700e
 	RTC_IRQP_READ                    = 0x8004700b
 	RTC_IRQP_SET                     = 0x4004700c
+	RTC_PARAM_GET                    = 0x40187013
+	RTC_PARAM_SET                    = 0x40187014
 	RTC_PIE_OFF                      = 0x7006
 	RTC_PIE_ON                       = 0x7005
 	RTC_PLL_GET                      = 0x801c7011
@@ -334,6 +336,7 @@ const (
 	SO_RCVTIMEO                      = 0x14
 	SO_RCVTIMEO_NEW                  = 0x42
 	SO_RCVTIMEO_OLD                  = 0x14
+	SO_RESERVE_MEM                   = 0x49
 	SO_REUSEADDR                     = 0x2
 	SO_REUSEPORT                     = 0xf
 	SO_RXQ_OVFL                      = 0x28

vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go

@@ -247,6 +247,8 @@ const (
 	RTC_EPOCH_SET                    = 0x4008700e
 	RTC_IRQP_READ                    = 0x8008700b
 	RTC_IRQP_SET                     = 0x4008700c
+	RTC_PARAM_GET                    = 0x40187013
+	RTC_PARAM_SET                    = 0x40187014
 	RTC_PIE_OFF                      = 0x7006
 	RTC_PIE_ON                       = 0x7005
 	RTC_PLL_GET                      = 0x80207011
@@ -324,6 +326,7 @@ const (
 	SO_RCVTIMEO                      = 0x14
 	SO_RCVTIMEO_NEW                  = 0x42
 	SO_RCVTIMEO_OLD                  = 0x14
+	SO_RESERVE_MEM                   = 0x49
 	SO_REUSEADDR                     = 0x2
 	SO_REUSEPORT                     = 0xf
 	SO_RXQ_OVFL                      = 0x28

vendor/golang.org/x/sys/unix/zerrors_linux_mips.go

@@ -250,6 +250,8 @@ const (
 	RTC_EPOCH_SET                    = 0x8004700e
 	RTC_IRQP_READ                    = 0x4004700b
 	RTC_IRQP_SET                     = 0x8004700c
+	RTC_PARAM_GET                    = 0x80187013
+	RTC_PARAM_SET                    = 0x80187014
 	RTC_PIE_OFF                      = 0x20007006
 	RTC_PIE_ON                       = 0x20007005
 	RTC_PLL_GET                      = 0x401c7011
@@ -327,6 +329,7 @@ const (
 	SO_RCVTIMEO                      = 0x1006
 	SO_RCVTIMEO_NEW                  = 0x42
 	SO_RCVTIMEO_OLD                  = 0x1006
+	SO_RESERVE_MEM                   = 0x49
 	SO_REUSEADDR                     = 0x4
 	SO_REUSEPORT                     = 0x200
 	SO_RXQ_OVFL                      = 0x28

vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go

@@ -250,6 +250,8 @@ const (
 	RTC_EPOCH_SET                    = 0x8008700e
 	RTC_IRQP_READ                    = 0x4008700b
 	RTC_IRQP_SET                     = 0x8008700c
+	RTC_PARAM_GET                    = 0x80187013
+	RTC_PARAM_SET                    = 0x80187014
 	RTC_PIE_OFF                      = 0x20007006
 	RTC_PIE_ON                       = 0x20007005
 	RTC_PLL_GET                      = 0x40207011
@@ -327,6 +329,7 @@ const (
 	SO_RCVTIMEO                      = 0x1006
 	SO_RCVTIMEO_NEW                  = 0x42
 	SO_RCVTIMEO_OLD                  = 0x1006
+	SO_RESERVE_MEM                   = 0x49
 	SO_REUSEADDR                     = 0x4
 	SO_REUSEPORT                     = 0x200
 	SO_RXQ_OVFL                      = 0x28

vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go

@@ -250,6 +250,8 @@ const (
 	RTC_EPOCH_SET                    = 0x8008700e
 	RTC_IRQP_READ                    = 0x4008700b
 	RTC_IRQP_SET                     = 0x8008700c
+	RTC_PARAM_GET                    = 0x80187013
+	RTC_PARAM_SET                    = 0x80187014
 	RTC_PIE_OFF                      = 0x20007006
 	RTC_PIE_ON                       = 0x20007005
 	RTC_PLL_GET                      = 0x40207011
@@ -327,6 +329,7 @@ const (
 	SO_RCVTIMEO                      = 0x1006
 	SO_RCVTIMEO_NEW                  = 0x42
 	SO_RCVTIMEO_OLD                  = 0x1006
+	SO_RESERVE_MEM                   = 0x49
 	SO_REUSEADDR                     = 0x4
 	SO_REUSEPORT                     = 0x200
 	SO_RXQ_OVFL                      = 0x28

vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go

@@ -250,6 +250,8 @@ const (
 	RTC_EPOCH_SET                    = 0x8004700e
 	RTC_IRQP_READ                    = 0x4004700b
 	RTC_IRQP_SET                     = 0x8004700c
+	RTC_PARAM_GET                    = 0x80187013
+	RTC_PARAM_SET                    = 0x80187014
 	RTC_PIE_OFF                      = 0x20007006
 	RTC_PIE_ON                       = 0x20007005
 	RTC_PLL_GET                      = 0x401c7011
@@ -327,6 +329,7 @@ const (
 	SO_RCVTIMEO                      = 0x1006
 	SO_RCVTIMEO_NEW                  = 0x42
 	SO_RCVTIMEO_OLD                  = 0x1006
+	SO_RESERVE_MEM                   = 0x49
 	SO_REUSEADDR                     = 0x4
 	SO_REUSEPORT                     = 0x200
 	SO_RXQ_OVFL                      = 0x28

vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go

@@ -305,6 +305,8 @@ const (
 	RTC_EPOCH_SET                    = 0x8004700e
 	RTC_IRQP_READ                    = 0x4004700b
 	RTC_IRQP_SET                     = 0x8004700c
+	RTC_PARAM_GET                    = 0x80187013
+	RTC_PARAM_SET                    = 0x80187014
 	RTC_PIE_OFF                      = 0x20007006
 	RTC_PIE_ON                       = 0x20007005
 	RTC_PLL_GET                      = 0x401c7011
@@ -382,6 +384,7 @@ const (
 	SO_RCVTIMEO                      = 0x12
 	SO_RCVTIMEO_NEW                  = 0x42
 	SO_RCVTIMEO_OLD                  = 0x12
+	SO_RESERVE_MEM                   = 0x49
 	SO_REUSEADDR                     = 0x2
 	SO_REUSEPORT                     = 0xf
 	SO_RXQ_OVFL                      = 0x28

vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go

@@ -309,6 +309,8 @@ const (
 	RTC_EPOCH_SET                    = 0x8008700e
 	RTC_IRQP_READ                    = 0x4008700b
 	RTC_IRQP_SET                     = 0x8008700c
+	RTC_PARAM_GET                    = 0x80187013
+	RTC_PARAM_SET                    = 0x80187014
 	RTC_PIE_OFF                      = 0x20007006
 	RTC_PIE_ON                       = 0x20007005
 	RTC_PLL_GET                      = 0x40207011
@@ -386,6 +388,7 @@ const (
 	SO_RCVTIMEO                      = 0x12
 	SO_RCVTIMEO_NEW                  = 0x42
 	SO_RCVTIMEO_OLD                  = 0x12
+	SO_RESERVE_MEM                   = 0x49
 	SO_REUSEADDR                     = 0x2
 	SO_REUSEPORT                     = 0xf
 	SO_RXQ_OVFL                      = 0x28

vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go

@@ -309,6 +309,8 @@ const (
 	RTC_EPOCH_SET                    = 0x8008700e
 	RTC_IRQP_READ                    = 0x4008700b
 	RTC_IRQP_SET                     = 0x8008700c
+	RTC_PARAM_GET                    = 0x80187013
+	RTC_PARAM_SET                    = 0x80187014
 	RTC_PIE_OFF                      = 0x20007006
 	RTC_PIE_ON                       = 0x20007005
 	RTC_PLL_GET                      = 0x40207011
@@ -386,6 +388,7 @@ const (
 	SO_RCVTIMEO                      = 0x12
 	SO_RCVTIMEO_NEW                  = 0x42
 	SO_RCVTIMEO_OLD                  = 0x12
+	SO_RESERVE_MEM                   = 0x49
 	SO_REUSEADDR                     = 0x2
 	SO_REUSEPORT                     = 0xf
 	SO_RXQ_OVFL                      = 0x28

vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go

@@ -238,6 +238,8 @@ const (
 	RTC_EPOCH_SET                    = 0x4008700e
 	RTC_IRQP_READ                    = 0x8008700b
 	RTC_IRQP_SET                     = 0x4008700c
+	RTC_PARAM_GET                    = 0x40187013
+	RTC_PARAM_SET                    = 0x40187014
 	RTC_PIE_OFF                      = 0x7006
 	RTC_PIE_ON                       = 0x7005
 	RTC_PLL_GET                      = 0x80207011
@@ -315,6 +317,7 @@ const (
 	SO_RCVTIMEO                      = 0x14
 	SO_RCVTIMEO_NEW                  = 0x42
 	SO_RCVTIMEO_OLD                  = 0x14
+	SO_RESERVE_MEM                   = 0x49
 	SO_REUSEADDR                     = 0x2
 	SO_REUSEPORT                     = 0xf
 	SO_RXQ_OVFL                      = 0x28

vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go

@@ -313,6 +313,8 @@ const (
 	RTC_EPOCH_SET                    = 0x4008700e
 	RTC_IRQP_READ                    = 0x8008700b
 	RTC_IRQP_SET                     = 0x4008700c
+	RTC_PARAM_GET                    = 0x40187013
+	RTC_PARAM_SET                    = 0x40187014
 	RTC_PIE_OFF                      = 0x7006
 	RTC_PIE_ON                       = 0x7005
 	RTC_PLL_GET                      = 0x80207011
@@ -390,6 +392,7 @@ const (
 	SO_RCVTIMEO                      = 0x14
 	SO_RCVTIMEO_NEW                  = 0x42
 	SO_RCVTIMEO_OLD                  = 0x14
+	SO_RESERVE_MEM                   = 0x49
 	SO_REUSEADDR                     = 0x2
 	SO_REUSEPORT                     = 0xf
 	SO_RXQ_OVFL                      = 0x28

vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go

@@ -304,6 +304,8 @@ const (
 	RTC_EPOCH_SET                    = 0x8008700e
 	RTC_IRQP_READ                    = 0x4008700b
 	RTC_IRQP_SET                     = 0x8008700c
+	RTC_PARAM_GET                    = 0x80187013
+	RTC_PARAM_SET                    = 0x80187014
 	RTC_PIE_OFF                      = 0x20007006
 	RTC_PIE_ON                       = 0x20007005
 	RTC_PLL_GET                      = 0x40207011
@@ -381,6 +383,7 @@ const (
 	SO_RCVTIMEO                      = 0x2000
 	SO_RCVTIMEO_NEW                  = 0x44
 	SO_RCVTIMEO_OLD                  = 0x2000
+	SO_RESERVE_MEM                   = 0x52
 	SO_REUSEADDR                     = 0x4
 	SO_REUSEPORT                     = 0x200
 	SO_RXQ_OVFL                      = 0x24

vendor/golang.org/x/sys/unix/zsysnum_linux_386.go

@@ -445,4 +445,5 @@ const (
 	SYS_LANDLOCK_RESTRICT_SELF       = 446
 	SYS_MEMFD_SECRET                 = 447
 	SYS_PROCESS_MRELEASE             = 448
+	SYS_FUTEX_WAITV                  = 449
 )

vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go

@@ -367,4 +367,5 @@ const (
 	SYS_LANDLOCK_RESTRICT_SELF  = 446
 	SYS_MEMFD_SECRET            = 447
 	SYS_PROCESS_MRELEASE        = 448
+	SYS_FUTEX_WAITV             = 449
 )

vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go

@@ -409,4 +409,5 @@ const (
 	SYS_LANDLOCK_ADD_RULE            = 445
 	SYS_LANDLOCK_RESTRICT_SELF       = 446
 	SYS_PROCESS_MRELEASE             = 448
+	SYS_FUTEX_WAITV                  = 449
 )

vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go

@@ -312,4 +312,5 @@ const (
 	SYS_LANDLOCK_RESTRICT_SELF  = 446
 	SYS_MEMFD_SECRET            = 447
 	SYS_PROCESS_MRELEASE        = 448
+	SYS_FUTEX_WAITV             = 449
 )

vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go

@@ -429,4 +429,5 @@ const (
 	SYS_LANDLOCK_ADD_RULE            = 4445
 	SYS_LANDLOCK_RESTRICT_SELF       = 4446
 	SYS_PROCESS_MRELEASE             = 4448
+	SYS_FUTEX_WAITV                  = 4449
 )

vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go

@@ -359,4 +359,5 @@ const (
 	SYS_LANDLOCK_ADD_RULE       = 5445
 	SYS_LANDLOCK_RESTRICT_SELF  = 5446
 	SYS_PROCESS_MRELEASE        = 5448
+	SYS_FUTEX_WAITV             = 5449
 )

vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go

@@ -359,4 +359,5 @@ const (
 	SYS_LANDLOCK_ADD_RULE       = 5445
 	SYS_LANDLOCK_RESTRICT_SELF  = 5446
 	SYS_PROCESS_MRELEASE        = 5448
+	SYS_FUTEX_WAITV             = 5449
 )

vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go

@@ -429,4 +429,5 @@ const (
 	SYS_LANDLOCK_ADD_RULE            = 4445
 	SYS_LANDLOCK_RESTRICT_SELF       = 4446
 	SYS_PROCESS_MRELEASE             = 4448
+	SYS_FUTEX_WAITV                  = 4449
 )

vendor/golang.org/x/sys/unix/zsysnum_linux_ppc.go

@@ -436,4 +436,5 @@ const (
 	SYS_LANDLOCK_ADD_RULE            = 445
 	SYS_LANDLOCK_RESTRICT_SELF       = 446
 	SYS_PROCESS_MRELEASE             = 448
+	SYS_FUTEX_WAITV                  = 449
 )

vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go

@@ -408,4 +408,5 @@ const (
 	SYS_LANDLOCK_ADD_RULE       = 445
 	SYS_LANDLOCK_RESTRICT_SELF  = 446
 	SYS_PROCESS_MRELEASE        = 448
+	SYS_FUTEX_WAITV             = 449
 )

vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go

@@ -408,4 +408,5 @@ const (
 	SYS_LANDLOCK_ADD_RULE       = 445
 	SYS_LANDLOCK_RESTRICT_SELF  = 446
 	SYS_PROCESS_MRELEASE        = 448
+	SYS_FUTEX_WAITV             = 449
 )

vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go

@@ -310,4 +310,5 @@ const (
 	SYS_LANDLOCK_ADD_RULE       = 445
 	SYS_LANDLOCK_RESTRICT_SELF  = 446
 	SYS_PROCESS_MRELEASE        = 448
+	SYS_FUTEX_WAITV             = 449
 )

vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go

@@ -373,4 +373,5 @@ const (
 	SYS_LANDLOCK_ADD_RULE       = 445
 	SYS_LANDLOCK_RESTRICT_SELF  = 446
 	SYS_PROCESS_MRELEASE        = 448
+	SYS_FUTEX_WAITV             = 449
 )

vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go

@@ -387,4 +387,5 @@ const (
 	SYS_LANDLOCK_ADD_RULE       = 445
 	SYS_LANDLOCK_RESTRICT_SELF  = 446
 	SYS_PROCESS_MRELEASE        = 448
+	SYS_FUTEX_WAITV             = 449
 )

vendor/golang.org/x/sys/unix/ztypes_linux.go

@@ -867,6 +867,7 @@ const (
 	CTRL_CMD_NEWMCAST_GRP      = 0x7
 	CTRL_CMD_DELMCAST_GRP      = 0x8
 	CTRL_CMD_GETMCAST_GRP      = 0x9
+	CTRL_CMD_GETPOLICY         = 0xa
 	CTRL_ATTR_UNSPEC           = 0x0
 	CTRL_ATTR_FAMILY_ID        = 0x1
 	CTRL_ATTR_FAMILY_NAME      = 0x2
@@ -875,12 +876,19 @@ const (
 	CTRL_ATTR_MAXATTR          = 0x5
 	CTRL_ATTR_OPS              = 0x6
 	CTRL_ATTR_MCAST_GROUPS     = 0x7
+	CTRL_ATTR_POLICY           = 0x8
+	CTRL_ATTR_OP_POLICY        = 0x9
+	CTRL_ATTR_OP               = 0xa
 	CTRL_ATTR_OP_UNSPEC        = 0x0
 	CTRL_ATTR_OP_ID            = 0x1
 	CTRL_ATTR_OP_FLAGS         = 0x2
 	CTRL_ATTR_MCAST_GRP_UNSPEC = 0x0
 	CTRL_ATTR_MCAST_GRP_NAME   = 0x1
 	CTRL_ATTR_MCAST_GRP_ID     = 0x2
+	CTRL_ATTR_POLICY_UNSPEC    = 0x0
+	CTRL_ATTR_POLICY_DO        = 0x1
+	CTRL_ATTR_POLICY_DUMP      = 0x2
+	CTRL_ATTR_POLICY_DUMP_MAX  = 0x2
 )
 
 const (
@@ -1136,7 +1144,8 @@ const (
 	PERF_RECORD_BPF_EVENT                 = 0x12
 	PERF_RECORD_CGROUP                    = 0x13
 	PERF_RECORD_TEXT_POKE                 = 0x14
-	PERF_RECORD_MAX                       = 0x15
+	PERF_RECORD_AUX_OUTPUT_HW_ID          = 0x15
+	PERF_RECORD_MAX                       = 0x16
 	PERF_RECORD_KSYMBOL_TYPE_UNKNOWN      = 0x0
 	PERF_RECORD_KSYMBOL_TYPE_BPF          = 0x1
 	PERF_RECORD_KSYMBOL_TYPE_OOL          = 0x2
@@ -1776,7 +1785,8 @@ const (
 
 const (
 	NF_NETDEV_INGRESS  = 0x0
-	NF_NETDEV_NUMHOOKS = 0x1
+	NF_NETDEV_EGRESS   = 0x1
+	NF_NETDEV_NUMHOOKS = 0x2
 )
 
 const (
@@ -3158,7 +3168,13 @@ const (
 	DEVLINK_ATTR_RELOAD_ACTION_INFO                    = 0xa2
 	DEVLINK_ATTR_RELOAD_ACTION_STATS                   = 0xa3
 	DEVLINK_ATTR_PORT_PCI_SF_NUMBER                    = 0xa4
-	DEVLINK_ATTR_MAX                                   = 0xa9
+	DEVLINK_ATTR_RATE_TYPE                             = 0xa5
+	DEVLINK_ATTR_RATE_TX_SHARE                         = 0xa6
+	DEVLINK_ATTR_RATE_TX_MAX                           = 0xa7
+	DEVLINK_ATTR_RATE_NODE_NAME                        = 0xa8
+	DEVLINK_ATTR_RATE_PARENT_NODE_NAME                 = 0xa9
+	DEVLINK_ATTR_REGION_MAX_SNAPSHOTS                  = 0xaa
+	DEVLINK_ATTR_MAX                                   = 0xaa
 	DEVLINK_DPIPE_FIELD_MAPPING_TYPE_NONE              = 0x0
 	DEVLINK_DPIPE_FIELD_MAPPING_TYPE_IFINDEX           = 0x1
 	DEVLINK_DPIPE_MATCH_TYPE_FIELD_EXACT               = 0x0
@@ -3455,7 +3471,14 @@ const (
 	ETHTOOL_MSG_CABLE_TEST_ACT                = 0x1a
 	ETHTOOL_MSG_CABLE_TEST_TDR_ACT            = 0x1b
 	ETHTOOL_MSG_TUNNEL_INFO_GET               = 0x1c
-	ETHTOOL_MSG_USER_MAX                      = 0x21
+	ETHTOOL_MSG_FEC_GET                       = 0x1d
+	ETHTOOL_MSG_FEC_SET                       = 0x1e
+	ETHTOOL_MSG_MODULE_EEPROM_GET             = 0x1f
+	ETHTOOL_MSG_STATS_GET                     = 0x20
+	ETHTOOL_MSG_PHC_VCLOCKS_GET               = 0x21
+	ETHTOOL_MSG_MODULE_GET                    = 0x22
+	ETHTOOL_MSG_MODULE_SET                    = 0x23
+	ETHTOOL_MSG_USER_MAX                      = 0x23
 	ETHTOOL_MSG_KERNEL_NONE                   = 0x0
 	ETHTOOL_MSG_STRSET_GET_REPLY              = 0x1
 	ETHTOOL_MSG_LINKINFO_GET_REPLY            = 0x2
@@ -3486,7 +3509,14 @@ const (
 	ETHTOOL_MSG_CABLE_TEST_NTF                = 0x1b
 	ETHTOOL_MSG_CABLE_TEST_TDR_NTF            = 0x1c
 	ETHTOOL_MSG_TUNNEL_INFO_GET_REPLY         = 0x1d
-	ETHTOOL_MSG_KERNEL_MAX                    = 0x22
+	ETHTOOL_MSG_FEC_GET_REPLY                 = 0x1e
+	ETHTOOL_MSG_FEC_NTF                       = 0x1f
+	ETHTOOL_MSG_MODULE_EEPROM_GET_REPLY       = 0x20
+	ETHTOOL_MSG_STATS_GET_REPLY               = 0x21
+	ETHTOOL_MSG_PHC_VCLOCKS_GET_REPLY         = 0x22
+	ETHTOOL_MSG_MODULE_GET_REPLY              = 0x23
+	ETHTOOL_MSG_MODULE_NTF                    = 0x24
+	ETHTOOL_MSG_KERNEL_MAX                    = 0x24
 	ETHTOOL_A_HEADER_UNSPEC                   = 0x0
 	ETHTOOL_A_HEADER_DEV_INDEX                = 0x1
 	ETHTOOL_A_HEADER_DEV_NAME                 = 0x2
@@ -3968,3 +3998,70 @@ type MountAttr struct {
 	Propagation uint64
 	Userns_fd   uint64
 }
+
+const (
+	WG_CMD_GET_DEVICE                      = 0x0
+	WG_CMD_SET_DEVICE                      = 0x1
+	WGDEVICE_F_REPLACE_PEERS               = 0x1
+	WGDEVICE_A_UNSPEC                      = 0x0
+	WGDEVICE_A_IFINDEX                     = 0x1
+	WGDEVICE_A_IFNAME                      = 0x2
+	WGDEVICE_A_PRIVATE_KEY                 = 0x3
+	WGDEVICE_A_PUBLIC_KEY                  = 0x4
+	WGDEVICE_A_FLAGS                       = 0x5
+	WGDEVICE_A_LISTEN_PORT                 = 0x6
+	WGDEVICE_A_FWMARK                      = 0x7
+	WGDEVICE_A_PEERS                       = 0x8
+	WGPEER_F_REMOVE_ME                     = 0x1
+	WGPEER_F_REPLACE_ALLOWEDIPS            = 0x2
+	WGPEER_F_UPDATE_ONLY                   = 0x4
+	WGPEER_A_UNSPEC                        = 0x0
+	WGPEER_A_PUBLIC_KEY                    = 0x1
+	WGPEER_A_PRESHARED_KEY                 = 0x2
+	WGPEER_A_FLAGS                         = 0x3
+	WGPEER_A_ENDPOINT                      = 0x4
+	WGPEER_A_PERSISTENT_KEEPALIVE_INTERVAL = 0x5
+	WGPEER_A_LAST_HANDSHAKE_TIME           = 0x6
+	WGPEER_A_RX_BYTES                      = 0x7
+	WGPEER_A_TX_BYTES                      = 0x8
+	WGPEER_A_ALLOWEDIPS                    = 0x9
+	WGPEER_A_PROTOCOL_VERSION              = 0xa
+	WGALLOWEDIP_A_UNSPEC                   = 0x0
+	WGALLOWEDIP_A_FAMILY                   = 0x1
+	WGALLOWEDIP_A_IPADDR                   = 0x2
+	WGALLOWEDIP_A_CIDR_MASK                = 0x3
+)
+
+const (
+	NL_ATTR_TYPE_INVALID      = 0x0
+	NL_ATTR_TYPE_FLAG         = 0x1
+	NL_ATTR_TYPE_U8           = 0x2
+	NL_ATTR_TYPE_U16          = 0x3
+	NL_ATTR_TYPE_U32          = 0x4
+	NL_ATTR_TYPE_U64          = 0x5
+	NL_ATTR_TYPE_S8           = 0x6
+	NL_ATTR_TYPE_S16          = 0x7
+	NL_ATTR_TYPE_S32          = 0x8
+	NL_ATTR_TYPE_S64          = 0x9
+	NL_ATTR_TYPE_BINARY       = 0xa
+	NL_ATTR_TYPE_STRING       = 0xb
+	NL_ATTR_TYPE_NUL_STRING   = 0xc
+	NL_ATTR_TYPE_NESTED       = 0xd
+	NL_ATTR_TYPE_NESTED_ARRAY = 0xe
+	NL_ATTR_TYPE_BITFIELD32   = 0xf
+
+	NL_POLICY_TYPE_ATTR_UNSPEC          = 0x0
+	NL_POLICY_TYPE_ATTR_TYPE            = 0x1
+	NL_POLICY_TYPE_ATTR_MIN_VALUE_S     = 0x2
+	NL_POLICY_TYPE_ATTR_MAX_VALUE_S     = 0x3
+	NL_POLICY_TYPE_ATTR_MIN_VALUE_U     = 0x4
+	NL_POLICY_TYPE_ATTR_MAX_VALUE_U     = 0x5
+	NL_POLICY_TYPE_ATTR_MIN_LENGTH      = 0x6
+	NL_POLICY_TYPE_ATTR_MAX_LENGTH      = 0x7
+	NL_POLICY_TYPE_ATTR_POLICY_IDX      = 0x8
+	NL_POLICY_TYPE_ATTR_POLICY_MAXTYPE  = 0x9
+	NL_POLICY_TYPE_ATTR_BITFIELD32_MASK = 0xa
+	NL_POLICY_TYPE_ATTR_PAD             = 0xb
+	NL_POLICY_TYPE_ATTR_MASK            = 0xc
+	NL_POLICY_TYPE_ATTR_MAX             = 0xc
+)

vendor/golang.org/x/sys/windows/exec_windows.go

@@ -9,8 +9,6 @@ package windows
 import (
 	errorspkg "errors"
 	"unsafe"
-
-	"golang.org/x/sys/internal/unsafeheader"
 )
 
 // EscapeArg rewrites command line argument s as prescribed
@@ -147,8 +145,12 @@ func NewProcThreadAttributeList(maxAttrCount uint32) (*ProcThreadAttributeListCo
 		}
 		return nil, err
 	}
+	alloc, err := LocalAlloc(LMEM_FIXED, uint32(size))
+	if err != nil {
+		return nil, err
+	}
 	// size is guaranteed to be ≥1 by InitializeProcThreadAttributeList.
-	al := &ProcThreadAttributeListContainer{data: (*ProcThreadAttributeList)(unsafe.Pointer(&make([]byte, size)[0]))}
+	al := &ProcThreadAttributeListContainer{data: (*ProcThreadAttributeList)(unsafe.Pointer(alloc))}
 	err = initializeProcThreadAttributeList(al.data, maxAttrCount, 0, &size)
 	if err != nil {
 		return nil, err
@@ -157,36 +159,17 @@ func NewProcThreadAttributeList(maxAttrCount uint32) (*ProcThreadAttributeListCo
 }
 
 // Update modifies the ProcThreadAttributeList using UpdateProcThreadAttribute.
-// Note that the value passed to this function will be copied into memory
-// allocated by LocalAlloc, the contents of which should not contain any
-// Go-managed pointers, even if the passed value itself is a Go-managed
-// pointer.
 func (al *ProcThreadAttributeListContainer) Update(attribute uintptr, value unsafe.Pointer, size uintptr) error {
-	alloc, err := LocalAlloc(LMEM_FIXED, uint32(size))
-	if err != nil {
-		return err
-	}
-	var src, dst []byte
-	hdr := (*unsafeheader.Slice)(unsafe.Pointer(&src))
-	hdr.Data = value
-	hdr.Cap = int(size)
-	hdr.Len = int(size)
-	hdr = (*unsafeheader.Slice)(unsafe.Pointer(&dst))
-	hdr.Data = unsafe.Pointer(alloc)
-	hdr.Cap = int(size)
-	hdr.Len = int(size)
-	copy(dst, src)
-	al.heapAllocations = append(al.heapAllocations, alloc)
-	return updateProcThreadAttribute(al.data, 0, attribute, unsafe.Pointer(alloc), size, nil, nil)
+	al.pointers = append(al.pointers, value)
+	return updateProcThreadAttribute(al.data, 0, attribute, value, size, nil, nil)
 }
 
 // Delete frees ProcThreadAttributeList's resources.
 func (al *ProcThreadAttributeListContainer) Delete() {
 	deleteProcThreadAttributeList(al.data)
-	for i := range al.heapAllocations {
-		LocalFree(Handle(al.heapAllocations[i]))
-	}
-	al.heapAllocations = nil
+	LocalFree(Handle(unsafe.Pointer(al.data)))
+	al.data = nil
+	al.pointers = nil
 }
 
 // List returns the actual ProcThreadAttributeList to be passed to StartupInfoEx.

vendor/golang.org/x/sys/windows/syscall_windows.go

@@ -363,6 +363,8 @@ func NewCallbackCDecl(fn interface{}) uintptr {
 //sys	SetProcessWorkingSetSizeEx(hProcess Handle, dwMinimumWorkingSetSize uintptr, dwMaximumWorkingSetSize uintptr, flags uint32) (err error)
 //sys	GetCommTimeouts(handle Handle, timeouts *CommTimeouts) (err error)
 //sys	SetCommTimeouts(handle Handle, timeouts *CommTimeouts) (err error)
+//sys	GetActiveProcessorCount(groupNumber uint16) (ret uint32)
+//sys	GetMaximumProcessorCount(groupNumber uint16) (ret uint32)
 
 // Volume Management Functions
 //sys	DefineDosDevice(flags uint32, deviceName *uint16, targetPath *uint16) (err error) = DefineDosDeviceW

vendor/golang.org/x/sys/windows/types_windows.go

@@ -938,8 +938,8 @@ type StartupInfoEx struct {
 type ProcThreadAttributeList struct{}
 
 type ProcThreadAttributeListContainer struct {
-	data            *ProcThreadAttributeList
-	heapAllocations []uintptr
+	data     *ProcThreadAttributeList
+	pointers []unsafe.Pointer
 }
 
 type ProcessInformation struct {
@@ -2749,6 +2749,43 @@ type PROCESS_BASIC_INFORMATION struct {
 	InheritedFromUniqueProcessId uintptr
 }
 
+type SYSTEM_PROCESS_INFORMATION struct {
+	NextEntryOffset              uint32
+	NumberOfThreads              uint32
+	WorkingSetPrivateSize        int64
+	HardFaultCount               uint32
+	NumberOfThreadsHighWatermark uint32
+	CycleTime                    uint64
+	CreateTime                   int64
+	UserTime                     int64
+	KernelTime                   int64
+	ImageName                    NTUnicodeString
+	BasePriority                 int32
+	UniqueProcessID              uintptr
+	InheritedFromUniqueProcessID uintptr
+	HandleCount                  uint32
+	SessionID                    uint32
+	UniqueProcessKey             *uint32
+	PeakVirtualSize              uintptr
+	VirtualSize                  uintptr
+	PageFaultCount               uint32
+	PeakWorkingSetSize           uintptr
+	WorkingSetSize               uintptr
+	QuotaPeakPagedPoolUsage      uintptr
+	QuotaPagedPoolUsage          uintptr
+	QuotaPeakNonPagedPoolUsage   uintptr
+	QuotaNonPagedPoolUsage       uintptr
+	PagefileUsage                uintptr
+	PeakPagefileUsage            uintptr
+	PrivatePageCount             uintptr
+	ReadOperationCount           int64
+	WriteOperationCount          int64
+	OtherOperationCount          int64
+	ReadTransferCount            int64
+	WriteTransferCount           int64
+	OtherTransferCount           int64
+}
+
 // SystemInformationClasses for NtQuerySystemInformation and NtSetSystemInformation
 const (
 	SystemBasicInformation = iota
@@ -3135,3 +3172,5 @@ type ModuleInfo struct {
 	SizeOfImage uint32
 	EntryPoint  uintptr
 }
+
+const ALL_PROCESSOR_GROUPS = 0xFFFF

vendor/golang.org/x/sys/windows/zsyscall_windows.go

@@ -226,6 +226,7 @@ var (
 	procFreeLibrary                                          = modkernel32.NewProc("FreeLibrary")
 	procGenerateConsoleCtrlEvent                             = modkernel32.NewProc("GenerateConsoleCtrlEvent")
 	procGetACP                                               = modkernel32.NewProc("GetACP")
+	procGetActiveProcessorCount                              = modkernel32.NewProc("GetActiveProcessorCount")
 	procGetCommTimeouts                                      = modkernel32.NewProc("GetCommTimeouts")
 	procGetCommandLineW                                      = modkernel32.NewProc("GetCommandLineW")
 	procGetComputerNameExW                                   = modkernel32.NewProc("GetComputerNameExW")
@@ -251,6 +252,7 @@ var (
 	procGetLogicalDriveStringsW                              = modkernel32.NewProc("GetLogicalDriveStringsW")
 	procGetLogicalDrives                                     = modkernel32.NewProc("GetLogicalDrives")
 	procGetLongPathNameW                                     = modkernel32.NewProc("GetLongPathNameW")
+	procGetMaximumProcessorCount                             = modkernel32.NewProc("GetMaximumProcessorCount")
 	procGetModuleFileNameW                                   = modkernel32.NewProc("GetModuleFileNameW")
 	procGetModuleHandleExW                                   = modkernel32.NewProc("GetModuleHandleExW")
 	procGetNamedPipeHandleStateW                             = modkernel32.NewProc("GetNamedPipeHandleStateW")
@@ -1967,6 +1969,12 @@ func GetACP() (acp uint32) {
 	return
 }
 
+func GetActiveProcessorCount(groupNumber uint16) (ret uint32) {
+	r0, _, _ := syscall.Syscall(procGetActiveProcessorCount.Addr(), 1, uintptr(groupNumber), 0, 0)
+	ret = uint32(r0)
+	return
+}
+
 func GetCommTimeouts(handle Handle, timeouts *CommTimeouts) (err error) {
 	r1, _, e1 := syscall.Syscall(procGetCommTimeouts.Addr(), 2, uintptr(handle), uintptr(unsafe.Pointer(timeouts)), 0)
 	if r1 == 0 {
@@ -2169,6 +2177,12 @@ func GetLongPathName(path *uint16, buf *uint16, buflen uint32) (n uint32, err er
 	return
 }
 
+func GetMaximumProcessorCount(groupNumber uint16) (ret uint32) {
+	r0, _, _ := syscall.Syscall(procGetMaximumProcessorCount.Addr(), 1, uintptr(groupNumber), 0, 0)
+	ret = uint32(r0)
+	return
+}
+
 func GetModuleFileName(module Handle, filename *uint16, size uint32) (n uint32, err error) {
 	r0, _, e1 := syscall.Syscall(procGetModuleFileNameW.Addr(), 3, uintptr(module), uintptr(unsafe.Pointer(filename)), uintptr(size))
 	n = uint32(r0)

vendor/modernc.org/cc/v3/Makefile

@@ -61,10 +61,13 @@ test_windows386:
 build_all_targets:
 	GOOS=darwin GOARCH=amd64 go build -v ./...
 	GOOS=darwin GOARCH=arm64 go build -v ./...
+	GOOS=freebsd GOARCH=amd64 go build -v ./...
+	GOOS=freebsd GOARCH=386 go build -v ./...
 	GOOS=linux GOARCH=386 go build -v ./...
 	GOOS=linux GOARCH=amd64 go build -v ./...
 	GOOS=linux GOARCH=arm go build -v ./...
 	GOOS=linux GOARCH=arm64 go build -v ./...
+	GOOS=netbsd GOARCH=amd64 go build -v ./...
 	GOOS=windows GOARCH=386 go build -v ./...
 	GOOS=windows GOARCH=amd64 go build -v ./...
 

vendor/modernc.org/cc/v3/abi_platforms.go

@@ -20,6 +20,7 @@ var (
 		{"darwin", "amd64"}:  true,
 		{"darwin", "arm64"}:  true,
 		{"freebsd", "amd64"}: true,
+		{"freebsd", "386"}:   true,
 		{"linux", "386"}:     true,
 		{"linux", "amd64"}:   true,
 		{"netbsd", "amd64"}:  true,
@@ -382,6 +383,41 @@ var abiTypes = map[[2]string]map[Kind]ABIType{
 		Int128:     {16, 16, 16},
 		UInt128:    {16, 16, 16},
 	},
+	// gcc (FreeBSD Ports Collection) 10.3.0
+	{"freebsd", "386"}: {
+		Void:       {1, 1, 1},
+		Bool:       {1, 1, 1},
+		Char:       {1, 1, 1},
+		SChar:      {1, 1, 1},
+		UChar:      {1, 1, 1},
+		Short:      {2, 2, 2},
+		UShort:     {2, 2, 2},
+		Enum:       {4, 4, 4},
+		Int:        {4, 4, 4},
+		UInt:       {4, 4, 4},
+		Long:       {4, 4, 4},
+		ULong:      {4, 4, 4},
+		LongLong:   {8, 4, 4},
+		ULongLong:  {8, 4, 4},
+		Ptr:        {4, 4, 4},
+		Function:   {4, 4, 4},
+		Float:      {4, 4, 4},
+		Double:     {8, 4, 4},
+		LongDouble: {12, 4, 4},
+		Int8:       {1, 1, 1},
+		UInt8:      {1, 1, 1},
+		Int16:      {2, 2, 2},
+		UInt16:     {2, 2, 2},
+		Int32:      {4, 4, 4},
+		UInt32:     {4, 4, 4},
+		Int64:      {8, 4, 4},
+		UInt64:     {8, 4, 4},
+		Float32:    {4, 4, 4},
+		Float32x:   {8, 4, 4},
+		Float64:    {8, 4, 4},
+		Float64x:   {16, 16, 16},
+		Float128:   {16, 16, 16},
+	},
 	// gcc (GCC) 8.4.0
 	{"openbsd", "amd64"}: {
 		Void:       {1, 1, 1},

vendor/modernc.org/cc/v3/ast.go

@@ -3527,6 +3527,7 @@ type PointerCase int
 const (
 	PointerTypeQual PointerCase = iota
 	PointerPtr
+	PointerBlock
 )
 
 // String implements fmt.Stringer
@@ -3536,6 +3537,8 @@ func (n PointerCase) String() string {
 		return "PointerTypeQual"
 	case PointerPtr:
 		return "PointerPtr"
+	case PointerBlock:
+		return "PointerBlock"
 	default:
 		return fmt.Sprintf("PointerCase(%v)", int(n))
 	}
@@ -3546,6 +3549,7 @@ func (n PointerCase) String() string {
 //	Pointer:
 //	        '*' TypeQualifiers          // Case PointerTypeQual
 //	|       '*' TypeQualifiers Pointer  // Case PointerPtr
+//	|       '^' TypeQualifiers          // Case PointerBlock
 type Pointer struct {
 	typeQualifiers *typeBase
 	Case           PointerCase `PrettyPrint:"stringer,zero"`
@@ -3564,7 +3568,7 @@ func (n *Pointer) Position() (r token.Position) {
 	}
 
 	switch n.Case {
-	case 0:
+	case 0, 2:
 		if p := n.Token.Position(); p.IsValid() {
 			return p
 		}

vendor/modernc.org/cc/v3/check.go

@@ -2093,6 +2093,8 @@ func (n *Pointer) check(ctx *context, typ Type) (t Type) {
 	case PointerPtr: // '*' TypeQualifiers Pointer
 		n.TypeQualifiers.check(ctx, &n.typeQualifiers)
 		typ = n.Pointer.check(ctx, typ)
+	case PointerBlock: // '^' TypeQualifiers
+		n.TypeQualifiers.check(ctx, &n.typeQualifiers)
 	default:
 		panic(todo(""))
 	}

vendor/modernc.org/cc/v3/cpp.go

@@ -143,6 +143,15 @@ func cppToksStr(toks []cppToken, sep string) string {
 	return b.String()
 }
 
+func cppToksStr2(toks [][]cppToken) string {
+	panic(todo(""))
+	var a []string
+	for _, v := range toks {
+		a = append(a, fmt.Sprintf("%q", cppToksStr(v, "|")))
+	}
+	return fmt.Sprint(a)
+}
+
 type cppReader struct {
 	buf []cppToken
 	ungetBuf
@@ -267,6 +276,10 @@ func (m *Macro) param2(varArgs []cppToken, ap [][]cppToken, nm StringID, out *[]
 }
 
 func (m *Macro) param(varArgs []cppToken, ap [][]cppToken, nm StringID, out *[]cppToken) bool {
+	// trc("select (A) varArgs %q, ap %v, nm %q, out %q", cppToksStr(varArgs, "|"), cppToksStr2(ap), nm, cppToksStr(*out, "|"))
+	// defer func() {
+	// 	trc("select (A) varArgs %q, ap %v, nm %q, out %q", cppToksStr(varArgs, "|"), cppToksStr2(ap), nm, cppToksStr(*out, "|"))
+	// }()
 	return m.param2(varArgs, ap, nm, out, nil)
 }
 
@@ -287,6 +300,7 @@ type cpp struct {
 	macros       map[StringID]*Macro
 	out          chan *[]token4
 	outBuf       *[]token4
+	pragmaOpBuf  []token4
 	rq           chan struct{}
 	timeMacro    Macro
 	ungetBuf
@@ -296,6 +310,7 @@ type cpp struct {
 	intmaxChecked bool
 	nonFirstRead  bool
 	seenEOF       bool
+	inPragmaOp    bool
 }
 
 func newCPP(ctx *context) *cpp {
@@ -408,87 +423,72 @@ func (c *cpp) write(tok cppToken) {
 
 	//dbg("%T.write %q", c, tok)
 	c.last = tok.char
-	*c.outBuf = append(*c.outBuf, tok.token4)
-	if tok.char == '\n' {
-		for i, tok := range *c.outBuf {
-			if tok.char != ' ' {
-				if tok.char == IDENTIFIER && tok.value == idPragmaOp {
-					toks := (*c.outBuf)[i:]
-					b := token4Pool.Get().(*[]token4)
-					*b = (*b)[:0]
-					c.outBuf = b
-					c.pragmaOp(toks)
-					return
-				}
-
+	switch {
+	case c.inPragmaOp:
+	out:
+		switch tok.char {
+		case ')':
+			c.inPragmaOp = false
+			b := c.pragmaOpBuf
+			if len(b) == 0 || b[0].char != '(' {
+				c.err(b[0], "expected (")
 				break
 			}
-		}
-		c.out <- c.outBuf
-		b := token4Pool.Get().(*[]token4)
-		*b = (*b)[:0]
-		c.outBuf = b
-	}
-}
 
-func (c *cpp) pragmaOp(toks []token4) {
-	var a []string
-loop:
-	for {
-		tok := toks[0]
-		toks = toks[1:] // Skip "_Pragma"
-		toks = ltrim4(toks)
-		if len(toks) == 0 || toks[0].char != '(' {
-			c.err(tok, "expected (")
-			break loop
-		}
+			var a []string
+			for _, v := range b[1:] {
+				if v.char != STRINGLITERAL {
+					c.err(v, "expected string literal")
+					break out
+				}
 
-		tok = toks[0]
-		toks = toks[1:] // Skip '('
-		toks = ltrim4(toks)
-		if len(toks) == 0 || (toks[0].char != STRINGLITERAL && toks[0].char != LONGSTRINGLITERAL) {
-			c.err(toks[0], "expected string literal")
-			break loop
-		}
+				a = append(a, v.String())
+			}
 
-		tok = toks[0]
-		a = append(a, tok.String())
-		toks = toks[1:] // Skip string literal
-		toks = ltrim4(toks)
-		if len(toks) == 0 || toks[0].char != ')' {
-			c.err(toks[0], "expected )")
-			break loop
-		}
+			if len(a) == 0 {
+				break
+			}
 
-		toks = toks[1:] // Skip ')'
-		toks = ltrim4(toks)
-		if len(toks) == 0 {
-			break loop
-		}
-
-		switch tok := toks[0]; {
-		case tok.char == '\n':
-			break loop
-		case tok.char == IDENTIFIER && tok.value == idPragmaOp:
-			// ok
+			for i, v := range a {
+				// [0], 6.10.9, 1
+				if v[0] == 'L' {
+					v = v[1:]
+				}
+				v = v[1 : len(v)-1]
+				v = strings.ReplaceAll(v, `\"`, `"`)
+				a[i] = "#pragma " + strings.ReplaceAll(v, `\\`, `\`) + "\n"
+			}
+			src := strings.Join(a, "")
+			s := newScanner0(c.ctx, strings.NewReader(src), tokenNewFile("", len(src)), 4096)
+			if ppf := s.translationPhase3(); ppf != nil {
+				ppf.translationPhase4(c)
+			}
 		default:
-			c.err(tok, "expected new-line")
-			break loop
+			c.pragmaOpBuf = append(c.pragmaOpBuf, tok.token4)
 		}
-	}
-	for i, v := range a {
-		// [0], 6.10.9, 1
-		if v[0] == 'L' {
-			v = v[1:]
+	default:
+		switch {
+		case tok.char == '\n':
+			*c.outBuf = append(*c.outBuf, tok.token4)
+			c.out <- c.outBuf
+			b := token4Pool.Get().(*[]token4)
+			*b = (*b)[:0]
+			c.outBuf = b
+		case tok.char == IDENTIFIER && tok.value == idPragmaOp:
+			if len(*c.outBuf) != 0 {
+				tok.char = '\n'
+				tok.value = 0
+				*c.outBuf = append(*c.outBuf, tok.token4)
+				c.out <- c.outBuf
+				b := token4Pool.Get().(*[]token4)
+				*b = (*b)[:0]
+				c.outBuf = b
+			}
+			c.inPragmaOp = true
+			c.pragmaOpBuf = c.pragmaOpBuf[:0]
+		default:
+			*c.outBuf = append(*c.outBuf, tok.token4)
 		}
-		v = v[1 : len(v)-1]
-		v = strings.ReplaceAll(v, `\"`, `"`)
-		a[i] = "#pragma " + strings.ReplaceAll(v, `\\`, `\`) + "\n"
-	}
-	src := strings.Join(a, "")
-	s := newScanner0(c.ctx, strings.NewReader(src), tokenNewFile("", len(src)), 4096)
-	if ppf := s.translationPhase3(); ppf != nil {
-		ppf.translationPhase4(c)
 	}
 }
 
@@ -531,7 +531,7 @@ func (c *cpp) writes(toks []cppToken) {
 // 	return T^HS • expand(TS’);
 // }
 func (c *cpp) expand(ts tokenReader, w tokenWriter, expandDefined bool) {
-	// dbg("==== expand enter")
+	// trc("==== expand enter")
 start:
 	tok, ok := ts.read()
 	tok.file = c.file
@@ -539,7 +539,7 @@ start:
 	if !ok {
 		// ---------------------------------------------------------- A
 		// return {};
-		// dbg("---- expand A")
+		// trc("---- expand A")
 		return
 	}
 
@@ -559,8 +559,8 @@ start:
 		if tok.has(nm) {
 			// -------------------------------------------------- B
 			// return T^HS • expand(TS’);
-			// dbg("---- expand B")
-			// dbg("expand write %q", tok)
+			// trc("---- expand B")
+			// trc("expand write %q", tok)
 			w.write(tok)
 			goto start
 		}
@@ -592,7 +592,7 @@ start:
 			if m != nil {
 				// -------------------------------------------------- C
 				// return expand(subst(ts(T), {}, {}, HS \cup {T}, {}) • TS’ );
-				// dbg("---- expand C")
+				// trc("---- expand C")
 				hs := hideSet{nm: {}}
 				for k, v := range tok.hs {
 					hs[k] = v
@@ -623,7 +623,7 @@ start:
 				// -------------------------------------------------- D
 				// check TS’ is actuals • )^HS’ • TS’’ and actuals are "correct for T"
 				// return expand(subst(ts(T), fp(T), actuals,(HS \cap HS’) \cup {T }, {}) • TS’’);
-				// dbg("---- expand D")
+				// trc("---- expand D")
 				hs := tok.hs
 				var skip []cppToken
 			again:
@@ -704,8 +704,8 @@ start:
 	// ------------------------------------------------------------------ E
 	// note TS must be T^HS • TS’
 	// return T^HS • expand(TS’);
-	// dbg("---- expand E")
-	// dbg("expand write %q", tok)
+	// trc("---- expand E")
+	// trc("expand write %q", tok)
 	w.write(tok)
 	goto start
 }
@@ -913,28 +913,28 @@ func (c *cpp) actuals(m *Macro, r tokenReader) (varArgs []cppToken, ap [][]cppTo
 // combinations. After the entire input sequence is finished, the updated hide
 // set is applied to the output sequence, and that is the result of subst.
 func (c *cpp) subst(m *Macro, is []cppToken, fp []StringID, varArgs []cppToken, ap [][]cppToken, hs hideSet, os *[]cppToken, expandDefined bool) (r []cppToken) {
-	// var a []string
-	// for _, v := range ap {
-	// 	a = append(a, fmt.Sprintf("%q", cppToksStr(v, "|")))
-	// }
-	// dbg("==== subst: is %q, fp %v ap %v", cppToksStr(is, "|"), fp, a)
+	var ap0 [][]cppToken
+	for _, v := range ap {
+		ap0 = append(ap0, append([]cppToken(nil), v...))
+	}
+	// trc("==== subst: is %q, fp, %v ap@%p %v", cppToksStr(is, "|"), fp, &ap, cppToksStr2(ap))
 start:
-	// dbg("start: %q", cppToksStr(is, "|"))
+	// trc("start: is %q, fp %v, ap@%p %v, os %q", cppToksStr(is, "|"), fp, &ap, cppToksStr2(ap), cppToksStr(*os, "|"))
 	if len(is) == 0 {
 		// ---------------------------------------------------------- A
 		// return hsadd(HS, OS);
-		// dbg("---- A")
-		// dbg("subst returns %q", cppToksStr(os, "|"))
+		// trc("---- A")
+		// trc("subst RETURNS %q", cppToksStr(*os, "|"))
 		return c.hsAdd(hs, os)
 	}
 
 	tok := is[0]
 	var arg []cppToken
 	if tok.char == '#' {
-		if len(is) > 1 && is[1].char == IDENTIFIER && m.param(varArgs, ap, is[1].value, &arg) {
+		if len(is) > 1 && is[1].char == IDENTIFIER && m.param(varArgs, ap0, is[1].value, &arg) {
 			// -------------------------------------------------- B
 			// return subst(IS’, FP, AP, HS, OS • stringize(select(i, AP)));
-			// dbg("---- subst B")
+			// trc("---- subst B")
 			*os = append(*os, c.stringize(arg))
 			is = is[2:]
 			goto start
@@ -942,14 +942,14 @@ start:
 	}
 
 	if tok.char == PPPASTE {
-		if len(is) > 1 && is[1].char == IDENTIFIER && m.param(varArgs, ap, is[1].value, &arg) {
+		if len(is) > 1 && is[1].char == IDENTIFIER && m.param(varArgs, ap0, is[1].value, &arg) {
 			// -------------------------------------------------- C
-			// dbg("---- subst C")
+			// trc("---- subst C")
 			if len(arg) == 0 {
 				// TODO "only if actuals can be empty"
 				// ------------------------------------------ D
 				// return subst(IS’, FP, AP, HS, OS);
-				// dbg("---- D")
+				// trc("---- D")
 				if c := len(*os); c != 0 && (*os)[c-1].char == ',' {
 					*os = (*os)[:c-1]
 				}
@@ -959,7 +959,7 @@ start:
 
 			// -------------------------------------------------- E
 			// return subst(IS’, FP, AP, HS, glue(OS, select(i, AP)));
-			// dbg("---- subst E")
+			// trc("---- subst E, arg %q", cppToksStr(arg, "|"))
 			*os = c.glue(*os, arg)
 			is = is[2:]
 			goto start
@@ -968,39 +968,39 @@ start:
 		if len(is) > 1 {
 			// -------------------------------------------------- F
 			// return subst(IS’, FP, AP, HS, glue(OS, T^HS’));
-			// dbg("---- subst F")
+			// trc("---- subst F")
 			*os = c.glue(*os, is[1:2])
 			is = is[2:]
 			goto start
 		}
 	}
 
-	if tok.char == IDENTIFIER && (len(is) > 1 && is[1].char == PPPASTE) && m.param(varArgs, ap, tok.value, &arg) {
+	if tok.char == IDENTIFIER && (len(is) > 1 && is[1].char == PPPASTE) && m.param(varArgs, ap0, tok.value, &arg) {
 		// ---------------------------------------------------------- G
-		// dbg("---- subst G")
+		// trc("---- subst G")
 		if len(arg) == 0 {
 			// TODO "only if actuals can be empty"
 			// -------------------------------------------------- H
-			// dbg("---- subst H")
+			// trc("---- subst H")
 			is = is[2:] // skip T##
 			if len(is) > 0 && is[0].char == IDENTIFIER && m.param(varArgs, ap, is[0].value, &arg) {
 				// -------------------------------------------------- I
 				// return subst(IS’’, FP, AP, HS, OS • select(j, AP));
-				// dbg("---- subst I")
+				// trc("---- subst I")
 				*os = append(*os, arg...)
 				is = is[1:]
 				goto start
 			} else {
 				// -------------------------------------------------- J
 				// return subst(IS’, FP, AP, HS, OS);
-				// dbg("---- subst J")
+				// trc("---- subst J")
 				goto start
 			}
 		}
 
 		// ---------------------------------------------------------- K
 		// return subst(##^HS’ • IS’, FP, AP, HS, OS • select(i, AP));
-		// dbg("---- subst K")
+		// trc("---- subst K")
 		*os = append(*os, arg...)
 		is = is[1:]
 		goto start
@@ -1010,7 +1010,7 @@ start:
 	if tok.char == IDENTIFIER && m.param2(varArgs, ap, tok.value, &arg, &ax) {
 		// ------------------------------------------ L
 		// return subst(IS’, FP, AP, HS, OS • expand(select(i, AP)));
-		// dbg("---- subst L")
+		// trc("---- subst L")
 		// if toks, ok := cache[tok.value]; ok {
 		// 	os = append(os, toks...)
 		// 	is = is[1:]
@@ -1019,7 +1019,9 @@ start:
 
 		sel := cppReader{buf: arg}
 		var w cppWriter
+		// trc("---- L(1) ap@%p %v", &ap, cppToksStr2(ap))
 		c.expand(&sel, &w, expandDefined)
+		// trc("---- L(2) ap@%p %v", &ap, cppToksStr2(ap))
 		*os = append(*os, w.toks...)
 		if ax >= 0 {
 			ap[ax] = w.toks
@@ -1031,9 +1033,9 @@ start:
 	// ------------------------------------------------------------------ M
 	// note IS must be T^HS’ • IS’
 	// return subst(IS’, FP, AP, HS, OS • T^HS’);
-	// dbg("---- subst M")
 	*os = append(*os, tok)
 	is = is[1:]
+	// trc("---- subst M: is %q, os %q", cppToksStr(is, "|"), cppToksStr(*os, "|"))
 	goto start
 }
 
@@ -1058,7 +1060,18 @@ start:
 // 43
 // 0
 // $
+//
+// ----------------------------------------------------------------------------
+//	glue(LS,RS ) /* paste last of left side with first of right side */
+//	{
+//		if LS is L^HS and RS is R^HS’ • RS’ then
+//			return L&R^(HS∩HS’) • RS’;	/* undefined if L&R is invalid */
+
+//		// note LS must be L HS • LS’
+//		return L^HS • glue(LS’,RS );
+//	}
 func (c *cpp) glue(ls, rs []cppToken) (out []cppToken) {
+	// trc("ls %q, rs %q", cppToksStr(ls, "|"), cppToksStr(rs, "|"))
 	if len(rs) == 0 {
 		return ls
 	}

vendor/modernc.org/cc/v3/parser.go

@@ -313,6 +313,7 @@ var (
 		dict.sid("__pragma_stdc"): PRAGMASTDC,
 		dict.sid("__restrict"):    RESTRICT,
 		dict.sid("__restrict__"):  RESTRICT,
+		dict.sid("__signed"):      SIGNED,
 		dict.sid("__signed__"):    SIGNED,
 		dict.sid("__thread"):      THREADLOCAL,
 		dict.sid("__typeof"):      TYPEOF,
@@ -2263,7 +2264,7 @@ func (p *parser) functionSpecifier(inline *bool) *FunctionSpecifier {
 //  declarator:
 // 	pointer_opt direct-declarator attribute-specifier-list_opt
 func (p *parser) declarator(declare, isTypedefName bool, ptr *Pointer) *Declarator {
-	if ptr == nil && p.rune() == '*' {
+	if ptr == nil && (p.rune() == '*' || p.rune() == '^') {
 		ptr = p.pointer()
 	}
 	r := &Declarator{IsTypedefName: isTypedefName, Pointer: ptr, DirectDeclarator: p.directDeclarator(nil)}
@@ -2488,9 +2489,21 @@ func (p *parser) directDeclarator(d *DirectDeclarator) (r *DirectDeclarator) {
 //  pointer:
 // 	* type-qualifier-list_opt
 // 	* type-qualifier-list_opt pointer
+//      ^ type-qualifier-list_opt
 func (p *parser) pointer() (r *Pointer) {
+	if p.rune() == '^' {
+		t := p.shift()
+		var list *TypeQualifiers
+		switch p.rune() {
+		case ATTRIBUTE, CONST, RESTRICT, VOLATILE, ATOMIC:
+			list = p.typeQualifierList()
+		}
+
+		return &Pointer{Case: PointerBlock, Token: t, TypeQualifiers: list}
+	}
+
 	if p.rune() != '*' {
-		p.err("expected *")
+		p.err("expected * or ^")
 		return nil
 	}
 
@@ -2608,7 +2621,8 @@ func (p *parser) parameterDeclaration() *ParameterDeclaration {
 
 func (p *parser) declaratorOrAbstractDeclarator(isTypedefName bool) (r Node) {
 	var ptr *Pointer
-	if p.rune() == '*' {
+	switch p.rune() {
+	case '*', '^':
 		ptr = p.pointer()
 	}
 	switch p.rune() {
@@ -2766,7 +2780,7 @@ func (p *parser) typeName() *TypeName {
 // 	pointer
 // 	pointer_opt direct-abstract-declarator
 func (p *parser) abstractDeclarator(ptr *Pointer) *AbstractDeclarator {
-	if ptr == nil && p.rune() == '*' {
+	if ptr == nil && (p.rune() == '*' || p.rune() == '^') {
 		ptr = p.pointer()
 	}
 	switch p.rune() {

vendor/modernc.org/cc/v3/parser.yy

@@ -688,6 +688,8 @@ package cc // import "modernc.org/cc/v3"
 				'*' TypeQualifiers
 			/*yy:example int **p; */
 /*yy:case Ptr        */ |	'*' TypeQualifiers Pointer
+			/*yy:example int atexit_b(void (^ _Nonnull)(void)); */
+/*yy:case Block      */ |	'^' TypeQualifiers
 
 			/*yy:field	noStorageClass */
 			/*yy:example int * const i; */

vendor/modernc.org/ccgo/v3/lib/Makefile

@@ -74,6 +74,7 @@ test_windows_amd64:
 build_all_targets:
 	GOOS=darwin GOARCH=amd64 go test -c -o /dev/null
 	GOOS=darwin GOARCH=arm64 go test -c -o /dev/null
+	GOOS=freebsd GOARCH=386 go test -c -o /dev/null
 	GOOS=freebsd GOARCH=amd64 go test -c -o /dev/null
 	GOOS=linux GOARCH=386 go test -c -o /dev/null
 	GOOS=linux GOARCH=amd64 go test -c -o /dev/null
@@ -81,6 +82,7 @@ build_all_targets:
 	GOOS=linux GOARCH=arm64 go test -c -o /dev/null
 	GOOS=linux GOARCH=s390x go test -c -o /dev/null
 	GOOS=netbsd GOARCH=amd64 go test -c -o /dev/null
+	GOOS=openbsd GOARCH=amd64 go test -c -o /dev/null
 	GOOS=windows GOARCH=386 go test -c -o /dev/null
 	GOOS=windows GOARCH=amd64 go test -c -o /dev/null
 

vendor/modernc.org/ccgo/v3/lib/ccgo.go

@@ -211,6 +211,7 @@ double __builtin_huge_val (void);
 double __builtin_inf (void);
 double __builtin_nan (const char *str);
 float __builtin_copysignf ( float x, float y );
+float __builtin_fabsf(float x);
 float __builtin_huge_valf (void);
 float __builtin_inff (void);
 float __builtin_nanf (const char *str);
@@ -221,6 +222,7 @@ int __builtin__snprintf_chk(char * str, size_t maxlen, int flag, size_t strlen,
 int __builtin_abs(int j);
 int __builtin_add_overflow();
 int __builtin_clz (unsigned);
+int __builtin_isunordered(double x, double y);
 int __builtin_clzl (unsigned long);
 int __builtin_clzll (unsigned long long);
 int __builtin_constant_p_impl(int, ...);
@@ -236,6 +238,7 @@ int __builtin_sprintf(char *str, const char *format, ...);
 int __builtin_strcmp(const char *s1, const char *s2);
 int __builtin_sub_overflow();
 long __builtin_expect (long exp, long c);
+long double __builtin_fabsl(long double x);
 long double __builtin_nanl (const char *str);
 long long __builtin_llabs(long long j);
 size_t __builtin_object_size (void * ptr, int type);
@@ -279,6 +282,10 @@ void __ccgo_va_start(__builtin_va_list ap);
 unsigned __sync_add_and_fetch_uint32(unsigned*, unsigned);
 unsigned __sync_sub_and_fetch_uint32(unsigned*, unsigned);
 
+#ifdef __APPLE__
+int (*__darwin_check_fd_set_overflow)(int, void *, int);
+#endif
+
 `
 	defaultCrt = "modernc.org/libc"
 )
@@ -1483,6 +1490,22 @@ out:
 		command = append([]string{sh, "-c"}, join(" ", command[0], "SHELL='sh -x'", command[1:]))
 		cmd = exec.Command(command[0], command[1:]...)
 		parser = makeXParser
+	case "openbsd":
+		switch command[0] {
+		case "make", "gmake":
+			// ok
+		default:
+			return fmt.Errorf("usupported build command: %s", command[0])
+		}
+
+		sh, err := exec.LookPath("sh")
+		if err != nil {
+			return err
+		}
+
+		command = append([]string{sh, "-c"}, join(" ", command[0], "SHELL='sh -x'", command[1:]))
+		cmd = exec.Command(command[0], command[1:]...)
+		parser = makeXParser2
 	case "windows":
 		if command[0] != "make" {
 			return fmt.Errorf("usupported build command: %s", command[0])
@@ -1573,7 +1596,7 @@ func isCreateArchive(s string) bool {
 	b := []byte(s)
 	sort.Slice(b, func(i, j int) bool { return b[i] < b[j] })
 	switch string(b) {
-	case "cq", "cr", "crs", "cru":
+	case "cq", "cr", "crs", "cru", "r":
 		return true
 	}
 	return false
@@ -1608,7 +1631,48 @@ func makeXParser(s string) (r []string, err error) {
 	}
 
 	s = s[1:]
+	if dmesgs {
+		dmesg("%v: source line `%s`, caller %v:", origin(1), s, origin(2))
+	}
 	r, err = shellquote.Split(s)
+	if dmesgs {
+		dmesg("%v: shellquote.Split -> %v %[2]q, %v", origin(1), r, err)
+	}
+	if err != nil {
+		if strings.Contains(err.Error(), "Unterminated single-quoted string") {
+			return nil, nil // ignore
+		}
+	}
+	if len(r) != 0 && filepath.Base(r[0]) == "libtool" {
+		r[0] = "libtool"
+	}
+	return r, err
+}
+
+func makeXParser2(s string) (r []string, err error) {
+	s = strings.TrimSpace(s)
+	switch {
+	case strings.HasPrefix(s, "libtool: link: ar "):
+		s = s[len("libtool: link:"):]
+	case strings.HasPrefix(s, "libtool: compile: "):
+		s = s[len("libtool: compile:"):]
+		for strings.HasPrefix(s, "  ") {
+			s = s[1:]
+		}
+	default:
+		var n int
+		if n, s = hasPlusPrefix(s); n != 0 {
+			return nil, nil
+		}
+	}
+
+	if dmesgs {
+		dmesg("%v: source line `%s`, caller %v:", origin(1), s, origin(2))
+	}
+	r, err = shellquote.Split(s)
+	if dmesgs {
+		dmesg("%v: shellquote.Split -> %v %[2]q, %v", origin(1), r, err)
+	}
 	if err != nil {
 		if strings.Contains(err.Error(), "Unterminated single-quoted string") {
 			return nil, nil // ignore
@@ -1802,26 +1866,29 @@ func (it *cdbItem) sources(cc, ar string) (r []string) {
 }
 
 type cdbMakeWriter struct {
-	b      bytes.Buffer
-	cc     string
 	ar     string
 	arBase string
+	b      bytes.Buffer
+	cc     string
 	dir    string
 	err    error
 	it     cdbItem
 	parser func(s string) ([]string, error)
+	prefix string
 	sc     *bufio.Scanner
+	t      *Task
 	w      *cdbWriter
 }
 
 func (t *Task) newCdbMakeWriter(w *cdbWriter, dir string, parser func(s string) ([]string, error)) *cdbMakeWriter {
 	const sz = 1 << 16
 	r := &cdbMakeWriter{
-		cc:     t.ccLookPath,
 		ar:     t.arLookPath,
 		arBase: filepath.Base(t.arLookPath),
+		cc:     t.ccLookPath,
 		dir:    dir,
 		parser: parser,
+		t:      t,
 		w:      w,
 	}
 	r.sc = bufio.NewScanner(&r.b)
@@ -1842,7 +1909,15 @@ func (w *cdbMakeWriter) Write(b []byte) (int, error) {
 			panic(todo("internal error"))
 		}
 
-		s := strings.TrimSpace(w.sc.Text())
+		s := w.sc.Text()
+		if strings.HasSuffix(s, "\\") {
+			w.prefix += s[:len(s)-1]
+			continue
+		}
+
+		s = w.prefix + s
+		w.prefix = ""
+		s = strings.TrimSpace(s)
 		if edx := strings.Index(s, "Entering directory"); edx >= 0 {
 			s = s[edx+len("Entering directory"):]
 			s = strings.TrimSpace(s)
@@ -1875,7 +1950,13 @@ func (w *cdbMakeWriter) Write(b []byte) (int, error) {
 			continue
 		}
 
+		if dmesgs {
+			dmesg("%v: source line `%s`", origin(1), s)
+		}
 		args, err := w.parser(s)
+		if dmesgs {
+			dmesg("%v: parser -> %v %[2]q, %v", origin(1), args, err)
+		}
 		if err != nil {
 			w.fail(err)
 			continue
@@ -1892,16 +1973,25 @@ func (w *cdbMakeWriter) Write(b []byte) (int, error) {
 		err = nil
 		switch args[0] {
 		case w.cc:
+			if w.t.verboseCompiledb {
+				fmt.Printf("source line: %q\n", s)
+			}
 			fmt.Printf("CCGO CC: %q\n", args)
 			err = w.handleGCC(args)
 		case w.ar:
 			fallthrough
 		case w.arBase:
 			if isCreateArchive(args[1]) {
+				if w.t.verboseCompiledb {
+					fmt.Printf("source line: %q\n", s)
+				}
 				fmt.Printf("CCGO AR: %q\n", args)
 				err = w.handleAR(args)
 			}
 		case "libtool":
+			if w.t.verboseCompiledb {
+				fmt.Printf("source line: %q\n", s)
+			}
 			fmt.Printf("CCGO LIBTOOL: %q\n", args)
 			err = w.handleLibtool(args)
 		}

vendor/modernc.org/ccgo/v3/lib/dmesg.go

@@ -32,7 +32,8 @@ func dmesg(s string, args ...interface{}) {
 	if s == "" {
 		s = strings.Repeat("%v ", len(args))
 	}
-	s = fmt.Sprintf(pid+s, args...)
+	s = fmt.Sprintf(s, args...)
+	s = pid + s
 	switch {
 	case len(s) != 0 && s[len(s)-1] == '\n':
 		fmt.Fprint(logf, s)

vendor/modernc.org/ccgo/v3/lib/go.go

@@ -3117,6 +3117,9 @@ func (p *project) declaratorDecay(n cc.Node, f *function, d *cc.Declarator, t cc
 				return
 			}
 
+			if !local.isPinned {
+				p.err(n, "%v: %v: missed pinning", n.Position(), d.Position(), d.Name())
+			}
 			p.w("(%s%s)/* &%s[0] */", f.bpName, nonZeroUintptr(local.off), local.name)
 			return
 		}
@@ -3663,7 +3666,7 @@ func (p *project) declaratorAddrOfNormal(n cc.Node, f *function, d *cc.Declarato
 		x.used = true
 		p.w("uintptr(unsafe.Pointer(&%sX%s))", x.qualifier, d.Name())
 	default:
-		panic(todo("%v: %v: %q %T", n.Position(), p.pos(d), d.Name(), x))
+		p.err(n, "undefined: %s", d.Name())
 	}
 }
 
@@ -8135,6 +8138,11 @@ func (p *project) castExpressionValue(f *function, n *cc.CastExpression, t cc.Ty
 	case cc.CastExpressionUnary: // UnaryExpression
 		p.unaryExpression(f, n.UnaryExpression, t, mode, flags)
 	case cc.CastExpressionCast: // '(' TypeName ')' CastExpression
+		if f != nil && p.pass1 && n.TypeName.Type().IsIntegerType() && n.CastExpression.Operand.Type().Kind() == cc.Array {
+			if d := n.CastExpression.Declarator(); d != nil {
+				f.pin(n, d)
+			}
+		}
 		switch k := p.opKind(f, n.CastExpression, n.CastExpression.Operand.Type()); k {
 		case opNormal, opBitfield:
 			p.castExpressionValueNormal(f, n, t, mode, flags)
@@ -8168,8 +8176,12 @@ func (p *project) castExpressionValueFunction(f *function, n *cc.CastExpression,
 		switch {
 		case tn.Kind() == cc.Ptr && t.Kind() == cc.Ptr:
 			p.castExpression(f, n.CastExpression, op.Type(), exprValue, flags)
+		case tn.IsIntegerType():
+			p.w("%s(", p.typ(n, tn))
+			p.castExpression(f, n.CastExpression, op.Type(), exprValue, flags)
+			p.w(")")
 		default:
-			panic(todo("", n.Position()))
+			panic(todo("%v: tn %v expr %v", n.Position(), tn, op.Type()))
 		}
 	default:
 		panic(todo("%v: %v -> %v -> %v", p.pos(n), op.Type(), tn, t))
@@ -12557,7 +12569,7 @@ func (p *project) iterationStatement(f *function, n *cc.IterationStatement) {
 			break
 		}
 
-		v := "ok"
+		v := "__ccgo"
 		if !p.pass1 {
 			v = f.scope.take(cc.String(v))
 		}

vendor/modernc.org/libc/Makefile

@@ -25,6 +25,7 @@ all:
 	go test 2>&1 -timeout 1h | tee -a $(log)
 	GOOS=darwin GOARCH=amd64 go build
 	GOOS=darwin GOARCH=arm64 go build
+	GOOS=freebsd GOARCH=386 go build
 	GOOS=freebsd GOARCH=amd64 go build
 	GOOS=linux GOARCH=386 go build
 	GOOS=linux GOARCH=amd64 go build
@@ -32,6 +33,7 @@ all:
 	GOOS=linux GOARCH=arm64 go build
 	GOOS=linux GOARCH=s390x go build
 	GOOS=netbsd GOARCH=amd64 go build
+	GOOS=openbsd GOARCH=amd64 go build
 	GOOS=windows GOARCH=386 go build
 	GOOS=windows GOARCH=amd64 go build
 	go vet -unsafeptr=false 2>&1 | grep -v $(ngrep) || true
@@ -60,6 +62,12 @@ freebsd_amd64:
 	go generate 2>&1 | tee log-generate
 	go build -v ./...
 
+# only on freebsd/386
+freebsd_386:
+	@echo "Should be executed only on freebsd/386."
+	go generate 2>&1 | tee log-generate
+	go build -v ./...
+
 # only on netbsd/amd64
 netbsd_amd64:
 	@echo "Should be executed only on netbsd/amd64."
@@ -87,6 +95,12 @@ linux_s390x:
 	CCGO_CPP=s390x-linux-gnu-cpp TARGET_GOOS=linux TARGET_GOARCH=s390x go generate
 	GOOS=linux GOARCH=s390x go build -v ./...
 
+# only on openbsd/amd64
+openbsd_amd64:
+	@echo "Should be executed only on openbsd/amd64."
+	go generate 2>&1 | tee log-generate
+	go build -v ./...
+
 windows_amd64:
 	@echo "Should be executed only on windows/amd64."
 	go generate 2>&1 | tee log-generate
@@ -105,6 +119,8 @@ build_all_targets:
 	GOOS=darwin GOARCH=amd64 go test -c -o /dev/null
 	GOOS=darwin GOARCH=arm64 go build -v ./...
 	GOOS=darwin GOARCH=arm64 go test -c -o /dev/null
+	GOOS=freebsd GOARCH=386 go build -v ./...
+	GOOS=freebsd GOARCH=386 go test -c -o /dev/null
 	GOOS=freebsd GOARCH=amd64 go build -v ./...
 	GOOS=freebsd GOARCH=amd64 go test -c -o /dev/null
 	GOOS=linux GOARCH=386 go build -v ./...
@@ -119,6 +135,8 @@ build_all_targets:
 	GOOS=linux GOARCH=s390x go test -c -o /dev/null
 	GOOS=netbsd GOARCH=amd64 go build -v ./...
 	GOOS=netbsd GOARCH=amd64 go test -c -o /dev/null
+	GOOS=openbsd GOARCH=amd64 go build -v ./...
+	GOOS=openbsd GOARCH=amd64 go test -c -o /dev/null
 	GOOS=windows GOARCH=386 go build -v ./...
 	GOOS=windows GOARCH=386 go test -c -o /dev/null
 	GOOS=windows GOARCH=amd64 go build -v ./...

vendor/modernc.org/libc/capi_darwin_amd64.go

@@ -3,6 +3,8 @@
 package libc // import "modernc.org/libc"
 
 var CAPI = map[string]struct{}{
+	"_CurrentRuneLocale":               {},
+	"_DefaultRuneLocale":               {},
 	"_IO_putc":                         {},
 	"_NSGetEnviron":                    {},
 	"___errno_location":                {},
@@ -36,6 +38,8 @@ var CAPI = map[string]struct{}{
 	"__builtin_exit":                   {},
 	"__builtin_expect":                 {},
 	"__builtin_fabs":                   {},
+	"__builtin_fabsf":                  {},
+	"__builtin_fabsl":                  {},
 	"__builtin_free":                   {},
 	"__builtin_getentropy":             {},
 	"__builtin_huge_val":               {},
@@ -44,6 +48,7 @@ var CAPI = map[string]struct{}{
 	"__builtin_inff":                   {},
 	"__builtin_infl":                   {},
 	"__builtin_isnan":                  {},
+	"__builtin_isunordered":            {},
 	"__builtin_malloc":                 {},
 	"__builtin_memcmp":                 {},
 	"__builtin_memcpy":                 {},
@@ -77,6 +82,7 @@ var CAPI = map[string]struct{}{
 	"__ccgo_sqlite3_log":               {},
 	"__cmsg_nxthdr":                    {},
 	"__ctype_get_mb_cur_max":           {},
+	"__darwin_check_fd_set_overflow":   {},
 	"__darwin_fd_clr":                  {},
 	"__darwin_fd_isset":                {},
 	"__darwin_fd_set":                  {},
@@ -93,33 +99,37 @@ var CAPI = map[string]struct{}{
 	"__inline_isnanf":                  {},
 	"__inline_isnanl":                  {},
 	"__intscan":                        {},
-	"__isalnum_l":                      {},
-	"__isalpha_l":                      {},
-	"__isdigit_l":                      {},
-	"__islower_l":                      {},
+	"__isctype":                        {},
 	"__isnan":                          {},
 	"__isnanf":                         {},
 	"__isnanl":                         {},
 	"__isoc99_sscanf":                  {},
-	"__isprint_l":                      {},
-	"__isupper_l":                      {},
-	"__isxdigit_l":                     {},
+	"__istype":                         {},
 	"__lookup_ipliteral":               {},
 	"__lookup_name":                    {},
 	"__lookup_serv":                    {},
+	"__maskrune":                       {},
 	"__mb_cur_max":                     {},
 	"__putenv":                         {},
 	"__shgetc":                         {},
 	"__shlim":                          {},
+	"__sincos_stret":                   {},
+	"__sincosf_stret":                  {},
+	"__sincospi_stret":                 {},
+	"__sincospif_stret":                {},
 	"__stderrp":                        {},
 	"__stdinp":                         {},
 	"__stdoutp":                        {},
 	"__strchrnul":                      {},
+	"__strncasecmp_l":                  {},
 	"__sync_add_and_fetch_uint32":      {},
 	"__sync_sub_and_fetch_uint32":      {},
+	"__tolower":                        {},
 	"__toread":                         {},
 	"__toread_needs_stdio_exit":        {},
+	"__toupper":                        {},
 	"__uflow":                          {},
+	"__wcwidth":                        {},
 	"_exit":                            {},
 	"_longjmp":                         {},
 	"_obstack_begin":                   {},
@@ -143,6 +153,7 @@ var CAPI = map[string]struct{}{
 	"atoi":                             {},
 	"atol":                             {},
 	"bind":                             {},
+	"bsearch":                          {},
 	"bzero":                            {},
 	"calloc":                           {},
 	"ceil":                             {},
@@ -167,11 +178,15 @@ var CAPI = map[string]struct{}{
 	"cos":                              {},
 	"cosf":                             {},
 	"cosh":                             {},
+	"ctime":                            {},
+	"ctime_r":                          {},
+	"digittoint":                       {},
 	"dlclose":                          {},
 	"dlerror":                          {},
 	"dlopen":                           {},
 	"dlsym":                            {},
 	"dup2":                             {},
+	"endpwent":                         {},
 	"environ":                          {},
 	"exit":                             {},
 	"exp":                              {},
@@ -227,7 +242,9 @@ var CAPI = map[string]struct{}{
 	"geteuid":                          {},
 	"getgid":                           {},
 	"getgrgid":                         {},
+	"getgrgid_r":                       {},
 	"getgrnam":                         {},
+	"getgrnam_r":                       {},
 	"gethostbyaddr":                    {},
 	"gethostbyaddr_r":                  {},
 	"gethostbyname":                    {},
@@ -238,6 +255,7 @@ var CAPI = map[string]struct{}{
 	"getnameinfo":                      {},
 	"getpeername":                      {},
 	"getpid":                           {},
+	"getprogname":                      {},
 	"getpwnam":                         {},
 	"getpwnam_r":                       {},
 	"getpwuid":                         {},
@@ -258,19 +276,31 @@ var CAPI = map[string]struct{}{
 	"inet_ntoa":                        {},
 	"inet_ntop":                        {},
 	"inet_pton":                        {},
+	"initstate":                        {},
+	"initstate_r":                      {},
 	"ioctl":                            {},
 	"isalnum":                          {},
 	"isalpha":                          {},
 	"isascii":                          {},
 	"isatty":                           {},
+	"isblank":                          {},
+	"iscntrl":                          {},
 	"isdigit":                          {},
+	"isgraph":                          {},
+	"ishexnumber":                      {},
+	"isideogram":                       {},
 	"islower":                          {},
 	"isnan":                            {},
 	"isnanf":                           {},
 	"isnanl":                           {},
+	"isnumber":                         {},
+	"isphonogram":                      {},
 	"isprint":                          {},
+	"ispunct":                          {},
+	"isrune":                           {},
 	"issetugid":                        {},
 	"isspace":                          {},
+	"isspecial":                        {},
 	"isupper":                          {},
 	"iswalnum":                         {},
 	"iswspace":                         {},
@@ -279,6 +309,7 @@ var CAPI = map[string]struct{}{
 	"ldexp":                            {},
 	"link":                             {},
 	"listen":                           {},
+	"localeconv":                       {},
 	"localtime":                        {},
 	"localtime_r":                      {},
 	"log":                              {},
@@ -303,7 +334,9 @@ var CAPI = map[string]struct{}{
 	"mkdir":                            {},
 	"mkfifo":                           {},
 	"mknod":                            {},
+	"mkostemp":                         {},
 	"mkstemp":                          {},
+	"mkstemp64":                        {},
 	"mkstemps":                         {},
 	"mkstemps64":                       {},
 	"mktime":                           {},
@@ -370,6 +403,7 @@ var CAPI = map[string]struct{}{
 	"rand":                             {},
 	"rand_r":                           {},
 	"random":                           {},
+	"random_r":                         {},
 	"read":                             {},
 	"readdir":                          {},
 	"readlink":                         {},
@@ -401,6 +435,7 @@ var CAPI = map[string]struct{}{
 	"setlocale":                        {},
 	"setsid":                           {},
 	"setsockopt":                       {},
+	"setstate":                         {},
 	"setvbuf":                          {},
 	"shmat":                            {},
 	"shmctl":                           {},
@@ -433,9 +468,11 @@ var CAPI = map[string]struct{}{
 	"strcspn":                          {},
 	"strdup":                           {},
 	"strerror":                         {},
+	"strerror_r":                       {},
 	"strlcat":                          {},
 	"strlcpy":                          {},
 	"strlen":                           {},
+	"strncasecmp":                      {},
 	"strncat":                          {},
 	"strncmp":                          {},
 	"strncpy":                          {},
@@ -464,6 +501,7 @@ var CAPI = map[string]struct{}{
 	"tcsetattr":                        {},
 	"time":                             {},
 	"tmpfile":                          {},
+	"toascii":                          {},
 	"tolower":                          {},
 	"toupper":                          {},
 	"trunc":                            {},
@@ -477,6 +515,10 @@ var CAPI = map[string]struct{}{
 	"usleep":                           {},
 	"utime":                            {},
 	"utimes":                           {},
+	"uuid_copy":                        {},
+	"uuid_generate_random":             {},
+	"uuid_parse":                       {},
+	"uuid_unparse":                     {},
 	"vasprintf":                        {},
 	"vfprintf":                         {},
 	"vprintf":                          {},

vendor/modernc.org/libc/capi_darwin_arm64.go

@@ -3,6 +3,8 @@
 package libc // import "modernc.org/libc"
 
 var CAPI = map[string]struct{}{
+	"_CurrentRuneLocale":               {},
+	"_DefaultRuneLocale":               {},
 	"_IO_putc":                         {},
 	"_NSGetEnviron":                    {},
 	"___errno_location":                {},
@@ -36,6 +38,8 @@ var CAPI = map[string]struct{}{
 	"__builtin_exit":                   {},
 	"__builtin_expect":                 {},
 	"__builtin_fabs":                   {},
+	"__builtin_fabsf":                  {},
+	"__builtin_fabsl":                  {},
 	"__builtin_free":                   {},
 	"__builtin_getentropy":             {},
 	"__builtin_huge_val":               {},
@@ -44,6 +48,7 @@ var CAPI = map[string]struct{}{
 	"__builtin_inff":                   {},
 	"__builtin_infl":                   {},
 	"__builtin_isnan":                  {},
+	"__builtin_isunordered":            {},
 	"__builtin_malloc":                 {},
 	"__builtin_memcmp":                 {},
 	"__builtin_memcpy":                 {},
@@ -77,6 +82,7 @@ var CAPI = map[string]struct{}{
 	"__ccgo_sqlite3_log":               {},
 	"__cmsg_nxthdr":                    {},
 	"__ctype_get_mb_cur_max":           {},
+	"__darwin_check_fd_set_overflow":   {},
 	"__darwin_fd_clr":                  {},
 	"__darwin_fd_isset":                {},
 	"__darwin_fd_set":                  {},
@@ -93,33 +99,37 @@ var CAPI = map[string]struct{}{
 	"__inline_isnanf":                  {},
 	"__inline_isnanl":                  {},
 	"__intscan":                        {},
-	"__isalnum_l":                      {},
-	"__isalpha_l":                      {},
-	"__isdigit_l":                      {},
-	"__islower_l":                      {},
+	"__isctype":                        {},
 	"__isnan":                          {},
 	"__isnanf":                         {},
 	"__isnanl":                         {},
 	"__isoc99_sscanf":                  {},
-	"__isprint_l":                      {},
-	"__isupper_l":                      {},
-	"__isxdigit_l":                     {},
+	"__istype":                         {},
 	"__lookup_ipliteral":               {},
 	"__lookup_name":                    {},
 	"__lookup_serv":                    {},
+	"__maskrune":                       {},
 	"__mb_cur_max":                     {},
 	"__putenv":                         {},
 	"__shgetc":                         {},
 	"__shlim":                          {},
+	"__sincos_stret":                   {},
+	"__sincosf_stret":                  {},
+	"__sincospi_stret":                 {},
+	"__sincospif_stret":                {},
 	"__stderrp":                        {},
 	"__stdinp":                         {},
 	"__stdoutp":                        {},
 	"__strchrnul":                      {},
+	"__strncasecmp_l":                  {},
 	"__sync_add_and_fetch_uint32":      {},
 	"__sync_sub_and_fetch_uint32":      {},
+	"__tolower":                        {},
 	"__toread":                         {},
 	"__toread_needs_stdio_exit":        {},
+	"__toupper":                        {},
 	"__uflow":                          {},
+	"__wcwidth":                        {},
 	"_exit":                            {},
 	"_longjmp":                         {},
 	"_obstack_begin":                   {},
@@ -143,6 +153,7 @@ var CAPI = map[string]struct{}{
 	"atoi":                             {},
 	"atol":                             {},
 	"bind":                             {},
+	"bsearch":                          {},
 	"bzero":                            {},
 	"calloc":                           {},
 	"ceil":                             {},
@@ -167,11 +178,15 @@ var CAPI = map[string]struct{}{
 	"cos":                              {},
 	"cosf":                             {},
 	"cosh":                             {},
+	"ctime":                            {},
+	"ctime_r":                          {},
+	"digittoint":                       {},
 	"dlclose":                          {},
 	"dlerror":                          {},
 	"dlopen":                           {},
 	"dlsym":                            {},
 	"dup2":                             {},
+	"endpwent":                         {},
 	"environ":                          {},
 	"exit":                             {},
 	"exp":                              {},
@@ -240,6 +255,7 @@ var CAPI = map[string]struct{}{
 	"getnameinfo":                      {},
 	"getpeername":                      {},
 	"getpid":                           {},
+	"getprogname":                      {},
 	"getpwnam":                         {},
 	"getpwnam_r":                       {},
 	"getpwuid":                         {},
@@ -260,19 +276,31 @@ var CAPI = map[string]struct{}{
 	"inet_ntoa":                        {},
 	"inet_ntop":                        {},
 	"inet_pton":                        {},
+	"initstate":                        {},
+	"initstate_r":                      {},
 	"ioctl":                            {},
 	"isalnum":                          {},
 	"isalpha":                          {},
 	"isascii":                          {},
 	"isatty":                           {},
+	"isblank":                          {},
+	"iscntrl":                          {},
 	"isdigit":                          {},
+	"isgraph":                          {},
+	"ishexnumber":                      {},
+	"isideogram":                       {},
 	"islower":                          {},
 	"isnan":                            {},
 	"isnanf":                           {},
 	"isnanl":                           {},
+	"isnumber":                         {},
+	"isphonogram":                      {},
 	"isprint":                          {},
+	"ispunct":                          {},
+	"isrune":                           {},
 	"issetugid":                        {},
 	"isspace":                          {},
+	"isspecial":                        {},
 	"isupper":                          {},
 	"iswalnum":                         {},
 	"iswspace":                         {},
@@ -281,6 +309,7 @@ var CAPI = map[string]struct{}{
 	"ldexp":                            {},
 	"link":                             {},
 	"listen":                           {},
+	"localeconv":                       {},
 	"localtime":                        {},
 	"localtime_r":                      {},
 	"log":                              {},
@@ -305,7 +334,9 @@ var CAPI = map[string]struct{}{
 	"mkdir":                            {},
 	"mkfifo":                           {},
 	"mknod":                            {},
+	"mkostemp":                         {},
 	"mkstemp":                          {},
+	"mkstemp64":                        {},
 	"mkstemps":                         {},
 	"mkstemps64":                       {},
 	"mktime":                           {},
@@ -372,6 +403,7 @@ var CAPI = map[string]struct{}{
 	"rand":                             {},
 	"rand_r":                           {},
 	"random":                           {},
+	"random_r":                         {},
 	"read":                             {},
 	"readdir":                          {},
 	"readlink":                         {},
@@ -403,6 +435,7 @@ var CAPI = map[string]struct{}{
 	"setlocale":                        {},
 	"setsid":                           {},
 	"setsockopt":                       {},
+	"setstate":                         {},
 	"setvbuf":                          {},
 	"shmat":                            {},
 	"shmctl":                           {},
@@ -435,9 +468,11 @@ var CAPI = map[string]struct{}{
 	"strcspn":                          {},
 	"strdup":                           {},
 	"strerror":                         {},
+	"strerror_r":                       {},
 	"strlcat":                          {},
 	"strlcpy":                          {},
 	"strlen":                           {},
+	"strncasecmp":                      {},
 	"strncat":                          {},
 	"strncmp":                          {},
 	"strncpy":                          {},
@@ -466,6 +501,7 @@ var CAPI = map[string]struct{}{
 	"tcsetattr":                        {},
 	"time":                             {},
 	"tmpfile":                          {},
+	"toascii":                          {},
 	"tolower":                          {},
 	"toupper":                          {},
 	"trunc":                            {},
@@ -479,6 +515,10 @@ var CAPI = map[string]struct{}{
 	"usleep":                           {},
 	"utime":                            {},
 	"utimes":                           {},
+	"uuid_copy":                        {},
+	"uuid_generate_random":             {},
+	"uuid_parse":                       {},
+	"uuid_unparse":                     {},
 	"vasprintf":                        {},
 	"vfprintf":                         {},
 	"vprintf":                          {},

vendor/modernc.org/libc/capi_freebsd_386.go

@@ -0,0 +1,486 @@
+// Code generated by 'go generate' - DO NOT EDIT.
+
+package libc // import "modernc.org/libc"
+
+var CAPI = map[string]struct{}{
+	"_CurrentRuneLocale":               {},
+	"_DefaultRuneLocale":               {},
+	"_IO_putc":                         {},
+	"_ThreadRuneLocale":                {},
+	"___errno_location":                {},
+	"___runetype":                      {},
+	"__assert":                         {},
+	"__assert_fail":                    {},
+	"__builtin___memcpy_chk":           {},
+	"__builtin___memmove_chk":          {},
+	"__builtin___memset_chk":           {},
+	"__builtin___snprintf_chk":         {},
+	"__builtin___sprintf_chk":          {},
+	"__builtin___strcat_chk":           {},
+	"__builtin___strcpy_chk":           {},
+	"__builtin___strncpy_chk":          {},
+	"__builtin___vsnprintf_chk":        {},
+	"__builtin_abort":                  {},
+	"__builtin_abs":                    {},
+	"__builtin_add_overflowInt64":      {},
+	"__builtin_add_overflowUint32":     {},
+	"__builtin_add_overflowUint64":     {},
+	"__builtin_bswap16":                {},
+	"__builtin_bswap32":                {},
+	"__builtin_bswap64":                {},
+	"__builtin_bzero":                  {},
+	"__builtin_clz":                    {},
+	"__builtin_clzl":                   {},
+	"__builtin_clzll":                  {},
+	"__builtin_constant_p_impl":        {},
+	"__builtin_copysign":               {},
+	"__builtin_copysignf":              {},
+	"__builtin_copysignl":              {},
+	"__builtin_exit":                   {},
+	"__builtin_expect":                 {},
+	"__builtin_fabs":                   {},
+	"__builtin_fabsf":                  {},
+	"__builtin_fabsl":                  {},
+	"__builtin_free":                   {},
+	"__builtin_getentropy":             {},
+	"__builtin_huge_val":               {},
+	"__builtin_huge_valf":              {},
+	"__builtin_inf":                    {},
+	"__builtin_inff":                   {},
+	"__builtin_infl":                   {},
+	"__builtin_isnan":                  {},
+	"__builtin_isunordered":            {},
+	"__builtin_malloc":                 {},
+	"__builtin_memcmp":                 {},
+	"__builtin_memcpy":                 {},
+	"__builtin_memset":                 {},
+	"__builtin_mmap":                   {},
+	"__builtin_mul_overflowInt64":      {},
+	"__builtin_mul_overflowUint128":    {},
+	"__builtin_mul_overflowUint64":     {},
+	"__builtin_nan":                    {},
+	"__builtin_nanf":                   {},
+	"__builtin_nanl":                   {},
+	"__builtin_object_size":            {},
+	"__builtin_popcount":               {},
+	"__builtin_popcountl":              {},
+	"__builtin_prefetch":               {},
+	"__builtin_printf":                 {},
+	"__builtin_snprintf":               {},
+	"__builtin_sprintf":                {},
+	"__builtin_strchr":                 {},
+	"__builtin_strcmp":                 {},
+	"__builtin_strcpy":                 {},
+	"__builtin_strlen":                 {},
+	"__builtin_sub_overflowInt64":      {},
+	"__builtin_trap":                   {},
+	"__builtin_unreachable":            {},
+	"__ccgo_dmesg":                     {},
+	"__ccgo_getMutexType":              {},
+	"__ccgo_in6addr_anyp":              {},
+	"__ccgo_pthreadAttrGetDetachState": {},
+	"__ccgo_pthreadMutexattrGettype":   {},
+	"__ccgo_sqlite3_log":               {},
+	"__cmsg_nxthdr":                    {},
+	"__ctype_get_mb_cur_max":           {},
+	"__errno_location":                 {},
+	"__error":                          {},
+	"__floatscan":                      {},
+	"__h_errno_location":               {},
+	"__inet_aton":                      {},
+	"__inet_ntoa":                      {},
+	"__intscan":                        {},
+	"__isalnum_l":                      {},
+	"__isalpha_l":                      {},
+	"__isdigit_l":                      {},
+	"__isnan":                          {},
+	"__isnanf":                         {},
+	"__isnanl":                         {},
+	"__isoc99_sscanf":                  {},
+	"__isthreaded":                     {},
+	"__lookup_ipliteral":               {},
+	"__lookup_name":                    {},
+	"__lookup_serv":                    {},
+	"__mb_sb_limit":                    {},
+	"__runes_for_locale":               {},
+	"__shgetc":                         {},
+	"__shlim":                          {},
+	"__srget":                          {},
+	"__stderrp":                        {},
+	"__stdinp":                         {},
+	"__stdoutp":                        {},
+	"__swbuf":                          {},
+	"__sync_add_and_fetch_uint32":      {},
+	"__sync_sub_and_fetch_uint32":      {},
+	"__syscall1":                       {},
+	"__syscall3":                       {},
+	"__syscall4":                       {},
+	"__toread":                         {},
+	"__toread_needs_stdio_exit":        {},
+	"__uflow":                          {},
+	"__xuname":                         {},
+	"_exit":                            {},
+	"_longjmp":                         {},
+	"_obstack_begin":                   {},
+	"_obstack_newchunk":                {},
+	"_setjmp":                          {},
+	"abort":                            {},
+	"abs":                              {},
+	"accept":                           {},
+	"access":                           {},
+	"acos":                             {},
+	"acosh":                            {},
+	"alarm":                            {},
+	"asin":                             {},
+	"asinh":                            {},
+	"atan":                             {},
+	"atan2":                            {},
+	"atanh":                            {},
+	"atexit":                           {},
+	"atof":                             {},
+	"atoi":                             {},
+	"atol":                             {},
+	"backtrace":                        {},
+	"backtrace_symbols_fd":             {},
+	"bind":                             {},
+	"bzero":                            {},
+	"calloc":                           {},
+	"ceil":                             {},
+	"ceilf":                            {},
+	"cfgetospeed":                      {},
+	"cfsetispeed":                      {},
+	"cfsetospeed":                      {},
+	"chdir":                            {},
+	"chflags":                          {},
+	"chmod":                            {},
+	"chown":                            {},
+	"clock_gettime":                    {},
+	"close":                            {},
+	"closedir":                         {},
+	"confstr":                          {},
+	"connect":                          {},
+	"copysign":                         {},
+	"copysignf":                        {},
+	"copysignl":                        {},
+	"cos":                              {},
+	"cosf":                             {},
+	"cosh":                             {},
+	"ctime":                            {},
+	"ctime_r":                          {},
+	"dlclose":                          {},
+	"dlerror":                          {},
+	"dlopen":                           {},
+	"dlsym":                            {},
+	"dup2":                             {},
+	"endpwent":                         {},
+	"environ":                          {},
+	"execvp":                           {},
+	"exit":                             {},
+	"exp":                              {},
+	"fabs":                             {},
+	"fabsf":                            {},
+	"fabsl":                            {},
+	"fchmod":                           {},
+	"fchown":                           {},
+	"fclose":                           {},
+	"fcntl":                            {},
+	"fcntl64":                          {},
+	"fdopen":                           {},
+	"ferror":                           {},
+	"fflush":                           {},
+	"fgetc":                            {},
+	"fgets":                            {},
+	"fileno":                           {},
+	"floor":                            {},
+	"fmod":                             {},
+	"fmodl":                            {},
+	"fopen":                            {},
+	"fopen64":                          {},
+	"fork":                             {},
+	"fprintf":                          {},
+	"fputc":                            {},
+	"fputs":                            {},
+	"fread":                            {},
+	"free":                             {},
+	"freeaddrinfo":                     {},
+	"frexp":                            {},
+	"fscanf":                           {},
+	"fseek":                            {},
+	"fstat":                            {},
+	"fstat64":                          {},
+	"fsync":                            {},
+	"ftell":                            {},
+	"ftruncate":                        {},
+	"fts64_close":                      {},
+	"fts64_open":                       {},
+	"fts64_read":                       {},
+	"fts_close":                        {},
+	"fts_open":                         {},
+	"fts_read":                         {},
+	"fwrite":                           {},
+	"gai_strerror":                     {},
+	"getaddrinfo":                      {},
+	"getc":                             {},
+	"getcwd":                           {},
+	"getegid":                          {},
+	"getentropy":                       {},
+	"getenv":                           {},
+	"geteuid":                          {},
+	"getgid":                           {},
+	"getgrgid":                         {},
+	"getgrgid_r":                       {},
+	"getgrnam":                         {},
+	"getgrnam_r":                       {},
+	"gethostbyaddr":                    {},
+	"gethostbyaddr_r":                  {},
+	"gethostbyname":                    {},
+	"gethostbyname2":                   {},
+	"gethostbyname2_r":                 {},
+	"gethostname":                      {},
+	"getnameinfo":                      {},
+	"getpeername":                      {},
+	"getpid":                           {},
+	"getpwnam":                         {},
+	"getpwnam_r":                       {},
+	"getpwuid":                         {},
+	"getpwuid_r":                       {},
+	"getresgid":                        {},
+	"getresuid":                        {},
+	"getrlimit":                        {},
+	"getrlimit64":                      {},
+	"getrusage":                        {},
+	"getservbyname":                    {},
+	"getsockname":                      {},
+	"getsockopt":                       {},
+	"gettimeofday":                     {},
+	"getuid":                           {},
+	"gmtime_r":                         {},
+	"h_errno":                          {},
+	"htonl":                            {},
+	"htons":                            {},
+	"hypot":                            {},
+	"inet_ntoa":                        {},
+	"inet_ntop":                        {},
+	"inet_pton":                        {},
+	"initstate":                        {},
+	"initstate_r":                      {},
+	"ioctl":                            {},
+	"isalnum":                          {},
+	"isalpha":                          {},
+	"isascii":                          {},
+	"isatty":                           {},
+	"isdigit":                          {},
+	"isnan":                            {},
+	"isnanf":                           {},
+	"isnanl":                           {},
+	"kill":                             {},
+	"ldexp":                            {},
+	"link":                             {},
+	"listen":                           {},
+	"localtime":                        {},
+	"localtime_r":                      {},
+	"log":                              {},
+	"log10":                            {},
+	"longjmp":                          {},
+	"lrand48":                          {},
+	"lseek":                            {},
+	"lseek64":                          {},
+	"lstat":                            {},
+	"lstat64":                          {},
+	"malloc":                           {},
+	"mblen":                            {},
+	"mbstowcs":                         {},
+	"mbtowc":                           {},
+	"memchr":                           {},
+	"memcmp":                           {},
+	"memcpy":                           {},
+	"memmove":                          {},
+	"memset":                           {},
+	"mkdir":                            {},
+	"mkfifo":                           {},
+	"mknod":                            {},
+	"mkostemp":                         {},
+	"mkstemp":                          {},
+	"mkstemp64":                        {},
+	"mkstemps":                         {},
+	"mkstemps64":                       {},
+	"mktime":                           {},
+	"mmap":                             {},
+	"modf":                             {},
+	"munmap":                           {},
+	"nl_langinfo":                      {},
+	"ntohs":                            {},
+	"obstack_free":                     {},
+	"obstack_vprintf":                  {},
+	"open":                             {},
+	"open64":                           {},
+	"opendir":                          {},
+	"openpty":                          {},
+	"pathconf":                         {},
+	"pause":                            {},
+	"pclose":                           {},
+	"perror":                           {},
+	"pipe":                             {},
+	"poll":                             {},
+	"popen":                            {},
+	"pow":                              {},
+	"printf":                           {},
+	"pselect":                          {},
+	"pthread_attr_destroy":             {},
+	"pthread_attr_getdetachstate":      {},
+	"pthread_attr_init":                {},
+	"pthread_attr_setdetachstate":      {},
+	"pthread_attr_setscope":            {},
+	"pthread_attr_setstacksize":        {},
+	"pthread_cond_broadcast":           {},
+	"pthread_cond_destroy":             {},
+	"pthread_cond_init":                {},
+	"pthread_cond_signal":              {},
+	"pthread_cond_timedwait":           {},
+	"pthread_cond_wait":                {},
+	"pthread_create":                   {},
+	"pthread_detach":                   {},
+	"pthread_equal":                    {},
+	"pthread_exit":                     {},
+	"pthread_getspecific":              {},
+	"pthread_join":                     {},
+	"pthread_key_create":               {},
+	"pthread_key_delete":               {},
+	"pthread_mutex_destroy":            {},
+	"pthread_mutex_init":               {},
+	"pthread_mutex_lock":               {},
+	"pthread_mutex_trylock":            {},
+	"pthread_mutex_unlock":             {},
+	"pthread_mutexattr_destroy":        {},
+	"pthread_mutexattr_init":           {},
+	"pthread_mutexattr_settype":        {},
+	"pthread_self":                     {},
+	"pthread_setspecific":              {},
+	"putc":                             {},
+	"putchar":                          {},
+	"puts":                             {},
+	"qsort":                            {},
+	"raise":                            {},
+	"rand":                             {},
+	"random":                           {},
+	"random_r":                         {},
+	"read":                             {},
+	"readdir":                          {},
+	"readdir64":                        {},
+	"readlink":                         {},
+	"readv":                            {},
+	"realloc":                          {},
+	"reallocarray":                     {},
+	"realpath":                         {},
+	"recv":                             {},
+	"recvfrom":                         {},
+	"recvmsg":                          {},
+	"remove":                           {},
+	"rename":                           {},
+	"rewind":                           {},
+	"rindex":                           {},
+	"rint":                             {},
+	"rmdir":                            {},
+	"round":                            {},
+	"scalbn":                           {},
+	"scalbnl":                          {},
+	"sched_yield":                      {},
+	"select":                           {},
+	"send":                             {},
+	"sendmsg":                          {},
+	"sendto":                           {},
+	"setbuf":                           {},
+	"setenv":                           {},
+	"setjmp":                           {},
+	"setlocale":                        {},
+	"setrlimit":                        {},
+	"setrlimit64":                      {},
+	"setsid":                           {},
+	"setsockopt":                       {},
+	"setstate":                         {},
+	"setvbuf":                          {},
+	"shmat":                            {},
+	"shmctl":                           {},
+	"shmdt":                            {},
+	"shutdown":                         {},
+	"sigaction":                        {},
+	"signal":                           {},
+	"sin":                              {},
+	"sinf":                             {},
+	"sinh":                             {},
+	"sleep":                            {},
+	"snprintf":                         {},
+	"socket":                           {},
+	"sprintf":                          {},
+	"sqrt":                             {},
+	"srand48":                          {},
+	"sscanf":                           {},
+	"stat":                             {},
+	"stat64":                           {},
+	"stderr":                           {},
+	"stdin":                            {},
+	"stdout":                           {},
+	"strcasecmp":                       {},
+	"strcat":                           {},
+	"strchr":                           {},
+	"strcmp":                           {},
+	"strcpy":                           {},
+	"strcspn":                          {},
+	"strdup":                           {},
+	"strerror":                         {},
+	"strerror_r":                       {},
+	"strlen":                           {},
+	"strncmp":                          {},
+	"strncpy":                          {},
+	"strnlen":                          {},
+	"strpbrk":                          {},
+	"strrchr":                          {},
+	"strspn":                           {},
+	"strstr":                           {},
+	"strtod":                           {},
+	"strtof":                           {},
+	"strtoimax":                        {},
+	"strtol":                           {},
+	"strtold":                          {},
+	"strtoll":                          {},
+	"strtoul":                          {},
+	"strtoull":                         {},
+	"strtoumax":                        {},
+	"symlink":                          {},
+	"sysconf":                          {},
+	"system":                           {},
+	"tan":                              {},
+	"tanh":                             {},
+	"tcgetattr":                        {},
+	"tcsendbreak":                      {},
+	"tcsetattr":                        {},
+	"time":                             {},
+	"tmpfile":                          {},
+	"tolower":                          {},
+	"toupper":                          {},
+	"trunc":                            {},
+	"tzset":                            {},
+	"umask":                            {},
+	"uname":                            {},
+	"ungetc":                           {},
+	"unlink":                           {},
+	"unsetenv":                         {},
+	"usleep":                           {},
+	"utime":                            {},
+	"utimes":                           {},
+	"uuid_generate_random":             {},
+	"uuid_parse":                       {},
+	"uuid_unparse":                     {},
+	"vasprintf":                        {},
+	"vfprintf":                         {},
+	"vprintf":                          {},
+	"vsnprintf":                        {},
+	"vsprintf":                         {},
+	"waitpid":                          {},
+	"wcschr":                           {},
+	"wctomb":                           {},
+	"wcwidth":                          {},
+	"write":                            {},
+	"writev":                           {},
+	"zero_struct_address":              {},
+}

vendor/modernc.org/libc/capi_freebsd_amd64.go

@@ -39,6 +39,8 @@ var CAPI = map[string]struct{}{
 	"__builtin_exit":                   {},
 	"__builtin_expect":                 {},
 	"__builtin_fabs":                   {},
+	"__builtin_fabsf":                  {},
+	"__builtin_fabsl":                  {},
 	"__builtin_free":                   {},
 	"__builtin_getentropy":             {},
 	"__builtin_huge_val":               {},
@@ -47,6 +49,7 @@ var CAPI = map[string]struct{}{
 	"__builtin_inff":                   {},
 	"__builtin_infl":                   {},
 	"__builtin_isnan":                  {},
+	"__builtin_isunordered":            {},
 	"__builtin_malloc":                 {},
 	"__builtin_memcmp":                 {},
 	"__builtin_memcpy":                 {},
@@ -90,11 +93,16 @@ var CAPI = map[string]struct{}{
 	"__isalnum_l":                      {},
 	"__isalpha_l":                      {},
 	"__isdigit_l":                      {},
+	"__islower_l":                      {},
 	"__isnan":                          {},
 	"__isnanf":                         {},
 	"__isnanl":                         {},
 	"__isoc99_sscanf":                  {},
+	"__isprint_l":                      {},
+	"__isspace_l":                      {},
 	"__isthreaded":                     {},
+	"__isupper_l":                      {},
+	"__isxdigit_l":                     {},
 	"__lookup_ipliteral":               {},
 	"__lookup_name":                    {},
 	"__lookup_serv":                    {},
@@ -139,6 +147,7 @@ var CAPI = map[string]struct{}{
 	"backtrace":                        {},
 	"backtrace_symbols_fd":             {},
 	"bind":                             {},
+	"bsearch":                          {},
 	"bzero":                            {},
 	"calloc":                           {},
 	"ceil":                             {},
@@ -258,15 +267,22 @@ var CAPI = map[string]struct{}{
 	"inet_ntoa":                        {},
 	"inet_ntop":                        {},
 	"inet_pton":                        {},
+	"initstate":                        {},
+	"initstate_r":                      {},
 	"ioctl":                            {},
 	"isalnum":                          {},
 	"isalpha":                          {},
 	"isascii":                          {},
 	"isatty":                           {},
 	"isdigit":                          {},
+	"islower":                          {},
 	"isnan":                            {},
 	"isnanf":                           {},
 	"isnanl":                           {},
+	"isprint":                          {},
+	"isspace":                          {},
+	"isupper":                          {},
+	"isxdigit":                         {},
 	"kill":                             {},
 	"ldexp":                            {},
 	"link":                             {},
@@ -293,6 +309,7 @@ var CAPI = map[string]struct{}{
 	"mkdir":                            {},
 	"mkfifo":                           {},
 	"mknod":                            {},
+	"mkostemp":                         {},
 	"mkstemp":                          {},
 	"mkstemp64":                        {},
 	"mkstemps":                         {},
@@ -356,6 +373,7 @@ var CAPI = map[string]struct{}{
 	"raise":                            {},
 	"rand":                             {},
 	"random":                           {},
+	"random_r":                         {},
 	"read":                             {},
 	"readdir":                          {},
 	"readdir64":                        {},
@@ -389,6 +407,7 @@ var CAPI = map[string]struct{}{
 	"setrlimit64":                      {},
 	"setsid":                           {},
 	"setsockopt":                       {},
+	"setstate":                         {},
 	"setvbuf":                          {},
 	"shmat":                            {},
 	"shmctl":                           {},
@@ -419,6 +438,7 @@ var CAPI = map[string]struct{}{
 	"strcspn":                          {},
 	"strdup":                           {},
 	"strerror":                         {},
+	"strerror_r":                       {},
 	"strlen":                           {},
 	"strncmp":                          {},
 	"strncpy":                          {},
@@ -458,6 +478,9 @@ var CAPI = map[string]struct{}{
 	"usleep":                           {},
 	"utime":                            {},
 	"utimes":                           {},
+	"uuid_generate_random":             {},
+	"uuid_parse":                       {},
+	"uuid_unparse":                     {},
 	"vasprintf":                        {},
 	"vfprintf":                         {},
 	"vprintf":                          {},

vendor/modernc.org/libc/capi_linux_386.go

@@ -34,6 +34,8 @@ var CAPI = map[string]struct{}{
 	"__builtin_exit":                   {},
 	"__builtin_expect":                 {},
 	"__builtin_fabs":                   {},
+	"__builtin_fabsf":                  {},
+	"__builtin_fabsl":                  {},
 	"__builtin_free":                   {},
 	"__builtin_getentropy":             {},
 	"__builtin_huge_val":               {},
@@ -42,6 +44,7 @@ var CAPI = map[string]struct{}{
 	"__builtin_inff":                   {},
 	"__builtin_infl":                   {},
 	"__builtin_isnan":                  {},
+	"__builtin_isunordered":            {},
 	"__builtin_malloc":                 {},
 	"__builtin_memcmp":                 {},
 	"__builtin_memcpy":                 {},
@@ -136,6 +139,7 @@ var CAPI = map[string]struct{}{
 	"backtrace":                        {},
 	"backtrace_symbols_fd":             {},
 	"bind":                             {},
+	"bsearch":                          {},
 	"bzero":                            {},
 	"calloc":                           {},
 	"ceil":                             {},
@@ -258,6 +262,7 @@ var CAPI = map[string]struct{}{
 	"inet_ntoa":                        {},
 	"inet_ntop":                        {},
 	"inet_pton":                        {},
+	"initstate":                        {},
 	"initstate_r":                      {},
 	"ioctl":                            {},
 	"isalnum":                          {},
@@ -405,6 +410,7 @@ var CAPI = map[string]struct{}{
 	"setrlimit64":                      {},
 	"setsid":                           {},
 	"setsockopt":                       {},
+	"setstate":                         {},
 	"setvbuf":                          {},
 	"shmat":                            {},
 	"shmctl":                           {},

vendor/modernc.org/libc/capi_linux_amd64.go

@@ -34,6 +34,8 @@ var CAPI = map[string]struct{}{
 	"__builtin_exit":                   {},
 	"__builtin_expect":                 {},
 	"__builtin_fabs":                   {},
+	"__builtin_fabsf":                  {},
+	"__builtin_fabsl":                  {},
 	"__builtin_free":                   {},
 	"__builtin_getentropy":             {},
 	"__builtin_huge_val":               {},
@@ -42,6 +44,7 @@ var CAPI = map[string]struct{}{
 	"__builtin_inff":                   {},
 	"__builtin_infl":                   {},
 	"__builtin_isnan":                  {},
+	"__builtin_isunordered":            {},
 	"__builtin_malloc":                 {},
 	"__builtin_memcmp":                 {},
 	"__builtin_memcpy":                 {},
@@ -136,6 +139,7 @@ var CAPI = map[string]struct{}{
 	"backtrace":                        {},
 	"backtrace_symbols_fd":             {},
 	"bind":                             {},
+	"bsearch":                          {},
 	"bzero":                            {},
 	"calloc":                           {},
 	"ceil":                             {},
@@ -258,6 +262,7 @@ var CAPI = map[string]struct{}{
 	"inet_ntoa":                        {},
 	"inet_ntop":                        {},
 	"inet_pton":                        {},
+	"initstate":                        {},
 	"initstate_r":                      {},
 	"ioctl":                            {},
 	"isalnum":                          {},
@@ -407,6 +412,7 @@ var CAPI = map[string]struct{}{
 	"setrlimit64":                      {},
 	"setsid":                           {},
 	"setsockopt":                       {},
+	"setstate":                         {},
 	"setvbuf":                          {},
 	"shmat":                            {},
 	"shmctl":                           {},

vendor/modernc.org/libc/capi_linux_arm.go

@@ -34,6 +34,8 @@ var CAPI = map[string]struct{}{
 	"__builtin_exit":                   {},
 	"__builtin_expect":                 {},
 	"__builtin_fabs":                   {},
+	"__builtin_fabsf":                  {},
+	"__builtin_fabsl":                  {},
 	"__builtin_free":                   {},
 	"__builtin_getentropy":             {},
 	"__builtin_huge_val":               {},
@@ -42,6 +44,7 @@ var CAPI = map[string]struct{}{
 	"__builtin_inff":                   {},
 	"__builtin_infl":                   {},
 	"__builtin_isnan":                  {},
+	"__builtin_isunordered":            {},
 	"__builtin_malloc":                 {},
 	"__builtin_memcmp":                 {},
 	"__builtin_memcpy":                 {},
@@ -136,6 +139,7 @@ var CAPI = map[string]struct{}{
 	"backtrace":                        {},
 	"backtrace_symbols_fd":             {},
 	"bind":                             {},
+	"bsearch":                          {},
 	"bzero":                            {},
 	"calloc":                           {},
 	"ceil":                             {},
@@ -258,6 +262,7 @@ var CAPI = map[string]struct{}{
 	"inet_ntoa":                        {},
 	"inet_ntop":                        {},
 	"inet_pton":                        {},
+	"initstate":                        {},
 	"initstate_r":                      {},
 	"ioctl":                            {},
 	"isalnum":                          {},
@@ -405,6 +410,7 @@ var CAPI = map[string]struct{}{
 	"setrlimit64":                      {},
 	"setsid":                           {},
 	"setsockopt":                       {},
+	"setstate":                         {},
 	"setvbuf":                          {},
 	"shmat":                            {},
 	"shmctl":                           {},

vendor/modernc.org/libc/capi_linux_arm64.go

@@ -34,6 +34,8 @@ var CAPI = map[string]struct{}{
 	"__builtin_exit":                   {},
 	"__builtin_expect":                 {},
 	"__builtin_fabs":                   {},
+	"__builtin_fabsf":                  {},
+	"__builtin_fabsl":                  {},
 	"__builtin_free":                   {},
 	"__builtin_getentropy":             {},
 	"__builtin_huge_val":               {},
@@ -42,6 +44,7 @@ var CAPI = map[string]struct{}{
 	"__builtin_inff":                   {},
 	"__builtin_infl":                   {},
 	"__builtin_isnan":                  {},
+	"__builtin_isunordered":            {},
 	"__builtin_malloc":                 {},
 	"__builtin_memcmp":                 {},
 	"__builtin_memcpy":                 {},
@@ -136,6 +139,7 @@ var CAPI = map[string]struct{}{
 	"backtrace":                        {},
 	"backtrace_symbols_fd":             {},
 	"bind":                             {},
+	"bsearch":                          {},
 	"bzero":                            {},
 	"calloc":                           {},
 	"ceil":                             {},
@@ -258,6 +262,7 @@ var CAPI = map[string]struct{}{
 	"inet_ntoa":                        {},
 	"inet_ntop":                        {},
 	"inet_pton":                        {},
+	"initstate":                        {},
 	"initstate_r":                      {},
 	"ioctl":                            {},
 	"isalnum":                          {},
@@ -405,6 +410,7 @@ var CAPI = map[string]struct{}{
 	"setrlimit64":                      {},
 	"setsid":                           {},
 	"setsockopt":                       {},
+	"setstate":                         {},
 	"setvbuf":                          {},
 	"shmat":                            {},
 	"shmctl":                           {},