Finally fix parsing of app buttons, now settings and fallback values should work as expected

.gitignore

@@ -1,2 +1,2 @@
-i3status-go
-i3status-go.json
+/i3status-go
+/battery-test

.golangci.yml

@@ -1,28 +1,12 @@
+version: "2"
 run:
-  tests: false
-  skip-dirs:
-    - data
-    - vendor
+  go: "1.24"
   modules-download-mode: readonly
+  tests: false
   allow-parallel-runners: true
-  go: '1.21'
-output:
-  sort-results: true
-linters-settings:
-  gosec:
-    excludes:
-      # not relevant here
-      - G404 # Insecure random number source (rand)
-      - G306 # Expect WriteFile permissions to be 0600 or less (gosec)
 linters:
-  disable-all: true
+  default: none
   enable:
-    - errcheck
-    - gosimple
-    - govet
-    - ineffassign
-    - staticcheck
-    - unused
     - asasalint
     - asciicheck
     - bodyclose
@@ -30,20 +14,20 @@ linters:
     - contextcheck
     - decorder
     - durationcheck
+    - err113
+    - errcheck
     - errchkjson
     - errorlint
-    - exportloopref
     - ginkgolinter
     - gocheckcompilerdirectives
     - gocritic
     - godot
-    - goerr113
-    - gofmt
-    - goimports
     - gosec
     - gosmopolitan
+    - govet
     - grouper
     - importas
+    - ineffassign
     - ireturn
     - makezero
     - mirror
@@ -59,8 +43,39 @@ linters:
     - reassign
     - revive
     - rowserrcheck
-    - stylecheck
+    - staticcheck
     - unconvert
+    - unused
     - wastedassign
     - whitespace
     - wsl
+  settings:
+    gosec:
+      excludes:
+        - G404
+        - G306
+  exclusions:
+    generated: lax
+    presets:
+      - comments
+      - common-false-positives
+      - legacy
+      - std-error-handling
+    paths:
+      - data
+      - vendor
+      - third_party$
+      - builtin$
+      - examples$
+formatters:
+  enable:
+    - gofmt
+    - goimports
+  exclusions:
+    generated: lax
+    paths:
+      - data
+      - vendor
+      - third_party$
+      - builtin$
+      - examples$

Makefile

@@ -1,28 +1,34 @@
 #!/usr/bin/env gmake -f
 
-BUILDOPTS=-ldflags="-s -w" -a -gcflags=all=-l -trimpath
-FILELIST=batteries.go clock.go collection.go config.go cputemp.go cron.go i3.go ifmon.go la.go main.go memory.go \
-         pulseaudio.go signal.go spawn.go stdin.go vpn.go
+BUILDOPTS=-ldflags="-s -w" -a -gcflags=all=-l -trimpath -buildvcs=false
 
 BINARY=i3status-go
+TEST1=battery-test
+TEST2=cmdrun-test
 
 ## Use calssic targets where first one is deafult target
 all: clean build
 
 ## This target compiles binary
 build:
-	go build ${BUILDOPTS} -o ${BINARY} ${FILELIST}
+	go build ${BUILDOPTS} -o ${BINARY} ./cmd/${BINARY}
 
+battery-test:
+	rm -rf ${TEST1}
+	go build ${BUILDOPTS} -o ${TEST1} ./cmd/${TEST1}
+
+cmdrun-test:
+	rm -rf ${TEST1}
+	go build ${BUILDOPTS} -o ${TEST2} ./cmd/${TEST2}
 
 ## Remove binary with golang compiler' means
 clean:
-	go clean
-
+	rm -rf ${BINARY} ${TEST1} ${TEST2}
 
 ## Misc target, for development purposes. Updates vendored libs, brutal way.
 upgrade:
 	$(RM) -r vendor
-	go get -d -u -t ./...
+	go get -u -t ./...
 	go mod tidy
 	go mod vendor
 

README.md

@@ -14,11 +14,12 @@ It is i3bar text generator.
 * PulseAudio volume indicator, can adjust master volume too
 * Clock
 * Cron jobs (intended to use for show periodic desktop notifications but not limited to)
+* Show output of one-shot system command
 
 ## How to build it
 
-This appliction was tested to compile with go v1.21 but can be built with earlier versions (seems down to 1.18, not
-sure).
+This application was tested to compile with go v1.24.
+
 All you need is go lang compiler and gnu make utility. Invoke
 
 ```bash

batteries.go

@@ -1,175 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"math"
-	"time"
-
-	"github.com/distatus/battery"
-)
-
-// Batt shows battery charge on i3bar.
-var Batt = "<big>⚡</big> ??% •"
-
-// UpdateBatteryInfo updates info about battery charge.
-func UpdateBatteryInfo() {
-	var (
-		ch     int
-		status string
-		Batts  string
-	)
-
-	for {
-		batteries, err := battery.GetAll()
-
-		if err != nil {
-			Batts = fmt.Sprintf(
-				"<span font='%s' size='%s'>%s</span><span font='%s' size='%s'> no batt</span>",
-				Conf.Battery.SymbolFont,
-				Conf.Battery.SymbolFontSize,
-				Conf.Battery.Symbol,
-				Conf.Battery.Font,
-				Conf.Battery.FontSize,
-			)
-		} else {
-			var (
-				battsInfo string
-				chStr     string
-			)
-
-			for i, b := range batteries {
-				switch b.State.Raw {
-				case battery.Charging:
-					status = `▲`
-				case battery.Discharging:
-					status = `▼`
-				case battery.Empty:
-					status = `✘`
-				default:
-					status = `•`
-				}
-
-				// N.B. there can be case when battery is overcharged and shows >100%. It also can indicate that
-				//      calibration data is out of date and battery should be re-calibrated.
-				ch = int(math.Round((b.Full - b.Current) * (100 / b.Full)))
-
-				switch {
-				case ch > 85:
-					if Conf.Battery.ChargeColor.Full == "" {
-						chStr = fmt.Sprintf(
-							"<span color='%s' background='%s' font='%s' size='%s'>% 3d%%</span>",
-							Conf.Battery.Color,
-							Conf.Battery.Background,
-							Conf.Battery.Font,
-							Conf.Battery.FontSize,
-							ch,
-						)
-					} else {
-						chStr = fmt.Sprintf(
-							`<span color='%s' background='%s' font='%s' size='%s'>% 3d%%</span>`,
-							Conf.Battery.ChargeColor.Full,
-							Conf.Battery.Background,
-							Conf.Battery.Font,
-							Conf.Battery.FontSize,
-							ch,
-						)
-					}
-
-				case ch < 85 && ch > 40:
-					if Conf.Battery.ChargeColor.AlmostFull == "" {
-						chStr = fmt.Sprintf(
-							"<span color='%s' background='%s' font='%s' size='%s'>% 3d%%</span>",
-							Conf.Battery.Color,
-							Conf.Battery.Background,
-							Conf.Battery.Font,
-							Conf.Battery.FontSize,
-							ch,
-						)
-					} else {
-						chStr = fmt.Sprintf(
-							`<span color='%s' background='%s' font='%s' size='%s'>% 3d%%</span>`,
-							Conf.Battery.ChargeColor.AlmostFull,
-							Conf.Battery.Background,
-							Conf.Battery.Font,
-							Conf.Battery.FontSize,
-							ch,
-						)
-					}
-
-				case ch <= 40 && ch >= 10:
-					if Conf.Battery.ChargeColor.AlmostEmpty == "" {
-						chStr = fmt.Sprintf(
-							"<span color='%s' background='%s' font='%s' size='%s'>% 3d%%</span>",
-							Conf.Battery.Color,
-							Conf.Battery.Background,
-							Conf.Battery.Font,
-							Conf.Battery.FontSize,
-							ch,
-						)
-					} else {
-						chStr = fmt.Sprintf(
-							`<span color='%s' background='%s' font='%s' size='%s'>% 3d%%</span>`,
-							Conf.Battery.ChargeColor.AlmostEmpty,
-							Conf.Battery.Background,
-							Conf.Battery.Font,
-							Conf.Battery.FontSize,
-							ch,
-						)
-					}
-
-				case ch < 10:
-					if Conf.Battery.ChargeColor.Empty == "" {
-						chStr = fmt.Sprintf(
-							"<span color='%s' background='%s' font='%s' size='%s'>% 3d%%</span>",
-							Conf.Battery.Color,
-							Conf.Battery.Background,
-							Conf.Battery.Font,
-							Conf.Battery.FontSize,
-							ch,
-						)
-					} else {
-						chStr = fmt.Sprintf(
-							`<span color='%s' background='%s' font='%s' size='%s'>% 3d%%</span>`,
-							Conf.Battery.ChargeColor.Empty,
-							Conf.Battery.Background,
-							Conf.Battery.Font,
-							Conf.Battery.FontSize,
-							ch,
-						)
-					}
-				}
-
-				battsInfo += fmt.Sprintf(
-					"<span color='%s' background='%s' font='%s' size='%s'>%s</span><span color='%s' background='%s' font='%s' size='%s'>B%d </span>%s<span color='%s' background='%s' font='%s' size='%s'> %s</span>",
-					Conf.Battery.Color,
-					Conf.Battery.Background,
-					Conf.Battery.SymbolFont,
-					Conf.Battery.SymbolFontSize,
-					Conf.Battery.Symbol,
-					Conf.Battery.Color,
-					Conf.Battery.Background,
-					Conf.Battery.Font,
-					Conf.Battery.FontSize,
-					i,
-					chStr,
-					Conf.Battery.Color,
-					Conf.Battery.Background,
-					Conf.Battery.Font,
-					Conf.Battery.FontSize,
-					status,
-				)
-			}
-
-			if battsInfo != "" {
-				Batts = battsInfo
-			}
-		}
-
-		if Batt == Batts {
-			Batt = Batts
-			UpdateReady <- true
-		}
-
-		time.Sleep(5 * time.Second)
-	}
-}

cmd/battery-test/main.go

@@ -0,0 +1,22 @@
+package main
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/davecgh/go-spew/spew"
+	"github.com/distatus/battery"
+)
+
+// Program entry point.
+func main() {
+	for {
+		batteries, _ := battery.GetAll()
+
+		for index, battery := range batteries {
+			fmt.Printf("Battery %d: %s\n", index, spew.Sdump(battery))
+		}
+
+		time.Sleep(1 * time.Second)
+	}
+}

cmd/i3status-go/default-config.json

@@ -2,7 +2,7 @@
 // Default text and *block* border colors. If not set #3e78fd is used.
 "color" : "#3e78fd",
 
-// Default backbround color. If not set value of #edeceb is used.
+// Default background color. If not set value of #edeceb is used.
 "background" : "#000000",
 
 // Can be omitted, then Liberation Mono will be used.
@@ -12,7 +12,7 @@
 // ‘smaller’ or ‘larger’
 "font_size": "medium",
 
-"separator"	: {
+"separator": {
 	"left": {
 		// Set to false if omitted.
 		"enabled": true,
@@ -518,6 +518,15 @@
 "battery": {
 	"enabled": false,
 
+	// Valid only on linux, where we have mounted sysfs and /sys/class/power_supply/BAT0/capacity available
+	"use_sysfs": false,
+
+	// it is possible to set files here, if none set, /sys/class/power_supply/BAT0/capacity will be taken.
+	"sysfs_files": [
+		"/sys/class/power_supply/BAT0/capacity",
+		"/sys/class/power_supply/HIDP0/capacity"
+	],
+
 	// If omitted set to default color defined up here.
 	"color": "#3e78fd",
 
@@ -693,10 +702,95 @@
 	]
 },
 
+// Prints stdout of command to panel.
+"cmdrun" : {
+	"enabled": false,
+
+	// Delay between two consecutive command batch runs.
+	"delay": 3,
+
+	// command' binary.
+	"cmd": "/bin/bash",
+
+	// Arguments for command binary.
+	"args": ["-c", "echo 42"],
+
+	// If omitted set to default color defined up here.
+	"color": "#3e78fd",
+
+	// If omitted set to default background color defined up here.
+	"background": "#000000",
+
+	// If omitted set to default font defined up here.
+	"font": "Noto Sans",
+
+	// ‘xx-small’, ‘x-small’, ‘small’, ‘medium’, ‘large’, ‘x-large’, ‘xx-large’,  or one of relative sizes
+	// ‘smaller’ or ‘larger’. If omitted set to default font size defined up here.
+	"font_size": "medium",
+
+	// Re-define separator parameters for each command block here.
+	"separator": {
+		"left": {
+			// Set to false if omitted.
+			"enabled": true,
+
+			// If omitted set to default color defined for separator up here.
+			"color": "#3e78fd",
+
+			// If omitted set to default background color defined for separator up here.
+			"background": "#000000",
+
+			// If omitted set to default symbol defined for separator up here.
+			"symbol": "▶",
+
+			// If omitted set to default font defined for separator up here.
+			"font": "Noto Sans",
+
+			// ‘xx-small’, ‘x-small’, ‘small’, ‘medium’, ‘large’, ‘x-large’, ‘xx-large’,  or one of relative sizes
+			// ‘smaller’ or ‘larger’. If omitted set to default font size defined for separator up here.
+			"font_size": "medium"
+		},
+
+		"right": {
+			// Set to false if omitted.
+			"enabled": true,
+
+			// If omitted set to default color defined for separator up here.
+			"color": "#3e78fd",
+
+			// If omitted set to default background color defined for separator up here.
+			"background": "#000000",
+
+			// If omitted set to default symbol defined for separator up here.
+			"symbol": "◀",
+
+			// If omitted set to default font defined for separator up here.
+			"font": "Noto Sans",
+
+			// ‘xx-small’, ‘x-small’, ‘small’, ‘medium’, ‘large’, ‘x-large’, ‘xx-large’,  or one of relative sizes
+			// ‘smaller’ or ‘larger’. If omitted set to default font size defined for separator up here.
+			"font_size": "medium"
+		}
+	}
+}
+
 // Whether to display Application Buttons.
 "app_buttons": {
 	"enabled": true,
 
+	// If omitted set to default color defined up here.
+	"color": "#3e78fd",
+
+	// If omitted set to default background color defined up here.
+	"background": "#000000",
+
+	// If omitted set to default font defined up here.
+	"font": "Noto Sans",
+
+	// ‘xx-small’, ‘x-small’, ‘small’, ‘medium’, ‘large’, ‘x-large’, ‘xx-large’,  or one of relative sizes
+	// ‘smaller’ or ‘larger’. If omitted set to default font size defined up here.
+	"font_size": "medium",
+
 	// Re-define separator parameters for net-if block here.
 	"separator": {
 		"left": {
@@ -740,31 +834,36 @@
 			// ‘smaller’ or ‘larger’. If omitted set to default font size defined for separator up here.
 			"font_size": "medium"
 		}
-	},
+	}
 },
 
 // Buttons - application launch "buttons"
 "apps": [
 		{
-			// Text dispalyed on button
+			// Text displayed on button, pango markup supported.
 			"full_text" : "📂",
-			// Internal name, can be any string, but unique for each app button
+			// Internal name, can be any string, but unique for each app button.
 			"name" : "thunar",
-			// Command itself
+			// Command itself.
 			"cmd" : "thunar",
-			// Array of command args, optional
+			// Array of command args, optional.
 			"args": [ "." ],
-			// Regexp that match with Instance component of WM_CLASS(STRING) of xprop output
+			// Regexp that match with Instance component of WM_CLASS(STRING) of xprop output.
 			"instance": "^thunar$",
-			// Regexp that match with Class component of WM_CLASS(STRING) of xprop output
+			// Regexp that match with Class component of WM_CLASS(STRING) of xprop output.
 			"class": "^Thunar$",
-			// text color in html notation
+			// Text color in html notation.
 			"color": "#ffa500",
-			// background color in html notation
+			// background color in html notation.
 			"background" : "#000000",
-			// border color in html notation
+			// If omitted set to default font defined for app_buttons up here.
+			"font": "Noto Sans",
+			// ‘xx-small’, ‘x-small’, ‘small’, ‘medium’, ‘large’, ‘x-large’, ‘xx-large’,  or one of relative sizes
+			// ‘smaller’ or ‘larger’. If omitted set to default font size defined for app_buttons up here.
+			"font_size": "medium",
+			// Border color in html notation.
 			"border": "#666666",
-			// border color if there is at least one window with given Instance and/or Class exist
+			// Border color if there is at least one window with given Instance and/or Class exist.
 			"border_active": "#3e78fd",
 			// Vertical line between objects on bar - if omitted true value is assumed by i3bar, but we set it to false
 			// in that case. It is limitation of golang json parser.

cmd/i3status-go/main.go

@@ -0,0 +1,648 @@
+package main
+
+import (
+	"bytes"
+	_ "embed"
+	"encoding/json"
+	"fmt"
+	"log"
+	"os"
+	"os/signal"
+	"strings"
+	"syscall"
+
+	"i3status-go/internal/lib"
+)
+
+//go:embed default-config.json
+var DefaultConfig []byte
+
+// Program entry point.
+func main() {
+	Conf, err := lib.ReadConf(DefaultConfig)
+
+	if err != nil {
+		log.Panicf("Unable to read config: %s", err)
+	}
+
+	Conf.Channels.UpdateReady = make(chan bool)
+	Conf.Channels.SVPAHandlerChan = make(chan lib.ClickEvent, 256)
+	Conf.Channels.MsgChan = make(chan []lib.I3BarOutBlock, 64)
+	Conf.Channels.SigChan = make(chan os.Signal, 1)
+	Conf.Channels.RunChan = make(chan []string, 128)
+	Conf.Values.PrintOutput = true
+	Conf.Values.BatteryString = "<big>⚡</big> ??% •"
+	Conf.Values.ClockTime = "Thu, 1 Jan 1970   1:00"
+	Conf.Values.IfStatus = ""
+	Conf.Values.VPNStatus = ""
+	Conf.Values.Memory.Shared = 0
+	Conf.Values.Memory.Usedpct = 0
+	Conf.Values.Memory.Swap = 0
+	Conf.Values.La = "-1"
+	// Conf.Values.PA
+	Conf.Values.SoundVolume = "🔊:0%"
+
+	// TODO: Проставить дефолтные значения для глобальных переменных модулей.
+	Conf.Values.BatteryString = fmt.Sprintf(
+		"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
+		Conf.Battery.Color,
+		Conf.Battery.Background,
+		Conf.Battery.SymbolFont,
+		Conf.Battery.SymbolFontSize,
+		Conf.Battery.Symbol,
+	)
+
+	Conf.Values.BatteryString += fmt.Sprintf(
+		"<span color='%s' background='%s' font='%s' size='%s'> ??%% •</span>",
+		Conf.Battery.Color,
+		Conf.Battery.Background,
+		Conf.Battery.Font,
+		Conf.Battery.FontSize,
+	)
+
+	Conf.Values.SoundVolume = fmt.Sprintf(
+		"<span color='%s' background='%s' font='%s' size='%s'>🔊</span>",
+		Conf.SimpleVolumePa.Color,
+		Conf.SimpleVolumePa.Background,
+		Conf.SimpleVolumePa.SymbolFont,
+		Conf.SimpleVolumePa.SymbolFontSize,
+	)
+
+	Conf.Values.SoundVolume += fmt.Sprintf(
+		"<span color='%s' background='%s' font='%s' size='%s'>:0%%</span>",
+		Conf.SimpleVolumePa.Color,
+		Conf.SimpleVolumePa.Background,
+		Conf.SimpleVolumePa.Font,
+		Conf.SimpleVolumePa.FontSize,
+	)
+
+	Conf.Values.ClockTime = fmt.Sprintf(
+		"<span color='%s' background='%s' font='%s' size='%s'>Thu, 1 Jan 1970   1:00</span>",
+		Conf.Clock.Color,
+		Conf.Clock.Background,
+		Conf.Clock.Font,
+		Conf.Clock.FontSize,
+	)
+
+	Conf.Values.RunCommandOutput = fmt.Sprintf(
+		"<span color='%s' background='%s' font='%s' size='%s'>?</span>",
+		Conf.CmdRun.Color,
+		Conf.CmdRun.Background,
+		Conf.CmdRun.Font,
+		Conf.CmdRun.FontSize,
+	)
+
+	go Conf.Spawner()
+	go Conf.ParseStdin()
+	go Conf.CleanZombies()
+	go Conf.SVPAHandler()
+	go PrintToI3bar(Conf)
+
+	if Conf.AppButtons.Enabled {
+		go Conf.UpdateI3WinList()
+	}
+
+	// Kick signal handler
+	go Conf.SigHandler()
+	signal.Notify(Conf.Channels.SigChan,
+		syscall.SIGUSR1,
+		syscall.SIGUSR2,
+		syscall.SIGQUIT,
+		syscall.SIGTERM,
+		syscall.SIGINT)
+
+	// Populate memory stats
+	if Conf.Mem.Enabled {
+		go Conf.UpdateMemStats()
+	}
+
+	// Populate LA stats
+	if Conf.LA.Enabled {
+		go Conf.UpdateLaStats()
+	}
+
+	// Populate CPUTemperature
+	if Conf.CPUTemp.Enabled {
+		go Conf.UpdateCPUTemperature()
+	}
+
+	// Populate Clock
+	if Conf.Clock.Enabled {
+		go Conf.UpdateClock()
+	}
+
+	if Conf.Battery.Enabled {
+		go Conf.UpdateBatteryInfo()
+	}
+
+	if Conf.SimpleVolumePa.Enabled {
+		go Conf.UpdateVolumeInfo()
+	}
+
+	if Conf.NetIf.Enabled {
+		go Conf.UpdateIfStatus()
+	}
+
+	if Conf.Cron.Enabled {
+		go Conf.RunCron()
+	}
+
+	if Conf.Vpn.Enabled {
+		go Conf.UpdateVPNStatus()
+	}
+
+	if Conf.CmdRun.Enabled {
+		go Conf.RunCommand()
+	}
+
+	/*
+		I3bar documentation pretends that message protocol must be valid json. In practice, we only have to print valid
+		header, empty json array and (potentially infinite) json lines (line that is valid json by itself) that is
+		actually json arrays. We do not need to *close* this json at all.
+		Gracefully closed json required when i3bar initiates our program to stop|quit, this (should) happens just before
+		i3bar itself terminating. So we don't care.
+	*/
+
+	// Print header and one empty message and wait for updates
+	fmt.Printf(
+		"{\"version\": 1, \"stop_signal\": %d, \"cont_signal\": %d, \"click_events\": true}\n",
+		syscall.SIGUSR1,
+		syscall.SIGUSR2,
+	)
+
+	fmt.Println("[ [],")
+
+	for range Conf.Channels.UpdateReady {
+		// Actually build json struct, marshal it and print result
+		var j []lib.I3BarOutBlock
+
+		// TODO: впилить для первого и последнего батона separator
+		if Conf.AppButtons.Enabled {
+			for num, app := range Conf.Apps {
+				var b lib.I3BarOutBlock
+
+				if num == 0 {
+					b.FullText = fmt.Sprintf(
+						"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
+						Conf.AppButtons.Separator.Left.Color,
+						Conf.AppButtons.Separator.Left.Background,
+						Conf.AppButtons.Separator.Left.Font,
+						Conf.AppButtons.Separator.Left.FontSize,
+						Conf.AppButtons.Separator.Left.Symbol,
+					)
+				}
+
+				b.FullText = fmt.Sprintf(
+					"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
+					app.Color,
+					app.Background,
+					app.Font,
+					app.FontSize,
+					app.FullText,
+				)
+
+				if num == len(Conf.Apps) {
+					b.FullText = fmt.Sprintf(
+						"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
+						Conf.AppButtons.Separator.Right.Color,
+						Conf.AppButtons.Separator.Right.Background,
+						Conf.AppButtons.Separator.Right.Font,
+						Conf.AppButtons.Separator.Right.FontSize,
+						Conf.AppButtons.Separator.Right.Symbol,
+					)
+				}
+
+				b.Instance = app.Instance
+				b.Markup = `pango`
+				b.Separator = app.Separator
+				b.SeparatorBlockWidth = app.SeparatorBlockWidth
+				b.Name = app.Name
+
+				if lib.HasWindows(app.Class, app.Instance) {
+					b.Border = app.BorderActive
+				} else {
+					b.Border = app.Border
+				}
+
+				b.BorderTop = 1
+				b.BorderRight = 1
+				b.BorderBottom = 1
+				b.BorderLeft = 1
+
+				j = append(j, b)
+			}
+		}
+
+		if Conf.CPUTemp.Enabled {
+			var b lib.I3BarOutBlock
+
+			b.Color = Conf.CPUTemp.Color
+			b.Background = Conf.CPUTemp.Background
+
+			if Conf.CPUTemp.Separator.Left.Enabled {
+				b.FullText = fmt.Sprintf(
+					"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
+					Conf.CPUTemp.Separator.Left.Color,
+					Conf.CPUTemp.Separator.Left.Background,
+					Conf.CPUTemp.Separator.Left.Font,
+					Conf.CPUTemp.Separator.Left.FontSize,
+					Conf.CPUTemp.Separator.Left.Symbol,
+				)
+			}
+
+			b.FullText += fmt.Sprintf(
+				"<span color='%s' background='%s' font='%s' size='%s'>CPU: %d°</span>",
+				Conf.CPUTemp.Color,
+				Conf.CPUTemp.Background,
+				Conf.CPUTemp.Font,
+				Conf.CPUTemp.FontSize,
+				Conf.Values.CPUTemperature,
+			)
+
+			if Conf.CPUTemp.Separator.Right.Enabled {
+				b.FullText += fmt.Sprintf(
+					"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
+					Conf.CPUTemp.Separator.Right.Color,
+					Conf.CPUTemp.Separator.Right.Background,
+					Conf.CPUTemp.Separator.Right.Font,
+					Conf.CPUTemp.Separator.Right.FontSize,
+					Conf.CPUTemp.Separator.Right.Symbol,
+				)
+			}
+
+			b.Markup = "pango"
+			b.Separator = false
+
+			j = append(j, b)
+		}
+
+		if Conf.Mem.Enabled {
+			var b lib.I3BarOutBlock
+
+			b.Color = Conf.Mem.Color
+			b.Background = Conf.Mem.Background
+
+			if Conf.Mem.Separator.Left.Enabled {
+				b.FullText = fmt.Sprintf(
+					"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
+					Conf.Mem.Separator.Left.Color,
+					Conf.Mem.Separator.Left.Background,
+					Conf.Mem.Separator.Left.Font,
+					Conf.Mem.Separator.Left.FontSize,
+					Conf.Mem.Separator.Left.Symbol,
+				)
+			}
+
+			if Conf.Mem.ShowSwap {
+				b.FullText += fmt.Sprintf(
+					"<span color='%s' background='%s' font='%s' size='%s'>M:%d%% SHM:%dM SW:%dM</span>",
+					Conf.Mem.Color,
+					Conf.Mem.Background,
+					Conf.Mem.Font,
+					Conf.Mem.FontSize,
+					Conf.Values.Memory.Usedpct,
+					Conf.Values.Memory.Shared,
+					Conf.Values.Memory.Swap,
+				)
+			} else {
+				b.FullText += fmt.Sprintf(
+					"<span color='%s' background='%s' font='%s' size='%s'>M:%d%% SHM:%dM</span>",
+					Conf.Mem.Color,
+					Conf.Mem.Background,
+					Conf.Mem.Font,
+					Conf.Mem.FontSize,
+					Conf.Values.Memory.Usedpct,
+					Conf.Values.Memory.Shared,
+				)
+			}
+
+			if Conf.Mem.Separator.Right.Enabled {
+				b.FullText += fmt.Sprintf(
+					"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
+					Conf.Mem.Separator.Right.Color,
+					Conf.Mem.Separator.Right.Background,
+					Conf.Mem.Separator.Right.Font,
+					Conf.Mem.Separator.Right.FontSize,
+					Conf.Mem.Separator.Right.Symbol,
+				)
+			}
+
+			b.Markup = "pango"
+			b.Separator = false
+
+			j = append(j, b)
+		}
+
+		if Conf.LA.Enabled {
+			var b lib.I3BarOutBlock
+
+			b.Color = Conf.LA.Color
+			b.Background = Conf.LA.Background
+
+			if Conf.LA.Separator.Left.Enabled {
+				b.FullText = fmt.Sprintf(
+					"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
+					Conf.LA.Separator.Left.Color,
+					Conf.LA.Separator.Left.Background,
+					Conf.LA.Separator.Left.Font,
+					Conf.LA.Separator.Left.FontSize,
+					Conf.LA.Separator.Left.Symbol,
+				)
+			}
+
+			b.FullText += fmt.Sprintf(
+				"<span color='%s' background='%s' font='%s' size='%s'>LA:%s</span>",
+				Conf.LA.Color,
+				Conf.LA.Background,
+				Conf.LA.Font,
+				Conf.LA.FontSize,
+				Conf.Values.La,
+			)
+
+			if Conf.LA.Separator.Right.Enabled {
+				b.FullText += fmt.Sprintf(
+					"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
+					Conf.LA.Separator.Right.Color,
+					Conf.LA.Separator.Right.Background,
+					Conf.LA.Separator.Right.Font,
+					Conf.LA.Separator.Right.FontSize,
+					Conf.LA.Separator.Right.Symbol,
+				)
+			}
+
+			b.Markup = "pango"
+			b.Separator = false
+
+			j = append(j, b)
+		}
+
+		if Conf.NetIf.Enabled {
+			var b lib.I3BarOutBlock
+
+			b.Color = Conf.NetIf.Color
+			b.Background = Conf.NetIf.Background
+
+			if Conf.NetIf.Separator.Left.Enabled {
+				b.FullText = fmt.Sprintf(
+					"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
+					Conf.NetIf.Separator.Left.Color,
+					Conf.NetIf.Separator.Left.Background,
+					Conf.NetIf.Separator.Left.Font,
+					Conf.NetIf.Separator.Left.FontSize,
+					Conf.NetIf.Separator.Left.Symbol,
+				)
+			}
+
+			b.FullText += fmt.Sprintf(
+				"<span color='%s' background='%s' font='%s' size= '%s'>%s</span>",
+				Conf.NetIf.Color,
+				Conf.NetIf.Background,
+				Conf.NetIf.Font,
+				Conf.NetIf.FontSize,
+				Conf.Values.IfStatus,
+			)
+
+			if Conf.NetIf.Separator.Right.Enabled {
+				b.FullText += fmt.Sprintf(
+					"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
+					Conf.NetIf.Separator.Right.Color,
+					Conf.NetIf.Separator.Right.Background,
+					Conf.NetIf.Separator.Right.Font,
+					Conf.NetIf.Separator.Right.FontSize,
+					Conf.NetIf.Separator.Right.Symbol,
+				)
+			}
+
+			b.Markup = "pango"
+			b.Separator = false
+
+			j = append(j, b)
+		}
+
+		if Conf.Vpn.Enabled {
+			var b lib.I3BarOutBlock
+
+			b.Color = Conf.Vpn.Color
+			b.Background = Conf.Vpn.Background
+
+			if Conf.Vpn.Separator.Left.Enabled {
+				b.FullText = fmt.Sprintf(
+					"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
+					Conf.Vpn.Separator.Left.Color,
+					Conf.Vpn.Separator.Left.Background,
+					Conf.Vpn.Separator.Left.Font,
+					Conf.Vpn.Separator.Left.FontSize,
+					Conf.Vpn.Separator.Left.Symbol,
+				)
+			}
+
+			b.FullText += fmt.Sprintf(
+				"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
+				Conf.Vpn.Color,
+				Conf.Vpn.Background,
+				Conf.Vpn.Font,
+				Conf.Vpn.FontSize,
+				Conf.Values.VPNStatus,
+			)
+
+			if Conf.Vpn.Separator.Right.Enabled {
+				b.FullText += fmt.Sprintf(
+					"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
+					Conf.Vpn.Separator.Right.Color,
+					Conf.Vpn.Separator.Right.Background,
+					Conf.Vpn.Separator.Right.Font,
+					Conf.Vpn.Separator.Right.FontSize,
+					Conf.Vpn.Separator.Right.Symbol,
+				)
+			}
+
+			b.Markup = "pango"
+			b.Separator = false
+
+			j = append(j, b)
+		}
+
+		if Conf.Battery.Enabled {
+			var b lib.I3BarOutBlock
+
+			b.Color = Conf.Battery.Color
+			b.Background = Conf.Battery.Background
+
+			if Conf.Battery.Separator.Left.Enabled {
+				b.FullText = fmt.Sprintf(
+					"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
+					Conf.Battery.Separator.Left.Color,
+					Conf.Battery.Separator.Left.Background,
+					Conf.Battery.Separator.Left.Font,
+					Conf.Battery.Separator.Left.FontSize,
+					Conf.Battery.Separator.Left.Symbol,
+				)
+			}
+
+			b.FullText += Conf.Values.BatteryString
+
+			if Conf.Battery.Separator.Right.Enabled {
+				b.FullText += fmt.Sprintf(
+					"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
+					Conf.Battery.Separator.Right.Color,
+					Conf.Battery.Separator.Right.Background,
+					Conf.Battery.Separator.Right.Font,
+					Conf.Battery.Separator.Right.FontSize,
+					Conf.Battery.Separator.Right.Symbol,
+				)
+			}
+
+			b.Markup = "pango"
+			b.Separator = false
+
+			j = append(j, b)
+		}
+
+		if Conf.SimpleVolumePa.Enabled {
+			var b lib.I3BarOutBlock
+
+			b.Name = "simple-volume-pa"
+			b.Color = Conf.SimpleVolumePa.Color
+			b.Background = Conf.SimpleVolumePa.Background
+
+			if Conf.SimpleVolumePa.Separator.Left.Enabled {
+				b.FullText = fmt.Sprintf(
+					"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
+					Conf.SimpleVolumePa.Separator.Left.Color,
+					Conf.SimpleVolumePa.Separator.Left.Background,
+					Conf.SimpleVolumePa.Separator.Left.Font,
+					Conf.SimpleVolumePa.Separator.Left.FontSize,
+					Conf.SimpleVolumePa.Separator.Left.Symbol,
+				)
+			}
+
+			// Pango format is already applied in plugin src.
+			b.FullText += Conf.Values.SoundVolume
+
+			if Conf.SimpleVolumePa.Separator.Right.Enabled {
+				b.FullText += fmt.Sprintf(
+					"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
+					Conf.SimpleVolumePa.Separator.Right.Color,
+					Conf.SimpleVolumePa.Separator.Right.Background,
+					Conf.SimpleVolumePa.Separator.Right.Font,
+					Conf.SimpleVolumePa.Separator.Right.FontSize,
+					Conf.SimpleVolumePa.Separator.Right.Symbol,
+				)
+			}
+
+			b.Markup = "pango"
+			b.Separator = false
+
+			j = append(j, b)
+		}
+
+		if Conf.CmdRun.Enabled {
+			var b lib.I3BarOutBlock
+
+			b.Name = `runcommandoutput`
+			b.Color = Conf.CmdRun.Color
+			b.Background = Conf.CmdRun.Background
+
+			if Conf.CmdRun.Separator.Left.Enabled {
+				b.FullText = fmt.Sprintf(
+					"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
+					Conf.CmdRun.Separator.Left.Color,
+					Conf.CmdRun.Separator.Left.Background,
+					Conf.CmdRun.Separator.Left.Font,
+					Conf.CmdRun.Separator.Left.FontSize,
+					Conf.CmdRun.Separator.Left.Symbol,
+				)
+			}
+
+			b.FullText += fmt.Sprintf(
+				"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
+				Conf.CmdRun.Color,
+				Conf.CmdRun.Background,
+				Conf.CmdRun.Font,
+				Conf.CmdRun.FontSize,
+				Conf.Values.RunCommandOutput,
+			)
+
+			if Conf.CmdRun.Separator.Right.Enabled {
+				b.FullText += fmt.Sprintf(
+					"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
+					Conf.CmdRun.Separator.Right.Color,
+					Conf.CmdRun.Separator.Right.Background,
+					Conf.CmdRun.Separator.Right.Font,
+					Conf.CmdRun.Separator.Right.FontSize,
+					Conf.CmdRun.Separator.Right.Symbol,
+				)
+			}
+
+			b.Markup = "pango"
+			b.Separator = false
+
+			j = append(j, b)
+		}
+
+		if Conf.Clock.Enabled {
+			var b lib.I3BarOutBlock
+
+			b.Name = `wallclock`
+			b.Color = Conf.Clock.Color
+			b.Background = Conf.Clock.Background
+
+			if Conf.Clock.Separator.Left.Enabled {
+				b.FullText = fmt.Sprintf(
+					"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
+					Conf.Clock.Separator.Left.Color,
+					Conf.Clock.Separator.Left.Background,
+					Conf.Clock.Separator.Left.Font,
+					Conf.Clock.Separator.Left.FontSize,
+					Conf.Clock.Separator.Left.Symbol,
+				)
+			}
+
+			b.FullText += fmt.Sprintf(
+				"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
+				Conf.Clock.Color,
+				Conf.Clock.Background,
+				Conf.Clock.Font,
+				Conf.Clock.FontSize,
+				Conf.Values.ClockTime,
+			)
+
+			if Conf.Clock.Separator.Right.Enabled {
+				b.FullText += fmt.Sprintf(
+					"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
+					Conf.Clock.Separator.Right.Color,
+					Conf.Clock.Separator.Right.Background,
+					Conf.Clock.Separator.Right.Font,
+					Conf.Clock.Separator.Right.FontSize,
+					Conf.Clock.Separator.Right.Symbol,
+				)
+			}
+
+			b.Markup = "pango"
+			b.Separator = false
+
+			j = append(j, b)
+		}
+
+		if Conf.Values.PrintOutput && len(j) > 0 {
+			Conf.Channels.MsgChan <- j
+		}
+	}
+}
+
+// PrintToI3bar prints info to stdout according to ipc docs (https://i3wm.org/docs/i3bar-protocol.html)
+func PrintToI3bar(c *lib.MyConfig) {
+	for message := range c.Channels.MsgChan {
+		// we do not need to html-encode output, json.Marshal does this forcefully, so invent our own Marshal
+		buf := new(bytes.Buffer)
+		encoder := json.NewEncoder(buf)
+		encoder.SetEscapeHTML(false)
+		err := encoder.Encode(message)
+
+		if err != nil {
+			log.Printf("Unable to json-encode message, %s\n", err)
+		}
+
+		fmt.Println(strings.TrimSuffix(buf.String(), "\n") + ",")
+	}
+}

configs/i3status-go-example.json

@@ -0,0 +1 @@
+../cmd/i3status-go/default-config.json

go.mod

@@ -1,13 +1,14 @@
-module github.com/eleksir/i3status-go
+module i3status-go
 
-go 1.21
+go 1.24.2
 
 require (
-	github.com/adrg/xdg v0.4.0
+	github.com/adrg/xdg v0.5.3
+	github.com/davecgh/go-spew v1.1.1
 	github.com/distatus/battery v0.11.0
-	github.com/go-co-op/gocron/v2 v2.1.2
+	github.com/go-co-op/gocron/v2 v2.16.1
 	github.com/hjson/hjson-go v3.3.0+incompatible
-	github.com/mafik/pulseaudio v0.0.0-20200511091429-8449222912dd
+	github.com/mafik/pulseaudio v0.0.0-20240327130323-384e01075e6e
 	github.com/shirou/gopsutil v3.21.11+incompatible
 	go.i3wm.org/i3 v0.0.0-20190720062127-36e6ec85cc5a
 )
@@ -16,11 +17,18 @@ require (
 	github.com/BurntSushi/xgb v0.0.0-20210121224620-deaf085860bc // indirect
 	github.com/BurntSushi/xgbutil v0.0.0-20190907113008-ad855c713046 // indirect
 	github.com/go-ole/go-ole v1.3.0 // indirect
-	github.com/google/uuid v1.5.0 // indirect
-	github.com/jonboulle/clockwork v0.4.0 // indirect
+	github.com/google/go-cmp v0.6.0 // indirect
+	github.com/google/uuid v1.6.0 // indirect
+	github.com/jonboulle/clockwork v0.5.0 // indirect
 	github.com/robfig/cron/v3 v3.0.1 // indirect
-	github.com/yusufpapurcu/wmi v1.2.3 // indirect
-	golang.org/x/exp v0.0.0-20240103183307-be819d1f06fc // indirect
-	golang.org/x/sys v0.16.0 // indirect
+	github.com/yusufpapurcu/wmi v1.2.4 // indirect
+	golang.org/x/sync v0.12.0 // indirect
+	golang.org/x/sys v0.32.0 // indirect
 	howett.net/plist v1.0.1 // indirect
 )
+
+tool (
+	i3status-go/cmd/battery-test
+	i3status-go/cmd/i3status-go
+	i3status-go/internal/lib
+)

go.sum

@@ -4,60 +4,53 @@ github.com/BurntSushi/xgb v0.0.0-20210121224620-deaf085860bc/go.mod h1:IVnqGOEym
 github.com/BurntSushi/xgbutil v0.0.0-20160919175755-f7c97cef3b4e/go.mod h1:uw9h2sd4WWHOPdJ13MQpwK5qYWKYDumDqxWWIknEQ+k=
 github.com/BurntSushi/xgbutil v0.0.0-20190907113008-ad855c713046 h1:O/r2Sj+8QcMF7V5IcmiE2sMFV2q3J47BEirxbXJAdzA=
 github.com/BurntSushi/xgbutil v0.0.0-20190907113008-ad855c713046/go.mod h1:uw9h2sd4WWHOPdJ13MQpwK5qYWKYDumDqxWWIknEQ+k=
-github.com/adrg/xdg v0.4.0 h1:RzRqFcjH4nE5C6oTAxhBtoE2IRyjBSa62SCbyPidvls=
-github.com/adrg/xdg v0.4.0/go.mod h1:N6ag73EX4wyxeaoeHctc1mas01KZgsj5tYiAIwqJE/E=
-github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/adrg/xdg v0.5.3 h1:xRnxJXne7+oWDatRhR1JLnvuccuIeCoBu2rtuLqQB78=
+github.com/adrg/xdg v0.5.3/go.mod h1:nlTsY+NNiCBGCK2tpm09vRqfVzrc2fLmXGpBLF0zlTQ=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/distatus/battery v0.11.0 h1:KJk89gz90Iq/wJtbjjM9yUzBXV+ASV/EG2WOOL7N8lc=
 github.com/distatus/battery v0.11.0/go.mod h1:KmVkE8A8hpIX4T78QRdMktYpEp35QfOL8A8dwZBxq2k=
-github.com/go-co-op/gocron/v2 v2.1.2 h1:+6tTOA9aBaKXpDWExw07hYoGEBzT+4CkGSVAiJ7WSXs=
-github.com/go-co-op/gocron/v2 v2.1.2/go.mod h1:0MfNAXEchzeSH1vtkZrTAcSMWqyL435kL6CA4b0bjrg=
+github.com/go-co-op/gocron/v2 v2.16.1 h1:ux/5zxVRveCaCuTtNI3DiOk581KC1KpJbpJFYUEVYwo=
+github.com/go-co-op/gocron/v2 v2.16.1/go.mod h1:opexeOFy5BplhsKdA7bzY9zeYih8I8/WNJ4arTIFPVc=
 github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0=
 github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE=
 github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW6zv78=
 github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
-github.com/google/go-cmp v0.5.8 h1:e6P7q2lk1O+qJJb4BtCQXlK8vWEO8V1ZeuEdJNOqZyg=
-github.com/google/go-cmp v0.5.8/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
-github.com/google/uuid v1.5.0 h1:1p67kYwdtXjb0gL0BPiP1Av9wiZPo5A8z2cWkTZ+eyU=
-github.com/google/uuid v1.5.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
+github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/hjson/hjson-go v3.3.0+incompatible h1:Rqr+Ya+0aCJMjaE4s8E9YKvuJLuLVpEvz4ONum52vnI=
 github.com/hjson/hjson-go v3.3.0+incompatible/go.mod h1:qsetwF8NlsTsOTwZTApNlTCerV+b2GjYRRcIk4JMFio=
 github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI=
-github.com/jonboulle/clockwork v0.4.0 h1:p4Cf1aMWXnXAUh8lVfewRBx1zaTSYKrKMF2g3ST4RZ4=
-github.com/jonboulle/clockwork v0.4.0/go.mod h1:xgRqUGwRcjKCO1vbZUEtSLrqKoPSsUpK7fnezOII0kc=
-github.com/mafik/pulseaudio v0.0.0-20200511091429-8449222912dd h1:gn6oLpDCn3wY+1WfbbP0OwxXL+2eHi3mxF/DsNyPHUM=
-github.com/mafik/pulseaudio v0.0.0-20200511091429-8449222912dd/go.mod h1:dlpd1fnLAhI6g9tM/aCobgN/Yka1/SkHrBTfAgDdb9Q=
+github.com/jonboulle/clockwork v0.5.0 h1:Hyh9A8u51kptdkR+cqRpT1EebBwTn1oK9YfGYbdFz6I=
+github.com/jonboulle/clockwork v0.5.0/go.mod h1:3mZlmanh0g2NDKO5TWZVJAfofYk64M7XN3SzBPjZF60=
+github.com/mafik/pulseaudio v0.0.0-20240327130323-384e01075e6e h1:y6jINFpNNS+IEizD6s9j35aKVNRsfsoEKN8IStRDQm0=
+github.com/mafik/pulseaudio v0.0.0-20240327130323-384e01075e6e/go.mod h1:dlpd1fnLAhI6g9tM/aCobgN/Yka1/SkHrBTfAgDdb9Q=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/robfig/cron/v3 v3.0.1 h1:WdRxkvbJztn8LMz/QEvLN5sBU+xKpSqwwUO1Pjr4qDs=
 github.com/robfig/cron/v3 v3.0.1/go.mod h1:eQICP3HwyT7UooqI/z+Ov+PtYAWygg1TEWWzGIFLtro=
 github.com/shirou/gopsutil v3.21.11+incompatible h1:+1+c1VGhc88SSonWP6foOcLhvnKlUeu/erjjvaPEYiI=
 github.com/shirou/gopsutil v3.21.11+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA=
-github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
-github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
-github.com/yusufpapurcu/wmi v1.2.3 h1:E1ctvB7uKFMOJw3fdOW32DwGE9I7t++CRUEMKvFoFiw=
-github.com/yusufpapurcu/wmi v1.2.3/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0=
+github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
+github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/yusufpapurcu/wmi v1.2.4 h1:zFUKzehAFReQwLys1b/iSMl+JQGSCSjtVqQn9bBrPo0=
+github.com/yusufpapurcu/wmi v1.2.4/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0=
 go.i3wm.org/i3 v0.0.0-20190720062127-36e6ec85cc5a h1:yeQv6GWN8DsA2f3b+u1zhRIJg2HmsGYqXsd+W7ULr7Q=
 go.i3wm.org/i3 v0.0.0-20190720062127-36e6ec85cc5a/go.mod h1:7w17+r1F28Yxb1pHu8SxARJo+RGvJCAGOEf+GLw+2aQ=
 go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
 go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
-golang.org/x/exp v0.0.0-20240103183307-be819d1f06fc h1:ao2WRsKSzW6KuUY9IWPwWahcHCgR0s52IfwutMfEbdM=
-golang.org/x/exp v0.0.0-20240103183307-be819d1f06fc/go.mod h1:iRJReGqOEeBhDZGkGbynYwcHlctCvnjTYIamk7uXpHI=
-golang.org/x/net v0.0.0-20181102091132-c10e9556a7bc h1:ZMCWScCvS2fUVFw8LOpxyUUW5qiviqr4Dg5NdjLeiLU=
 golang.org/x/net v0.0.0-20181102091132-c10e9556a7bc/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f h1:wMNYb4v58l5UBM7MYRLPG6ZhfOqbKu7X5eyFl8ZhKvA=
 golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.12.0 h1:MHc5BpPuC30uJk597Ri8TV3CNZcTLu6B6z4lJy+g6Jw=
+golang.org/x/sync v0.12.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
 golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20211025201205-69cdffdb9359/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.16.0 h1:xWw16ngr6ZMtmxDyKyIgsE93KNKz5HKmMa3b8ALHidU=
-golang.org/x/sys v0.16.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.32.0 h1:s77OFDvIQeibCmezSnk/q6iAfkdiQaJi4VzroCFrN20=
+golang.org/x/sys v0.32.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v1 v1.0.0-20140924161607-9f9df34309c0/go.mod h1:WDnlLJ4WF5VGsH/HVa3CI79GS0ol3YnhVnKP89i0kNg=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 howett.net/plist v1.0.1 h1:37GdZ8tP09Q35o9ych3ehygcsL+HqKSwzctveSlarvM=

internal/lib/batteries.go

@@ -0,0 +1,255 @@
+package lib
+
+import (
+	"fmt"
+	"log"
+	"math"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/distatus/battery"
+)
+
+// UpdateBatteryInfo updates info about battery charge.
+func (c *MyConfig) UpdateBatteryInfo() {
+	var (
+		InitialDelay       = 100 * time.Millisecond
+		LoopIterationDelay = 5 * time.Second
+		Delay              = InitialDelay
+		ticker             = time.NewTicker(Delay)
+	)
+
+	for range ticker.C {
+		if Delay == InitialDelay {
+			Delay = LoopIterationDelay
+			ticker.Reset(Delay)
+		}
+
+		var (
+			batteries = []*battery.Battery{}
+			Batts     string
+			ch        int
+			status    string
+		)
+
+		if c.Battery.UseSysfs {
+			for _, file := range c.Battery.SysfsFiles {
+				var batt battery.Battery
+
+				_, err := os.Stat(file)
+
+				// If file exists.
+				if !os.IsNotExist(err) {
+					var (
+						myCharge string
+						myStatus string
+					)
+
+					b, err := os.ReadFile(file)
+
+					if err != nil {
+						log.Printf("Unable to read file %s: %s", file, err)
+
+						continue
+					}
+
+					myCharge = strings.Trim(string(b), "\n")
+
+					statusFile := filepath.Dir(file) + "/status"
+
+					// If file exists.
+					if !os.IsNotExist(err) {
+						b, err := os.ReadFile(statusFile)
+
+						if err != nil {
+							log.Printf("Unable to read file %s: %s", statusFile, err)
+
+							continue
+						}
+
+						myStatus = strings.Trim(string(b), "\n")
+					} else {
+						continue
+					}
+
+					// Make stub battery class :) .
+					switch myStatus {
+					case "Charging":
+						batt.State.Raw = battery.Charging
+					case "Discharging":
+						batt.State.Raw = battery.Discharging
+					case "Empty":
+						batt.State.Raw = battery.Empty
+					case "Full":
+						batt.State.Raw = battery.Full
+					default:
+						batt.State.Raw = battery.Unknown
+					}
+
+					ch, err := strconv.Atoi(myCharge)
+
+					if err != nil {
+						log.Printf("Unable to convert string from file %s to integer", file)
+
+						continue
+					}
+
+					batt.Current = float64(ch)
+
+					batteries = append(batteries, &batt)
+				}
+			}
+		} else {
+			// In theory, this module should give for each entry its separate err, but in practice it gives
+			// one single err for all entries, so we cannot detemine whist exatly entry errored.
+			batteries, _ = battery.GetAll()
+		}
+
+		var (
+			battsInfo string
+			chStr     string
+		)
+
+		for i, b := range batteries {
+			switch b.State.Raw {
+			case battery.Charging:
+				status = `▲`
+			case battery.Discharging:
+				status = `▼`
+			case battery.Empty:
+				status = `✘`
+			default:
+				status = `•`
+			}
+
+			// N.B. there can be case when battery is overcharged and shows >100%. It also can indicate that
+			//      calibration data is out of date and battery should be re-calibrated.
+			if c.Battery.UseSysfs {
+				ch = int(b.Current)
+			} else {
+				ch = int(math.Round((b.Full - (b.Full - b.Current)) * (100 / b.Full)))
+			}
+
+			switch {
+			case ch <= 500 && ch >= 84:
+				if c.Battery.ChargeColor.Full == "" {
+					chStr = fmt.Sprintf(
+						"<span color='%s' background='%s' font='%s' size='%s'>% 3d%%</span>",
+						c.Battery.Color,
+						c.Battery.Background,
+						c.Battery.Font,
+						c.Battery.FontSize,
+						ch,
+					)
+				} else {
+					chStr = fmt.Sprintf(
+						`<span color='%s' background='%s' font='%s' size='%s'>% 3d%%</span>`,
+						c.Battery.ChargeColor.Full,
+						c.Battery.Background,
+						c.Battery.Font,
+						c.Battery.FontSize,
+						ch,
+					)
+				}
+
+			case ch < 85 && ch > 40:
+				if c.Battery.ChargeColor.AlmostFull == "" {
+					chStr = fmt.Sprintf(
+						"<span color='%s' background='%s' font='%s' size='%s'>% 3d%%</span>",
+						c.Battery.Color,
+						c.Battery.Background,
+						c.Battery.Font,
+						c.Battery.FontSize,
+						ch,
+					)
+				} else {
+					chStr = fmt.Sprintf(
+						`<span color='%s' background='%s' font='%s' size='%s'>% 3d%%</span>`,
+						c.Battery.ChargeColor.AlmostFull,
+						c.Battery.Background,
+						c.Battery.Font,
+						c.Battery.FontSize,
+						ch,
+					)
+				}
+
+			case ch <= 40 && ch >= 10:
+				if c.Battery.ChargeColor.AlmostEmpty == "" {
+					chStr = fmt.Sprintf(
+						"<span color='%s' background='%s' font='%s' size='%s'>% 3d%%</span>",
+						c.Battery.Color,
+						c.Battery.Background,
+						c.Battery.Font,
+						c.Battery.FontSize,
+						ch,
+					)
+				} else {
+					chStr = fmt.Sprintf(
+						`<span color='%s' background='%s' font='%s' size='%s'>% 3d%%</span>`,
+						c.Battery.ChargeColor.AlmostEmpty,
+						c.Battery.Background,
+						c.Battery.Font,
+						c.Battery.FontSize,
+						ch,
+					)
+				}
+
+			case ch < 10 && ch >= 0:
+				if c.Battery.ChargeColor.Empty == "" {
+					chStr = fmt.Sprintf(
+						"<span color='%s' background='%s' font='%s' size='%s'>% 3d%%</span>",
+						c.Battery.Color,
+						c.Battery.Background,
+						c.Battery.Font,
+						c.Battery.FontSize,
+						ch,
+					)
+				} else {
+					chStr = fmt.Sprintf(
+						`<span color='%s' background='%s' font='%s' size='%s'>% 3d%%</span>`,
+						c.Battery.ChargeColor.Empty,
+						c.Battery.Background,
+						c.Battery.Font,
+						c.Battery.FontSize,
+						ch,
+					)
+				}
+
+			default:
+				continue
+			}
+
+			battsInfo += fmt.Sprintf(
+				"<span color='%s' background='%s' font='%s' size='%s'>%s</span><span color='%s' background='%s' font='%s' size='%s'>B%d </span>%s<span color='%s' background='%s' font='%s' size='%s'> %s</span>",
+				c.Battery.Color,
+				c.Battery.Background,
+				c.Battery.SymbolFont,
+				c.Battery.SymbolFontSize,
+				c.Battery.Symbol,
+				c.Battery.Color,
+				c.Battery.Background,
+				c.Battery.Font,
+				c.Battery.FontSize,
+				i,
+				chStr,
+				c.Battery.Color,
+				c.Battery.Background,
+				c.Battery.Font,
+				c.Battery.FontSize,
+				status,
+			)
+		}
+
+		if battsInfo != "" {
+			Batts = battsInfo
+		}
+
+		if c.Values.BatteryString != Batts {
+			c.Values.BatteryString = Batts
+			c.Channels.UpdateReady <- true
+		}
+	}
+}

internal/lib/clock.go

@@ -1,16 +1,25 @@
-package main
+package lib
 
 import (
 	"fmt"
 	"time"
 )
 
-// Clock shows current date and time on i3bar.
-var Clock = "Thu, 1 Jan 1970   1:00"
-
 // UpdateClock get and updates (on i3bar) info about system clock.
-func UpdateClock() {
-	for {
+func (c *MyConfig) UpdateClock() {
+	var (
+		InitialDelay       = 100 * time.Millisecond
+		LoopIterationDelay = 1 * time.Second
+		Delay              = InitialDelay
+		ticker             = time.NewTicker(Delay)
+	)
+
+	for range ticker.C {
+		if Delay == InitialDelay {
+			Delay = LoopIterationDelay
+			ticker.Reset(Delay)
+		}
+
 		currentTime := time.Now()
 		hours, minutes, _ := currentTime.Clock()
 		year, month, day := currentTime.Date()
@@ -20,11 +29,9 @@ func UpdateClock() {
 
 		myclock := fmt.Sprintf("     %s, %d %s %d  % 2d:%02d  ", rdow[dow], day, rmonth[month-1], year, hours, minutes)
 
-		if myclock != Clock {
-			Clock = myclock
-			UpdateReady <- true
+		if myclock != c.Values.ClockTime {
+			c.Values.ClockTime = myclock
+			c.Channels.UpdateReady <- true
 		}
-
-		time.Sleep(1 * time.Second)
 	}
 }

internal/lib/collection.go

@@ -1,4 +1,4 @@
-package main
+package lib
 
 import (
 	"sync"
@@ -12,7 +12,7 @@ type Collection struct {
 
 // Item just interface for stoing any data.
 type item struct {
-	data interface{}
+	data any
 }
 
 // NewCollection creates new instance of "collection".
@@ -25,7 +25,7 @@ func NewCollection() *Collection {
 }
 
 // Get returns value by given key. Or empty value.
-func (collection *Collection) Get(key interface{}) (interface{}, bool) {
+func (collection *Collection) Get(key any) (any, bool) {
 	obj, exists := collection.items.Load(key)
 
 	if !exists {
@@ -38,15 +38,15 @@ func (collection *Collection) Get(key interface{}) (interface{}, bool) {
 }
 
 // Set saves value to given "collection".
-func (collection *Collection) Set(key interface{}, value interface{}) {
+func (collection *Collection) Set(key any, value any) {
 	collection.items.Store(key, item{
 		data: value,
 	})
 }
 
 // Range apply function f to all keys/values in collection. Retuns immediatly on first error.
-func (collection *Collection) Range(f func(key, value interface{}) bool) {
-	fn := func(key, value interface{}) bool {
+func (collection *Collection) Range(f func(key, value any) bool) {
+	fn := func(key, value any) bool {
 		item := value.(item)
 
 		return f(key, item.data)
@@ -56,7 +56,7 @@ func (collection *Collection) Range(f func(key, value interface{}) bool) {
 }
 
 // Delete deletes key and corresponding value from collection.
-func (collection *Collection) Delete(key interface{}) {
+func (collection *Collection) Delete(key any) {
 	collection.items.Delete(key)
 }
 

internal/lib/cputemp.go

@@ -1,4 +1,4 @@
-package main
+package lib
 
 import (
 	"bufio"
@@ -8,21 +8,29 @@ import (
 	"time"
 )
 
-// CPUTemperature stores average temperature among all cores.
-var CPUTemperature int64
-
 // UpdateCPUTemperature gets and updates average CPU cores temperature.
-func UpdateCPUTemperature() {
-	n := len(Conf.CPUTemp.File)
+func (c *MyConfig) UpdateCPUTemperature() {
+	var (
+		n                  = len(c.CPUTemp.File)
+		InitialDelay       = 100 * time.Millisecond
+		LoopIterationDelay = 3 * time.Second
+		Delay              = InitialDelay
+		ticker             = time.NewTicker(Delay)
+	)
 
-	for {
+	for range ticker.C {
 		var (
 			temperature = make([]int64, n)
 			tSum        int64
 			tAvg        int64
 		)
 
-		for i, filename := range Conf.CPUTemp.File {
+		if Delay == InitialDelay {
+			Delay = LoopIterationDelay
+			ticker.Reset(Delay)
+		}
+
+		for i, filename := range c.CPUTemp.File {
 			file, err := os.Open(filename)
 
 			if err != nil {
@@ -70,11 +78,9 @@ func UpdateCPUTemperature() {
 			tAvg = tSum / int64(len(temperature))
 		}
 
-		if CPUTemperature != tAvg {
-			CPUTemperature = tAvg
-			UpdateReady <- true
+		if c.Values.CPUTemperature != tAvg {
+			c.Values.CPUTemperature = tAvg
+			c.Channels.UpdateReady <- true
 		}
-
-		time.Sleep(3 * time.Second)
 	}
 }

internal/lib/cron.go

@@ -1,4 +1,4 @@
-package main
+package lib
 
 import (
 	"log"
@@ -10,7 +10,7 @@ import (
 var myCron gocron.Scheduler
 
 // RunCron parses config part, related to cron tasks and kicks cron to run.
-func RunCron() {
+func (c MyConfig) RunCron() {
 	var err error
 
 	myCron, err = gocron.NewScheduler()
@@ -21,14 +21,14 @@ func RunCron() {
 		return
 	}
 
-	for _, job := range Conf.Cron.Tasks {
+	for _, job := range c.Cron.Tasks {
 		_, err := myCron.NewJob(
 			gocron.CronJob(job.Time, false),
 			gocron.NewTask(
 				// Сука, просто заспавнить бинарь, ну почему это надо делать через жопу-то?
 				any(
 					func() bool {
-						RunChan <- job.Cmd
+						c.Channels.RunChan <- job.Cmd
 
 						return true
 					},

internal/lib/i3.go

@@ -1,4 +1,4 @@
-package main
+package lib
 
 import (
 	"log"
@@ -18,7 +18,7 @@ type WinList struct {
 var WL WinList
 
 // UpdateI3WinList subsribes to all window-related events and send them to I3EventParser() for more detailed parsing.
-func UpdateI3WinList() {
+func (c *MyConfig) UpdateI3WinList() {
 	// TODO: Здесь получить начальный список окон, управляемых i3wm (через GetTree()) и сложить их атрибутику в переменную WL
 	Tree, err := i3.GetTree()
 
@@ -26,20 +26,20 @@ func UpdateI3WinList() {
 		log.Printf("Unable to get list of windows: %s", err)
 	}
 
-	ExtractProps(Tree.Root)
+	c.ExtractProps(Tree.Root)
 
 	i3wm := i3.Subscribe(i3.WindowEventType)
 
 	for i3wm.Next() {
 		e := i3wm.Event().(*i3.WindowEvent)
-		go I3EventParser(e)
+		go c.I3EventParser(e)
 	}
 
 	log.Fatal(i3wm.Close())
 }
 
 // I3EventParser parses i3wm events and updates WL (aka Windows List).
-func I3EventParser(e *i3.WindowEvent) {
+func (c *MyConfig) I3EventParser(e *i3.WindowEvent) {
 	switch e.Change {
 	case "new":
 		var (
@@ -68,7 +68,7 @@ func I3EventParser(e *i3.WindowEvent) {
 		count++
 		WL.Instance.Set(e.Container.WindowProperties.Instance, count)
 
-		UpdateReady <- true
+		c.Channels.UpdateReady <- true
 
 	case "close":
 		countI, exist := WL.Class.Get(e.Container.WindowProperties.Class)
@@ -99,7 +99,7 @@ func I3EventParser(e *i3.WindowEvent) {
 			}
 		}
 
-		UpdateReady <- true
+		c.Channels.UpdateReady <- true
 	}
 }
 
@@ -152,10 +152,10 @@ func HasWindows(className string, instanceName string) bool {
 func FindWindowInstance(regexpStr string) bool {
 	var found = false
 
-	f := func(key interface{}, value interface{}) bool {
+	f := func(key any, value any) bool { //nolint: revive
 		keyStr := reflect.ValueOf(key).String()
 
-		re, err := regexp.Compile(regexpStr) //nolint:nolintlint, gocritic, we do not want shit our pants and panic on
+		re, err := regexp.Compile(regexpStr) // we do not want shit our pants and panic on
 		//        erroneous regexp, we want log it to stderr, that it.
 
 		if err != nil {
@@ -183,10 +183,10 @@ func FindWindowInstance(regexpStr string) bool {
 func FindWindowClass(regexpStr string) bool {
 	var found = false
 
-	f := func(key interface{}, value interface{}) bool {
+	f := func(key any, value any) bool { //nolint: revive
 		keyStr := reflect.ValueOf(key).String()
 
-		re, err := regexp.Compile(regexpStr) //nolint:nolintlint, gocritic, we do not want shit our pants and panic on
+		re, err := regexp.Compile(regexpStr) // we do not want shit our pants and panic on
 		//        erroneous regexp, we want log it to stderr, that it.
 
 		if err != nil {
@@ -210,18 +210,18 @@ func FindWindowClass(regexpStr string) bool {
 }
 
 // ExtractProps fills WL stricture collections with instance name and class name of given node (x11, that is).
-func ExtractProps(n *i3.Node) {
+func (c *MyConfig) ExtractProps(n *i3.Node) {
 	var e i3.WindowEvent
 	e.Change = "new"
 	e.Container = *n
 
-	I3EventParser(&e)
+	c.I3EventParser(&e)
 
 	for _, node := range n.Nodes {
-		ExtractProps(node)
+		c.ExtractProps(node)
 	}
 
 	for _, node := range n.FloatingNodes {
-		ExtractProps(node)
+		c.ExtractProps(node)
 	}
 }

internal/lib/ifmon.go

@@ -1,4 +1,4 @@
-package main
+package lib
 
 import (
 	"fmt"
@@ -9,15 +9,24 @@ import (
 	"time"
 )
 
-// IfStatus global var conaining cumulative status of all monitored net intefaces.
-var IfStatus string
-
 // UpdateIfStatus updates network interfaces status for i3bar.
-func UpdateIfStatus() {
-	for {
+func (c *MyConfig) UpdateIfStatus() {
+	var (
+		InitialDelay       = 100 * time.Millisecond
+		LoopIterationDelay = 3 * time.Second
+		Delay              = InitialDelay
+		ticker             = time.NewTicker(Delay)
+	)
+
+	for range ticker.C {
+		if Delay == InitialDelay {
+			Delay = LoopIterationDelay
+			ticker.Reset(Delay)
+		}
+
 		var statusSum string
 
-		for _, item := range Conf.NetIf.If {
+		for _, item := range c.NetIf.If {
 			var (
 				name = item.Name
 			)
@@ -35,10 +44,10 @@ func UpdateIfStatus() {
 			} else {
 				switch strings.TrimSpace(string(operstate)) {
 				case "up":
-					StatusStr := fmt.Sprintf("<span foreground=\"%s\">⍋</span>", Conf.NetIf.UpColor)
+					StatusStr := fmt.Sprintf("<span foreground=\"%s\">⍋</span>", c.NetIf.UpColor)
 					operstate = []byte(StatusStr)
 				case "down":
-					statusStr := fmt.Sprintf("<span foreground=\"%s\">⍒</span>", Conf.NetIf.DownColor)
+					statusStr := fmt.Sprintf("<span foreground=\"%s\">⍒</span>", c.NetIf.DownColor)
 					operstate = []byte(statusStr)
 				default:
 					operstate = []byte(`?`)
@@ -52,11 +61,9 @@ func UpdateIfStatus() {
 			statusSum += fmt.Sprintf("%s:%s", name, operstate)
 		}
 
-		if IfStatus != statusSum {
-			IfStatus = statusSum
-			UpdateReady <- true
+		if c.Values.IfStatus != statusSum {
+			c.Values.IfStatus = statusSum
+			c.Channels.UpdateReady <- true
 		}
-
-		time.Sleep(3 * time.Second)
 	}
 }

internal/lib/la.go

@@ -0,0 +1,34 @@
+package lib
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/shirou/gopsutil/load"
+)
+
+// UpdateLaStats вытаскивает показание LA за последнюю минуту.
+func (c *MyConfig) UpdateLaStats() {
+	var (
+		InitialDelay       = 100 * time.Millisecond
+		LoopIterationDelay = 3 * time.Second
+		Delay              = InitialDelay
+		ticker             = time.NewTicker(Delay)
+	)
+
+	for range ticker.C {
+		if Delay == InitialDelay {
+			Delay = LoopIterationDelay
+			ticker.Reset(Delay)
+		}
+
+		l, _ := load.Avg()
+
+		lav := fmt.Sprintf("%.2f", l.Load1)
+
+		if c.Values.La != lav {
+			c.Values.La = lav
+			c.Channels.UpdateReady <- true
+		}
+	}
+}

internal/lib/memory.go

@@ -0,0 +1,65 @@
+package lib
+
+import (
+	"log"
+	"time"
+
+	"github.com/shirou/gopsutil/mem"
+)
+
+// Mem struct with mem stats.
+type Mem struct {
+	Usedpct uint64
+	Shared  uint64
+	Swap    uint64
+}
+
+// UpdateMemStats parses mem info stats.
+func (c *MyConfig) UpdateMemStats() {
+	var (
+		InitialDelay       = 100 * time.Millisecond
+		LoopIterationDelay = 3 * time.Second
+		Delay              = InitialDelay
+		ticker             = time.NewTicker(Delay)
+	)
+
+	for range ticker.C {
+		if Delay == InitialDelay {
+			Delay = LoopIterationDelay
+			ticker.Reset(Delay)
+		}
+
+		v, err := mem.VirtualMemory()
+
+		if err != nil {
+			log.Printf("Unable to get memory statistics: %s", err)
+			time.Sleep(1 * time.Second)
+
+			continue
+		}
+
+		sw, err := mem.SwapMemory()
+
+		if err != nil {
+			log.Printf("Unable to get swap statistics: %s", err)
+			time.Sleep(1 * time.Second)
+
+			continue
+		}
+
+		if c.Mem.ShowSwap {
+			if c.Values.Memory.Usedpct != uint64(v.UsedPercent) || c.Values.Memory.Shared != v.Shared/1024/1024 || c.Values.Memory.Swap != v.SwapTotal-v.SwapFree {
+				c.Values.Memory.Usedpct = uint64(v.UsedPercent)
+				c.Values.Memory.Shared = v.Shared / 1024 / 1024
+				c.Values.Memory.Swap = sw.Used / 1024 / 1024
+				c.Channels.UpdateReady <- true
+			}
+		} else {
+			if c.Values.Memory.Usedpct != uint64(v.UsedPercent) || c.Values.Memory.Shared != v.Shared/1024/1024 {
+				c.Values.Memory.Usedpct = uint64(v.UsedPercent)
+				c.Values.Memory.Shared = v.Shared / 1024 / 1024
+				c.Channels.UpdateReady <- true
+			}
+		}
+	}
+}

internal/lib/pulseaudio.go

@@ -1,4 +1,4 @@
-package main
+package lib
 
 import (
 	"errors"
@@ -10,30 +10,25 @@ import (
 	p "github.com/mafik/pulseaudio"
 )
 
-var SoundVolume = "🔊:0%"
-var pa *p.Client
-
-var SVPAHandlerChan = make(chan ClickEvent, 256)
-
 // TODO: https://twin.sh/articles/44/add-a-timeout-to-any-function-in-go timeout pulseaudio calls
 
 // UpdateVolumeInfo updates info about current Sound Volume.
-func UpdateVolumeInfo() {
+func (c *MyConfig) UpdateVolumeInfo() {
 	var err error
 
-	pa, err = p.NewClient()
+	c.Values.PA, err = p.NewClient()
 
 	// It can happen if no pulseaudio server running for current user.
 	// If no server running we have to run one.
 	if err != nil {
-		if err := PaReinit(); err != nil {
+		if err := c.PaReinit(); err != nil {
 			log.Print(err)
 
 			return
 		}
 	}
 
-	vol, err := pa.Volume()
+	vol, err := c.Values.PA.Volume()
 
 	if err != nil {
 		log.Printf("Unable get volume from pulseaudio server: %s", err)
@@ -41,29 +36,29 @@ func UpdateVolumeInfo() {
 		return
 	}
 
-	SoundVolume = fmt.Sprintf(
+	c.Values.SoundVolume = fmt.Sprintf(
 		"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
-		Conf.SimpleVolumePa.Color,
-		Conf.SimpleVolumePa.Background,
-		Conf.SimpleVolumePa.SymbolFont,
-		Conf.SimpleVolumePa.SymbolFontSize,
-		Conf.SimpleVolumePa.Symbol,
+		c.SimpleVolumePa.Color,
+		c.SimpleVolumePa.Background,
+		c.SimpleVolumePa.SymbolFont,
+		c.SimpleVolumePa.SymbolFontSize,
+		c.SimpleVolumePa.Symbol,
 	)
 
-	SoundVolume += fmt.Sprintf(
+	c.Values.SoundVolume += fmt.Sprintf(
 		"<span color='%s' background='%s' font='%s' size='%s'>:%d%%</span>",
-		Conf.SimpleVolumePa.Color,
-		Conf.SimpleVolumePa.Background,
-		Conf.SimpleVolumePa.Font,
-		Conf.SimpleVolumePa.FontSize,
+		c.SimpleVolumePa.Color,
+		c.SimpleVolumePa.Background,
+		c.SimpleVolumePa.Font,
+		c.SimpleVolumePa.FontSize,
 		int64(vol*100),
 	)
 
-	UpdateReady <- true
+	c.Channels.UpdateReady <- true
 
 	for {
 		// Subscribe to update notification channel, to get info that volume changed.
-		pulseUpdate, err := pa.Updates()
+		pulseUpdate, err := c.Values.PA.Updates()
 
 		if err != nil {
 			log.Printf("Unable to subscribe to pulseaudio updates: %s", err)
@@ -73,7 +68,7 @@ func UpdateVolumeInfo() {
 
 		// Rake update events.
 		for range pulseUpdate {
-			vol, err = pa.Volume()
+			vol, err = c.Values.PA.Volume()
 
 			if err != nil {
 				log.Printf("Unable get volume from pulseaudio server: %s", err)
@@ -81,28 +76,28 @@ func UpdateVolumeInfo() {
 				return
 			}
 
-			SoundVolume = fmt.Sprintf(
+			c.Values.SoundVolume = fmt.Sprintf(
 				"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
-				Conf.SimpleVolumePa.Color,
-				Conf.SimpleVolumePa.Background,
-				Conf.SimpleVolumePa.SymbolFont,
-				Conf.SimpleVolumePa.SymbolFontSize,
-				Conf.SimpleVolumePa.Symbol,
+				c.SimpleVolumePa.Color,
+				c.SimpleVolumePa.Background,
+				c.SimpleVolumePa.SymbolFont,
+				c.SimpleVolumePa.SymbolFontSize,
+				c.SimpleVolumePa.Symbol,
 			)
 
-			SoundVolume += fmt.Sprintf(
+			c.Values.SoundVolume += fmt.Sprintf(
 				"<span color='%s' background='%s' font='%s' size='%s'>:%d%%</span>",
-				Conf.SimpleVolumePa.Color,
-				Conf.SimpleVolumePa.Background,
-				Conf.SimpleVolumePa.Font,
-				Conf.SimpleVolumePa.FontSize,
+				c.SimpleVolumePa.Color,
+				c.SimpleVolumePa.Background,
+				c.SimpleVolumePa.Font,
+				c.SimpleVolumePa.FontSize,
 				int64(vol*100),
 			)
 
-			UpdateReady <- true
+			c.Channels.UpdateReady <- true
 		}
 
-		if err := PaReinit(); err != nil {
+		if err := c.PaReinit(); err != nil {
 			log.Print(err)
 
 			return
@@ -110,11 +105,11 @@ func UpdateVolumeInfo() {
 	}
 
 	// This code is unreachable :(
-	pa.Close() //nolint:govet
+	c.Values.PA.Close() //nolint:govet
 }
 
 // PaReinit re-inits pulseaudio and connection to it.
-func PaReinit() error {
+func (c *MyConfig) PaReinit() error {
 	var err error
 
 	// If we out of updates, seems someone killed pulseaudio server. Restart it.
@@ -140,7 +135,7 @@ func PaReinit() error {
 			}
 
 			if cnt >= 5 {
-				return errors.New("timeout waiting pulseaudio to exit") //nolint: goerr113
+				return errors.New("timeout waiting pulseaudio to exit") //nolint: err113
 			}
 
 			log.Print("Waiting for pulseaudio to exit")
@@ -157,7 +152,7 @@ func PaReinit() error {
 	// This setting defines if pulseaudio will be run in manner that allows it to exit is other login detected (how
 	// they guess it - I do not know). In general case we do not want to allow pa to exit and leave our session without
 	// audio.
-	if Conf.SimpleVolumePa.DontExitOnLogin {
+	if c.SimpleVolumePa.DontExitOnLogin {
 		// Do not exit on any kind of login/logout events.
 		cmd = exec.Command("pulseaudio", "--exit-idle-time=-1", "--start")
 	} else {
@@ -169,7 +164,7 @@ func PaReinit() error {
 		return fmt.Errorf("unable to initialize pulseaudio server instance: %w", err)
 	}
 
-	pa, err = p.NewClient()
+	c.Values.PA, err = p.NewClient()
 
 	if err != nil {
 		return fmt.Errorf("unable to make client connection to pulseaudio: %w", err)
@@ -178,21 +173,21 @@ func PaReinit() error {
 	return err
 }
 
-func SVPAHandler() {
-	for e := range SVPAHandlerChan {
+func (c *MyConfig) SVPAHandler() {
+	for e := range c.Channels.SVPAHandlerChan {
 		if e.Button == 3 {
-			RunChan <- Conf.SimpleVolumePa.RightClickCmd
+			c.Channels.RunChan <- c.SimpleVolumePa.RightClickCmd
 
 			continue
 		}
 
-		vol, err := pa.Volume()
+		vol, err := c.Values.PA.Volume()
 
 		if err != nil {
-			if err := PaReinit(); err != nil {
+			if err := c.PaReinit(); err != nil {
 				log.Printf("Unable to get pulseaudio volume: %s", err)
 			} else {
-				vol, err = pa.Volume()
+				vol, err = c.Values.PA.Volume()
 
 				if err != nil {
 					log.Printf("Unable to get volume pulseaudio server behaves weirdly: %s", err)
@@ -201,25 +196,25 @@ func SVPAHandler() {
 		}
 
 		switch e.Button {
-		case Conf.SimpleVolumePa.WheelUp:
-			vol += float32(Conf.SimpleVolumePa.Step) / 100
+		case c.SimpleVolumePa.WheelUp:
+			vol += float32(c.SimpleVolumePa.Step) / 100
 
-			if vol > (float32(Conf.SimpleVolumePa.MaxVolumeLimit) / 100) {
-				vol = float32(Conf.SimpleVolumePa.MaxVolumeLimit) / 100
+			if vol > (float32(c.SimpleVolumePa.MaxVolumeLimit) / 100) {
+				vol = float32(c.SimpleVolumePa.MaxVolumeLimit) / 100
 			}
 
-			if err := pa.SetVolume(vol); err != nil {
+			if err := c.Values.PA.SetVolume(vol); err != nil {
 				log.Printf("Unable to set pulseaudio volume: %s", err)
 			}
 
-		case Conf.SimpleVolumePa.WheelDown:
-			vol -= float32(Conf.SimpleVolumePa.Step) / 100
+		case c.SimpleVolumePa.WheelDown:
+			vol -= float32(c.SimpleVolumePa.Step) / 100
 
 			if vol < 0 {
 				vol = 0
 			}
 
-			if err := pa.SetVolume(vol); err != nil {
+			if err := c.Values.PA.SetVolume(vol); err != nil {
 				log.Printf("Unable to set pulseaudio volume: %s", err)
 			}
 		}

internal/lib/runcommand.go

@@ -0,0 +1,41 @@
+package lib
+
+import (
+	"log"
+	"time"
+)
+
+// RunCommands gets list of commands runs them sequentally and conacatenates their output.
+func (c *MyConfig) RunCommand() {
+	var (
+		InitialDelay       = 100 * time.Millisecond
+		LoopIterationDelay = time.Duration(c.CmdRun.Delay) * time.Second
+		Delay              = InitialDelay
+		ticker             = time.NewTicker(Delay)
+	)
+
+	for range ticker.C {
+		if Delay == InitialDelay {
+			Delay = LoopIterationDelay
+			ticker.Reset(Delay)
+		}
+
+		var (
+			outputString string
+			command      = []string{c.CmdRun.Cmd}
+		)
+
+		if len(c.CmdRun.Args) > 0 {
+			command = append(command, c.CmdRun.Args...)
+		}
+
+		outputString += RunProcess(command)
+
+		log.Println(c.Values.RunCommandOutput)
+
+		if c.Values.RunCommandOutput != outputString {
+			c.Values.RunCommandOutput = outputString
+			c.Channels.UpdateReady <- true
+		}
+	}
+}

internal/lib/signal.go

@@ -1,4 +1,4 @@
-package main
+package lib
 
 import (
 	"log"
@@ -7,23 +7,25 @@ import (
 )
 
 var PrintOutput = true
-var sigChan = make(chan os.Signal, 1)
 
-// sigHandler OS signal handler.
-func sigHandler() {
-	for s := range sigChan {
+// SigHandler OS signal handler.
+func (c *MyConfig) SigHandler() {
+	for s := range c.Channels.SigChan {
 		switch s {
 		case syscall.SIGUSR1:
 			log.Print("Got SIGUSR1, stopping output")
 
-			PrintOutput = false
+			c.Values.PrintOutput = false
 
 		case syscall.SIGUSR2:
 			log.Print("Got SIGUSR2, resuming output")
 
-			PrintOutput = true
+			c.Values.PrintOutput = true
 
-			UpdateReady <- true
+			c.Channels.UpdateReady <- true
+
+		case syscall.SIGQUIT, syscall.SIGTERM, syscall.SIGINT:
+			os.Exit(0)
 
 		// We have signal that we're not interested in, so make a new loop iteration.
 		default:

internal/lib/spawn.go

@@ -0,0 +1,98 @@
+package lib
+
+import (
+	"bytes"
+	"log"
+	"os"
+	"os/exec"
+	"strings"
+	"syscall"
+	"time"
+)
+
+// Spawner forks and execs given program, and also detaches form its control tty.
+func (c *MyConfig) Spawner() {
+	for prg := range c.Channels.RunChan {
+		<-time.After(25 * time.Millisecond)
+
+		devnullR, _ := os.Open(os.DevNull)
+		devnullW, _ := os.OpenFile(os.DevNull, os.O_WRONLY|os.O_APPEND, 0644)
+
+		spa := syscall.SysProcAttr{
+			Setsid:     true,
+			Foreground: false,
+		}
+
+		pa := syscall.ProcAttr{
+			Dir:   os.Getenv(`HOME`),
+			Env:   os.Environ(),
+			Files: []uintptr{devnullR.Fd(), devnullW.Fd(), devnullW.Fd()},
+			Sys:   &spa,
+		}
+
+		bin, err := exec.LookPath(prg[0])
+
+		if err != nil {
+			log.Printf("Unable to spawn %s: %s", prg[0], err)
+		}
+
+		_, err = syscall.ForkExec(bin, prg, &pa)
+
+		if err != nil {
+			log.Printf("Unable to spawn %s: %s", prg[0], err)
+		}
+
+		// Close file errors we don't handle :) at all.
+		_ = devnullR.Close()
+		_ = devnullW.Close()
+	}
+}
+
+// CleanZombies reaps processes spawned by Spawner() and already exited.
+func (c *MyConfig) CleanZombies() {
+	r := syscall.Rusage{}
+
+	for {
+		_, _ = syscall.Wait4(-1, nil, 0, &r)
+
+		time.Sleep(1 * time.Minute)
+	}
+}
+
+// RunProcess runs given command and returns contens of command stdout. On error prints error on stderr and returns
+// empty syting.
+func RunProcess(command []string) string {
+	var (
+		cmd            *exec.Cmd
+		stdout, stderr bytes.Buffer
+	)
+
+	switch len(command) {
+	case 1:
+		cmd = exec.Command(command[0], "") //nolint: gosec
+	default:
+		cmd = exec.Command(command[0], command[1:]...) //nolint: gosec
+	}
+
+	cmd.Dir = "/"
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+
+	err := cmd.Run()
+
+	if err != nil {
+		if stdout.String() != "" {
+			log.Printf("Unable to run '%s': %s, %s", strings.Join(command, " "), err, stdout.String())
+		} else {
+			log.Printf("Unable to run '%s': %s", strings.Join(command, " "), err)
+		}
+
+		return ""
+	}
+
+	if stderr.String() != "" {
+		log.Printf("%s: %s", strings.Join(command, " "), stderr.String())
+	}
+
+	return strings.TrimRight(stdout.String(), "\n")
+}

internal/lib/stdin.go

@@ -1,4 +1,4 @@
-package main
+package lib
 
 import (
 	"bufio"
@@ -26,7 +26,7 @@ type ClickEvent struct {
 
 // ParseStdin tries to parse text that i3bar prints to our stdin. Currently - it is mouse click events on different
 // area names of i3bar.
-func ParseStdin() {
+func (c *MyConfig) ParseStdin() {
 	reader := bufio.NewReader(os.Stdin)
 
 	// De-facto it is jsonl, except first line is garbage. Also, first symbol in each strint garbage too.
@@ -84,35 +84,35 @@ func ParseStdin() {
 
 		// Clock clicks parse.
 		if e.Name == "wallclock" {
-			if Conf.Clock.LeftClick.Enabled && e.Button == 1 {
-				RunChan <- Conf.Clock.LeftClick.Cmd
-			} else if Conf.Clock.RightClick.Enabled && e.Button == 3 {
-				RunChan <- Conf.Clock.RightClick.Cmd
+			if c.Clock.LeftClick.Enabled && e.Button == 1 {
+				c.Channels.RunChan <- c.Clock.LeftClick.Cmd
+			} else if c.Clock.RightClick.Enabled && e.Button == 3 {
+				c.Channels.RunChan <- c.Clock.RightClick.Cmd
 			}
 
 			continue
 		}
 
 		if e.Name == "simple-volume-pa" {
-			if Conf.SimpleVolumePa.Enabled {
-				SVPAHandlerChan <- e
+			if c.SimpleVolumePa.Enabled {
+				c.Channels.SVPAHandlerChan <- e
 			}
 
 			continue
 		}
 
-		if !Conf.AppButtons.Enabled {
+		if !c.AppButtons.Enabled {
 			continue
 		}
 
-		for _, app := range Conf.Apps {
+		for _, app := range c.Apps {
 			switch {
 			case app.Name != "" && app.Instance != "":
 				if app.Name == e.Name && app.Instance == e.Instance {
 					prg := append([]string{}, app.Cmd)
 					prg = append(prg, app.Args...)
 
-					RunChan <- prg
+					c.Channels.RunChan <- prg
 
 					break
 				}
@@ -120,13 +120,13 @@ func ParseStdin() {
 				prg := append([]string{}, app.Cmd)
 				prg = append(prg, app.Args...)
 
-				RunChan <- prg
+				c.Channels.RunChan <- prg
 
 			case app.Instance != "" && e.Instance == app.Instance:
 				prg := append([]string{}, app.Cmd)
 				prg = append(prg, app.Args...)
 
-				RunChan <- prg
+				c.Channels.RunChan <- prg
 			}
 		}
 	}

internal/lib/vpn.go

@@ -0,0 +1,102 @@
+package lib
+
+import (
+	"fmt"
+	"net"
+	"os"
+	"time"
+)
+
+// UpdateVPNStatus periodically update status of openvpn daemon.
+func (c *MyConfig) UpdateVPNStatus() {
+	var (
+		vpnCStatus         string
+		tcpCheck           string
+		vpnCheck           string
+		InitialDelay       = 100 * time.Millisecond
+		LoopIterationDelay = 3 * time.Second
+		Delay              = InitialDelay
+		ticker             = time.NewTicker(Delay)
+	)
+
+	for range ticker.C {
+		if Delay == InitialDelay {
+			Delay = LoopIterationDelay
+			ticker.Reset(Delay)
+		}
+
+		if c.VPNFileCheck() {
+			if c.Vpn.UpColor == "" {
+				vpnCheck = `⍋`
+			} else {
+				vpnCheck = fmt.Sprintf(`<span foreground="%s">⍋</span>`, c.Vpn.UpColor)
+			}
+		} else {
+			if c.Vpn.DownColor == "" {
+				vpnCheck = `⍒`
+			} else {
+				vpnCheck = fmt.Sprintf(`<span foreground="%s">⍒</span>`, c.Vpn.DownColor)
+			}
+		}
+
+		if c.Vpn.TCPCheck.Enabled {
+			if c.VPNTCPCheck() {
+				if c.Vpn.UpColor == "" {
+					tcpCheck = `✔`
+				} else {
+					tcpCheck = fmt.Sprintf(`<span foreground="%s">✔</span>`, c.Vpn.UpColor)
+				}
+			} else {
+				if c.Vpn.DownColor == "" {
+					tcpCheck = `✘`
+				} else {
+					tcpCheck = fmt.Sprintf(`<span foreground="%s">✘</span>`, c.Vpn.DownColor)
+				}
+			}
+
+			vpnCStatus = fmt.Sprintf("VPN:%s:%s", vpnCheck, tcpCheck)
+		} else {
+			vpnCStatus = fmt.Sprintf("VPN:%s", vpnCheck)
+		}
+
+		if c.Values.VPNStatus != vpnCStatus {
+			c.Values.VPNStatus = vpnCStatus
+			c.Channels.UpdateReady <- true
+		}
+	}
+}
+
+// VPNTCPCheck intended to check arbitrary service inside vpn segment, to indicate that openvpn sevice not stoned.
+func (c *MyConfig) VPNTCPCheck() bool {
+	conn, err := net.DialTimeout(
+		"tcp",
+		fmt.Sprintf("%s:%d", c.Vpn.TCPCheck.Host, c.Vpn.TCPCheck.Port), //nolint: hostport
+		time.Second*time.Duration(c.Vpn.TCPCheck.Timeout),
+	)
+
+	if err == nil {
+		_ = conn.Close()
+
+		return true
+	}
+
+	return false
+}
+
+// VPNFileCheck checks modification time of openvpn-status file.
+func (c *MyConfig) VPNFileCheck() bool {
+	var (
+		fi  os.FileInfo
+		err error
+	)
+
+	if fi, err = os.Stat(c.Vpn.StatusFile); err != nil {
+		return false
+	}
+
+	if time.Since(fi.ModTime()).Seconds() > float64(c.Vpn.MtimeThreshold) {
+		return false
+	}
+
+	return true
+}

la.go

@@ -1,27 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"time"
-
-	"github.com/shirou/gopsutil/load"
-)
-
-// La переменная, хранящая значение LA за последнюю минуту.
-var La = "-1"
-
-// UpdateLaStats вытаскивает показание LA за последнюю минуту.
-func UpdateLaStats() {
-	for {
-		l, _ := load.Avg()
-
-		lav := fmt.Sprintf("%.2f", l.Load1)
-
-		if La != lav {
-			La = lav
-			UpdateReady <- true
-		}
-
-		time.Sleep(3 * time.Second)
-	}
-}

main.go

@@ -1,600 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"embed"
-	"encoding/json"
-	"fmt"
-	"log"
-	"os/signal"
-	"strings"
-	"syscall"
-)
-
-// I3BarOutBlock is structure element for I3BarOut, it represents i3bar output json block format.
-type I3BarOutBlock struct {
-	FullText string `json:"full_text"`
-	// ShortText will be shown if not enough room for FullText, threshold width defined in MinWidth
-	ShortText    string `json:"short_text,omitempty"`
-	Color        string `json:"color,omitempty"`
-	Background   string `json:"background,omitempty"`
-	Border       string `json:"border,omitempty"`
-	BorderTop    int    `json:"border_top"`
-	BorderRight  int    `json:"border_right"`
-	BorderBottom int    `json:"border_bottom"`
-	BorderLeft   int    `json:"border_left"`
-	// measured either in pixels or in characters, so either int or string, let's make it string :)
-	MinWidth            string `json:"min_width,omitempty"`
-	Align               string `json:"align,omitempty"`
-	Name                string `json:"name,omitempty"`
-	Instance            string `json:"instance,omitempty"`
-	Urgent              bool   `json:"urgent,omitempty"`
-	Separator           bool   `json:"separator"`
-	SeparatorBlockWidth int    `json:"separator_block_width"`
-	Markup              string `json:"markup,omitempty"`
-}
-
-// UpdateReady channel that "refreshes" i3bar (generates stdout json line).
-var UpdateReady = make(chan bool)
-var MsgChan = make(chan []I3BarOutBlock, 64)
-
-//go:embed i3status-go-example.json
-var EmbeddedDefaultConfig embed.FS
-var DefaultConfig []byte
-
-func init() {
-	DefaultConfig, _ = EmbeddedDefaultConfig.ReadFile("i3status-go-example.json")
-}
-
-// Program entry point.
-func main() {
-	var err error
-
-	Conf, err = readConf()
-
-	// TODO: Проставить дефолтные значения для глобальных переменных модулей.
-	Batt = fmt.Sprintf(
-		"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
-		Conf.Battery.Color,
-		Conf.Battery.Background,
-		Conf.Battery.SymbolFont,
-		Conf.Battery.SymbolFontSize,
-		Conf.Battery.Symbol,
-	)
-
-	Batt += fmt.Sprintf(
-		"<span color='%s' background='%s' font='%s' size='%s'> ??%% •</span>",
-		Conf.Battery.Color,
-		Conf.Battery.Background,
-		Conf.Battery.Font,
-		Conf.Battery.FontSize,
-	)
-
-	SoundVolume = fmt.Sprintf(
-		"<span color='%s' background='%s' font='%s' size='%s'>🔊</span>",
-		Conf.SimpleVolumePa.Color,
-		Conf.SimpleVolumePa.Background,
-		Conf.SimpleVolumePa.SymbolFont,
-		Conf.SimpleVolumePa.SymbolFontSize,
-	)
-
-	SoundVolume += fmt.Sprintf(
-		"<span color='%s' background='%s' font='%s' size='%s'>:0%%</span>",
-		Conf.SimpleVolumePa.Color,
-		Conf.SimpleVolumePa.Background,
-		Conf.SimpleVolumePa.Font,
-		Conf.SimpleVolumePa.FontSize,
-	)
-
-	Clock = fmt.Sprintf(
-		"<span color='%s' background='%s' font='%s' size='%s'>Thu, 1 Jan 1970   1:00</span>",
-		Conf.Clock.Color,
-		Conf.Clock.Background,
-		Conf.Clock.Font,
-		Conf.Clock.FontSize,
-	)
-
-	if err != nil {
-		log.Panicln(err)
-	}
-
-	go Spawner()
-	go ParseStdin()
-	go CleanZombies()
-	go SVPAHandler()
-	go PrintToI3bar()
-
-	if Conf.AppButtons.Enabled {
-		go UpdateI3WinList()
-	}
-
-	// Kick signal handler
-	go sigHandler()
-	signal.Notify(sigChan,
-		syscall.SIGUSR1,
-		syscall.SIGUSR2)
-
-	// Populate memory stats
-	if Conf.Mem.Enabled {
-		go UpdateMemStats()
-	}
-
-	// Populate LA stats
-	if Conf.LA.Enabled {
-		go UpdateLaStats()
-	}
-
-	// Populate CPUTemperature
-	if Conf.CPUTemp.Enabled {
-		go UpdateCPUTemperature()
-	}
-
-	// Populate Clock
-	if Conf.Clock.Enabled {
-		go UpdateClock()
-	}
-
-	if Conf.Battery.Enabled {
-		go UpdateBatteryInfo()
-	}
-
-	if Conf.SimpleVolumePa.Enabled {
-		go UpdateVolumeInfo()
-	}
-
-	if Conf.NetIf.Enabled {
-		go UpdateIfStatus()
-	}
-
-	if Conf.Cron.Enabled {
-		go RunCron()
-	}
-
-	if Conf.Vpn.Enabled {
-		go UpdateVPNStatus()
-	}
-
-	/*
-		I3bar documentation pretends that message protocol must be valid json. In practice, we only have to print valid
-		header, empty json array and (potentially infinite) json lines (line that is valid json by itself) that is
-		actually json arrays. We do not need to *close* this json at all.
-		Gracefully closed json required when i3bar initiates our program to stop|quit, this (should) happens just before
-		i3bar itself terminating. So we don't care.
-	*/
-
-	// Print header and one empty message and wait for updates
-	fmt.Printf(
-		"{\"version\": 1, \"stop_signal\": %d, \"cont_signal\": %d, \"click_events\": true}\n",
-		syscall.SIGUSR1,
-		syscall.SIGUSR2,
-	)
-
-	fmt.Println("[ [],")
-
-	for {
-		if <-UpdateReady {
-			// Actually build json struct, marshal it and print result
-			var j []I3BarOutBlock
-
-			// TODO: впилить для первого и последнего батона separator
-			if Conf.AppButtons.Enabled {
-				for num, app := range Conf.Apps {
-					var b I3BarOutBlock
-
-					if num == 0 {
-						b.FullText = fmt.Sprintf(
-							"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
-							Conf.AppButtons.Separator.Left.Color,
-							Conf.AppButtons.Separator.Left.Background,
-							Conf.AppButtons.Separator.Left.Font,
-							Conf.AppButtons.Separator.Left.FontSize,
-							Conf.AppButtons.Separator.Left.Symbol,
-						)
-					}
-
-					b.FullText = app.FullText
-
-					if num == len(Conf.Apps) {
-						b.FullText = fmt.Sprintf(
-							"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
-							Conf.AppButtons.Separator.Right.Color,
-							Conf.AppButtons.Separator.Right.Background,
-							Conf.AppButtons.Separator.Right.Font,
-							Conf.AppButtons.Separator.Right.FontSize,
-							Conf.AppButtons.Separator.Right.Symbol,
-						)
-					}
-
-					b.Background = app.Background
-					b.Color = app.Color
-					b.Instance = app.Instance
-					b.Markup = `pango`
-					b.Separator = app.Separator
-					b.SeparatorBlockWidth = app.SeparatorBlockWidth
-					b.Name = app.Name
-
-					if HasWindows(app.Class, app.Instance) {
-						b.Border = app.BorderActive
-					} else {
-						b.Border = app.Border
-					}
-
-					b.BorderTop = 1
-					b.BorderRight = 1
-					b.BorderBottom = 1
-					b.BorderLeft = 1
-
-					j = append(j, b)
-				}
-			}
-
-			if Conf.CPUTemp.Enabled {
-				var b I3BarOutBlock
-
-				b.Color = Conf.CPUTemp.Color
-				b.Background = Conf.CPUTemp.Background
-
-				if Conf.CPUTemp.Separator.Left.Enabled {
-					b.FullText = fmt.Sprintf(
-						"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
-						Conf.CPUTemp.Separator.Left.Color,
-						Conf.CPUTemp.Separator.Left.Background,
-						Conf.CPUTemp.Separator.Left.Font,
-						Conf.CPUTemp.Separator.Left.FontSize,
-						Conf.CPUTemp.Separator.Left.Symbol,
-					)
-				}
-
-				b.FullText += fmt.Sprintf(
-					"<span color='%s' background='%s' font='%s' size='%s'>CPU: %d°</span>",
-					Conf.CPUTemp.Color,
-					Conf.CPUTemp.Background,
-					Conf.CPUTemp.Font,
-					Conf.CPUTemp.FontSize,
-					CPUTemperature,
-				)
-
-				if Conf.CPUTemp.Separator.Right.Enabled {
-					b.FullText += fmt.Sprintf(
-						"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
-						Conf.CPUTemp.Separator.Right.Color,
-						Conf.CPUTemp.Separator.Right.Background,
-						Conf.CPUTemp.Separator.Right.Font,
-						Conf.CPUTemp.Separator.Right.FontSize,
-						Conf.CPUTemp.Separator.Right.Symbol,
-					)
-				}
-
-				b.Markup = "pango"
-				b.Separator = false
-
-				j = append(j, b)
-			}
-
-			if Conf.Mem.Enabled {
-				var b I3BarOutBlock
-
-				b.Color = Conf.Mem.Color
-				b.Background = Conf.Mem.Background
-
-				if Conf.Mem.Separator.Left.Enabled {
-					b.FullText = fmt.Sprintf(
-						"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
-						Conf.Mem.Separator.Left.Color,
-						Conf.Mem.Separator.Left.Background,
-						Conf.Mem.Separator.Left.Font,
-						Conf.Mem.Separator.Left.FontSize,
-						Conf.Mem.Separator.Left.Symbol,
-					)
-				}
-
-				if Conf.Mem.ShowSwap {
-					b.FullText += fmt.Sprintf(
-						"<span color='%s' background='%s' font='%s' size='%s'>M:%d%% SHM:%dM SW:%dM</span>",
-						Conf.Mem.Color,
-						Conf.Mem.Background,
-						Conf.Mem.Font,
-						Conf.Mem.FontSize,
-						Memory.Usedpct,
-						Memory.Shared,
-						Memory.Swap,
-					)
-				} else {
-					b.FullText += fmt.Sprintf(
-						"<span color='%s' background='%s' font='%s' size='%s'>M:%d%% SHM:%dM</span>",
-						Conf.Mem.Color,
-						Conf.Mem.Background,
-						Conf.Mem.Font,
-						Conf.Mem.FontSize,
-						Memory.Usedpct,
-						Memory.Shared,
-					)
-				}
-
-				if Conf.Mem.Separator.Right.Enabled {
-					b.FullText += fmt.Sprintf(
-						"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
-						Conf.Mem.Separator.Right.Color,
-						Conf.Mem.Separator.Right.Background,
-						Conf.Mem.Separator.Right.Font,
-						Conf.Mem.Separator.Right.FontSize,
-						Conf.Mem.Separator.Right.Symbol,
-					)
-				}
-
-				b.Markup = "pango"
-				b.Separator = false
-
-				j = append(j, b)
-			}
-
-			if Conf.LA.Enabled {
-				var b I3BarOutBlock
-
-				b.Color = Conf.LA.Color
-				b.Background = Conf.LA.Background
-
-				if Conf.LA.Separator.Left.Enabled {
-					b.FullText = fmt.Sprintf(
-						"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
-						Conf.LA.Separator.Left.Color,
-						Conf.LA.Separator.Left.Background,
-						Conf.LA.Separator.Left.Font,
-						Conf.LA.Separator.Left.FontSize,
-						Conf.LA.Separator.Left.Symbol,
-					)
-				}
-
-				b.FullText += fmt.Sprintf(
-					"<span color='%s' background='%s' font='%s' size='%s'>LA:%s</span>",
-					Conf.LA.Color,
-					Conf.LA.Background,
-					Conf.LA.Font,
-					Conf.LA.FontSize,
-					La,
-				)
-
-				if Conf.LA.Separator.Right.Enabled {
-					b.FullText += fmt.Sprintf(
-						"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
-						Conf.LA.Separator.Right.Color,
-						Conf.LA.Separator.Right.Background,
-						Conf.LA.Separator.Right.Font,
-						Conf.LA.Separator.Right.FontSize,
-						Conf.LA.Separator.Right.Symbol,
-					)
-				}
-
-				b.Markup = "pango"
-				b.Separator = false
-
-				j = append(j, b)
-			}
-
-			if Conf.NetIf.Enabled {
-				var b I3BarOutBlock
-
-				b.Color = Conf.NetIf.Color
-				b.Background = Conf.NetIf.Background
-
-				if Conf.NetIf.Separator.Left.Enabled {
-					b.FullText = fmt.Sprintf(
-						"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
-						Conf.NetIf.Separator.Left.Color,
-						Conf.NetIf.Separator.Left.Background,
-						Conf.NetIf.Separator.Left.Font,
-						Conf.NetIf.Separator.Left.FontSize,
-						Conf.NetIf.Separator.Left.Symbol,
-					)
-				}
-
-				b.FullText += fmt.Sprintf(
-					"<span color='%s' background='%s' font='%s' size= '%s'>%s</span>",
-					Conf.NetIf.Color,
-					Conf.NetIf.Background,
-					Conf.NetIf.Font,
-					Conf.NetIf.FontSize,
-					IfStatus,
-				)
-
-				if Conf.NetIf.Separator.Right.Enabled {
-					b.FullText += fmt.Sprintf(
-						"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
-						Conf.NetIf.Separator.Right.Color,
-						Conf.NetIf.Separator.Right.Background,
-						Conf.NetIf.Separator.Right.Font,
-						Conf.NetIf.Separator.Right.FontSize,
-						Conf.NetIf.Separator.Right.Symbol,
-					)
-				}
-
-				b.Markup = "pango"
-				b.Separator = false
-
-				j = append(j, b)
-			}
-
-			if Conf.Vpn.Enabled {
-				var b I3BarOutBlock
-
-				b.Color = Conf.Vpn.Color
-				b.Background = Conf.Vpn.Background
-
-				if Conf.Vpn.Separator.Left.Enabled {
-					b.FullText = fmt.Sprintf(
-						"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
-						Conf.Vpn.Separator.Left.Color,
-						Conf.Vpn.Separator.Left.Background,
-						Conf.Vpn.Separator.Left.Font,
-						Conf.Vpn.Separator.Left.FontSize,
-						Conf.Vpn.Separator.Left.Symbol,
-					)
-				}
-
-				b.FullText += fmt.Sprintf(
-					"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
-					Conf.Vpn.Color,
-					Conf.Vpn.Background,
-					Conf.Vpn.Font,
-					Conf.Vpn.FontSize,
-					VPNStatus,
-				)
-
-				if Conf.Vpn.Separator.Right.Enabled {
-					b.FullText += fmt.Sprintf(
-						"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
-						Conf.Vpn.Separator.Right.Color,
-						Conf.Vpn.Separator.Right.Background,
-						Conf.Vpn.Separator.Right.Font,
-						Conf.Vpn.Separator.Right.FontSize,
-						Conf.Vpn.Separator.Right.Symbol,
-					)
-				}
-
-				b.Markup = "pango"
-				b.Separator = false
-
-				j = append(j, b)
-			}
-
-			if Conf.Battery.Enabled {
-				var b I3BarOutBlock
-
-				b.Color = Conf.Battery.Color
-				b.Background = Conf.Battery.Background
-
-				if Conf.Battery.Separator.Left.Enabled {
-					b.FullText = fmt.Sprintf(
-						"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
-						Conf.Battery.Separator.Left.Color,
-						Conf.Battery.Separator.Left.Background,
-						Conf.Battery.Separator.Left.Font,
-						Conf.Battery.Separator.Left.FontSize,
-						Conf.Battery.Separator.Left.Symbol,
-					)
-				}
-
-				b.FullText += Batt
-
-				if Conf.Battery.Separator.Right.Enabled {
-					b.FullText += fmt.Sprintf(
-						"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
-						Conf.Battery.Separator.Right.Color,
-						Conf.Battery.Separator.Right.Background,
-						Conf.Battery.Separator.Right.Font,
-						Conf.Battery.Separator.Right.FontSize,
-						Conf.Battery.Separator.Right.Symbol,
-					)
-				}
-
-				b.Markup = "pango"
-				b.Separator = false
-
-				j = append(j, b)
-			}
-
-			if Conf.SimpleVolumePa.Enabled {
-				var b I3BarOutBlock
-
-				b.Name = "simple-volume-pa"
-				b.Color = Conf.SimpleVolumePa.Color
-				b.Background = Conf.SimpleVolumePa.Background
-
-				if Conf.SimpleVolumePa.Separator.Left.Enabled {
-					b.FullText = fmt.Sprintf(
-						"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
-						Conf.SimpleVolumePa.Separator.Left.Color,
-						Conf.SimpleVolumePa.Separator.Left.Background,
-						Conf.SimpleVolumePa.Separator.Left.Font,
-						Conf.SimpleVolumePa.Separator.Left.FontSize,
-						Conf.SimpleVolumePa.Separator.Left.Symbol,
-					)
-				}
-
-				// Pango format is already applied in plugin src.
-				b.FullText += SoundVolume
-
-				if Conf.SimpleVolumePa.Separator.Right.Enabled {
-					b.FullText += fmt.Sprintf(
-						"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
-						Conf.SimpleVolumePa.Separator.Right.Color,
-						Conf.SimpleVolumePa.Separator.Right.Background,
-						Conf.SimpleVolumePa.Separator.Right.Font,
-						Conf.SimpleVolumePa.Separator.Right.FontSize,
-						Conf.SimpleVolumePa.Separator.Right.Symbol,
-					)
-				}
-
-				b.Markup = "pango"
-				b.Separator = false
-
-				j = append(j, b)
-			}
-
-			if Conf.Clock.Enabled {
-				var b I3BarOutBlock
-
-				b.Name = `wallclock`
-				b.Color = Conf.Clock.Color
-				b.Background = Conf.Clock.Background
-
-				if Conf.Clock.Separator.Left.Enabled {
-					b.FullText = fmt.Sprintf(
-						"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
-						Conf.Clock.Separator.Left.Color,
-						Conf.Clock.Separator.Left.Background,
-						Conf.Clock.Separator.Left.Font,
-						Conf.Clock.Separator.Left.FontSize,
-						Conf.Clock.Separator.Left.Symbol,
-					)
-				}
-
-				b.FullText += fmt.Sprintf(
-					"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
-					Conf.Clock.Color,
-					Conf.Clock.Background,
-					Conf.Clock.Font,
-					Conf.Clock.FontSize,
-					Clock,
-				)
-
-				if Conf.Clock.Separator.Right.Enabled {
-					b.FullText += fmt.Sprintf(
-						"<span color='%s' background='%s' font='%s' size='%s'>%s</span>",
-						Conf.Clock.Separator.Right.Color,
-						Conf.Clock.Separator.Right.Background,
-						Conf.Clock.Separator.Right.Font,
-						Conf.Clock.Separator.Right.FontSize,
-						Conf.Clock.Separator.Right.Symbol,
-					)
-				}
-
-				b.Markup = "pango"
-				b.Separator = false
-
-				j = append(j, b)
-			}
-
-			if PrintOutput && len(j) > 0 {
-				MsgChan <- j
-			}
-		}
-	}
-}
-
-// PrintToI3bar prints info to stdout according to ipc docs (https://i3wm.org/docs/i3bar-protocol.html)
-func PrintToI3bar() {
-	for message := range MsgChan {
-		// we do not need to html-encode output, json.Marshal does this forcefully, so invent our own Marshal
-		buf := new(bytes.Buffer)
-		encoder := json.NewEncoder(buf)
-		encoder.SetEscapeHTML(false)
-		err := encoder.Encode(message)
-
-		if err != nil {
-			log.Printf("Unable to json-encode message, %s\n", err)
-		}
-
-		fmt.Println(strings.TrimSuffix(buf.String(), "\n") + ",")
-	}
-}

memory.go

@@ -1,59 +0,0 @@
-package main
-
-import (
-	"log"
-	"time"
-
-	"github.com/shirou/gopsutil/mem"
-)
-
-// Mem struct with mem stats.
-type Mem struct {
-	Usedpct uint64
-	Shared  uint64
-	Swap    uint64
-}
-
-// Memory stores string with mem stats for i3bar.
-var Memory Mem
-
-// UpdateMemStats parses mem info stats.
-func UpdateMemStats() {
-	for {
-		v, err := mem.VirtualMemory()
-
-		if err != nil {
-			log.Printf("Unable to get memory statistics: %s", err)
-			time.Sleep(1 * time.Second)
-
-			continue
-		}
-
-		sw, err := mem.SwapMemory()
-
-		if err != nil {
-			log.Printf("Unable to get swap statistics: %s", err)
-			time.Sleep(1 * time.Second)
-
-			continue
-		}
-
-		if Conf.Mem.ShowSwap {
-			if Memory.Usedpct != uint64(v.UsedPercent) || Memory.Shared != v.Shared/1024/1024 ||
-				Memory.Swap != v.SwapTotal-v.SwapFree {
-				Memory.Usedpct = uint64(v.UsedPercent)
-				Memory.Shared = v.Shared / 1024 / 1024
-				Memory.Swap = sw.Used
-				UpdateReady <- true
-			}
-		} else {
-			if Memory.Usedpct != uint64(v.UsedPercent) || Memory.Shared != v.Shared/1024/1024 {
-				Memory.Usedpct = uint64(v.UsedPercent)
-				Memory.Shared = v.Shared / 1024 / 1024
-				UpdateReady <- true
-			}
-		}
-
-		time.Sleep(3 * time.Second)
-	}
-}

spawn.go

@@ -1,59 +0,0 @@
-package main
-
-import (
-	"log"
-	"os"
-	"os/exec"
-	"syscall"
-	"time"
-)
-
-// RunChan to this channel we send command and its argv to execute as separate process.
-var RunChan = make(chan []string, 128)
-
-// Spawn forks and execs given program, and also detaches form its control tty.
-func Spawner() {
-	for prg := range RunChan {
-		devnullR, _ := os.Open(os.DevNull)
-		devnullW, _ := os.OpenFile(os.DevNull, os.O_WRONLY|os.O_APPEND, 0644)
-
-		spa := syscall.SysProcAttr{
-			Setsid:     true,
-			Foreground: false,
-		}
-
-		pa := syscall.ProcAttr{
-			Dir:   os.Getenv(`HOME`),
-			Env:   os.Environ(),
-			Files: []uintptr{devnullR.Fd(), devnullW.Fd(), devnullW.Fd()},
-			Sys:   &spa,
-		}
-
-		bin, err := exec.LookPath(prg[0])
-
-		if err != nil {
-			log.Printf("Unable to spawn %s: %s", prg[0], err)
-		}
-
-		_, err = syscall.ForkExec(bin, prg, &pa)
-
-		if err != nil {
-			log.Printf("Unable to spawn %s: %s", prg[0], err)
-		}
-
-		// Close file errors we don't handle :) at all.
-		_ = devnullR.Close()
-		_ = devnullW.Close()
-	}
-}
-
-// CleanZombies reaps processes spawned by Spawner() and already exited.
-func CleanZombies() {
-	r := syscall.Rusage{}
-
-	for {
-		_, _ = syscall.Wait4(-1, nil, 0, &r)
-
-		time.Sleep(1 * time.Minute)
-	}
-}

vendor/github.com/adrg/xdg/README.md

@@ -7,8 +7,8 @@
 <h4 align="center">Go implementation of the XDG Base Directory Specification and XDG user directories.</h4>
 
 <p align="center">
-    <a href="https://github.com/adrg/xdg/actions?query=workflow%3ACI">
-        <img alt="Build status" src="https://github.com/adrg/xdg/workflows/CI/badge.svg">
+    <a href="https://github.com/adrg/xdg/actions/workflows/tests.yml">
+        <img alt="Tests status" src="https://github.com/adrg/xdg/actions/workflows/tests.yml/badge.svg">
     </a>
     <a href="https://app.codecov.io/gh/adrg/xdg">
         <img alt="Code coverage" src="https://codecov.io/gh/adrg/xdg/branch/master/graphs/badge.svg?branch=master">
@@ -41,8 +41,9 @@ Provides an implementation of the [XDG Base Directory Specification](https://spe
 The specification defines a set of standard paths for storing application files,
 including data and configuration files. For portability and flexibility reasons,
 applications should use the XDG defined locations instead of hardcoding paths.
-The package also includes the locations of well known [user directories](https://wiki.archlinux.org/index.php/XDG_user_directories), as well as
-other common directories such as fonts and applications.
+
+The package also includes the locations of well known [user directories](https://wiki.archlinux.org/index.php/XDG_user_directories),
+support for the non-standard `XDG_BIN_HOME` directory, as well as other common directories such as fonts and applications.
 
 The current implementation supports **most flavors of Unix**, **Windows**, **macOS** and **Plan 9**.  
 On Windows, where XDG environment variables are not usually set, the package uses [Known Folders](https://docs.microsoft.com/en-us/windows/win32/shell/known-folders)
@@ -58,7 +59,7 @@ See usage [examples](#usage) below. Full documentation can be found at https://p
 The package defines sensible defaults for XDG variables which are empty or not
 present in the environment.
 
-- On Unix-like operating systems, XDG environment variables are tipically defined.
+- On Unix-like operating systems, XDG environment variables are typically defined.
 Appropriate default locations are used for the environment variables which are not set.
 - On Windows, XDG environment variables are usually not set. If that is the case,
 the package relies on the appropriate [Known Folders](https://docs.microsoft.com/en-us/windows/win32/shell/knownfolderid).
@@ -70,15 +71,16 @@ Sensible fallback locations are used for the folders which are not set.
     <summary><strong>Unix-like operating systems</strong></summary>
     <br/>
 
-| <a href="#xdg-base-directory"><img width="400" height="0"></a> | <a href="#xdg-base-directory"><img width="500" height="0"></a><p>Unix</p> | <a href="#xdg-base-directory"><img width="600" height="0"></a><p>macOS</p>                                            | <a href="#xdg-base-directory"><img width="500" height="0"></a><p>Plan 9</p> |
-| :------------------------------------------------------------: | :-----------------------------------------------------------------------: | :-------------------------------------------------------------------------------------------------------------------: | :-------------------------------------------------------------------------: |
-| <kbd><b>XDG_DATA_HOME</b></kbd>                                | <kbd>~/.local/share</kbd>                                                 | <kbd>~/Library/Application&nbsp;Support</kbd>                                                                         | <kbd>$home/lib</kbd>                                                        |
-| <kbd><b>XDG_DATA_DIRS</b></kbd>                                | <kbd>/usr/local/share</kbd><br/><kbd>/usr/share</kbd>                     | <kbd>/Library/Application&nbsp;Support</kbd>                                                                          | <kbd>/lib</kbd>                                                             |
-| <kbd><b>XDG_CONFIG_HOME</b></kbd>                              | <kbd>~/.config</kbd>                                                      | <kbd>~/Library/Application&nbsp;Support</kbd>                                                                         | <kbd>$home/lib</kbd>                                                        |
-| <kbd><b>XDG_CONFIG_DIRS</b></kbd>                              | <kbd>/etc/xdg</kbd>                                                       | <kbd>~/Library/Preferences</kbd><br/><kbd>/Library/Application&nbsp;Support</kbd><br/><kbd>/Library/Preferences</kbd> | <kbd>/lib</kbd>                                                             |
-| <kbd><b>XDG_STATE_HOME</b></kbd>                               | <kbd>~/.local/state</kbd>                                                 | <kbd>~/Library/Application&nbsp;Support</kbd>                                                                         | <kbd>$home/lib/state</kbd>                                                  |
-| <kbd><b>XDG_CACHE_HOME</b></kbd>                               | <kbd>~/.cache</kbd>                                                       | <kbd>~/Library/Caches</kbd>                                                                                           | <kbd>$home/lib/cache</kbd>                                                  |
-| <kbd><b>XDG_RUNTIME_DIR</b></kbd>                              | <kbd>/run/user/UID</kbd>                                                  | <kbd>~/Library/Application&nbsp;Support</kbd>                                                                         | <kbd>/tmp</kbd>                                                             |
+| <a href="#xdg-base-directory"><img width="400" height="0"></a> | <a href="#xdg-base-directory"><img width="500" height="0"></a><p>Unix</p> | <a href="#xdg-base-directory"><img width="600" height="0"></a><p>macOS</p>                                                                          | <a href="#xdg-base-directory"><img width="500" height="0"></a><p>Plan 9</p> |
+| :------------------------------------------------------------: | :-----------------------------------------------------------------------: | :-------------------------------------------------------------------------------------------------------------------------------------------------: | :-------------------------------------------------------------------------: |
+| <kbd><b>XDG_DATA_HOME</b></kbd>                                | <kbd>~/.local/share</kbd>                                                 | <kbd>~/Library/Application&nbsp;Support</kbd>                                                                                                       | <kbd>$home/lib</kbd>                                                        |
+| <kbd><b>XDG_DATA_DIRS</b></kbd>                                | <kbd>/usr/local/share</kbd><br/><kbd>/usr/share</kbd>                     | <kbd>/Library/Application&nbsp;Support</kbd><kbd>~/.local/share</kbd>                                                                               | <kbd>/lib</kbd>                                                             |
+| <kbd><b>XDG_CONFIG_HOME</b></kbd>                              | <kbd>~/.config</kbd>                                                      | <kbd>~/Library/Application&nbsp;Support</kbd>                                                                                                       | <kbd>$home/lib</kbd>                                                        |
+| <kbd><b>XDG_CONFIG_DIRS</b></kbd>                              | <kbd>/etc/xdg</kbd>                                                       | <kbd>~/Library/Preferences</kbd><br/><kbd>/Library/Application&nbsp;Support</kbd><br/><kbd>/Library/Preferences</kbd><br/><kbd>&#126;/.config</kbd> | <kbd>/lib</kbd>                                                             |
+| <kbd><b>XDG_STATE_HOME</b></kbd>                               | <kbd>~/.local/state</kbd>                                                 | <kbd>~/Library/Application&nbsp;Support</kbd>                                                                                                       | <kbd>$home/lib/state</kbd>                                                  |
+| <kbd><b>XDG_CACHE_HOME</b></kbd>                               | <kbd>~/.cache</kbd>                                                       | <kbd>~/Library/Caches</kbd>                                                                                                                         | <kbd>$home/lib/cache</kbd>                                                  |
+| <kbd><b>XDG_RUNTIME_DIR</b></kbd>                              | <kbd>/run/user/$UID</kbd>                                                 | <kbd>~/Library/Application&nbsp;Support</kbd>                                                                                                       | <kbd>/tmp</kbd>                                                             |
+| <kbd><b>XDG_BIN_HOME</b></kbd>                                 | <kbd>~/.local/bin</kbd>                                                   | <kbd>~/.local/bin</kbd>                                                                                                                             | <kbd>$home/bin</kbd>                                                        |
 
 </details>
 
@@ -95,11 +97,23 @@ Sensible fallback locations are used for the folders which are not set.
 | <kbd><b>XDG_STATE_HOME</b></kbd>                               | <kbd>LocalAppData</kbd>                                                                   | <kbd>%LOCALAPPDATA%</kbd>                                                        |
 | <kbd><b>XDG_CACHE_HOME</b></kbd>                               | <kbd>LocalAppData\cache</kbd>                                                             | <kbd>%LOCALAPPDATA%\cache</kbd>                                                  |
 | <kbd><b>XDG_RUNTIME_DIR</b></kbd>                              | <kbd>LocalAppData</kbd>                                                                   | <kbd>%LOCALAPPDATA%</kbd>                                                        |
+| <kbd><b>XDG_BIN_HOME</b></kbd>                                 | <kbd>UserProgramFiles</kbd>                                                               | <kbd>%LOCALAPPDATA%\Programs</kbd>                                               |
 
 </details>
 
 ### XDG user directories
 
+XDG user directories environment variables are usually **not** set on most
+operating systems. However, if they are present in the environment, they take
+precedence. Appropriate fallback locations are used for the environment
+variables which are not set.
+
+- On Unix-like operating systems (except macOS and Plan 9), the package reads the [user-dirs.dirs](https://man.archlinux.org/man/user-dirs.dirs.5.en) config file.
+- On Windows, the package uses the appropriate [Known Folders](https://docs.microsoft.com/en-us/windows/win32/shell/knownfolderid).
+
+Lastly, default locations are used for any user directories which are not set,
+as shown in the following tables.
+
 <details open>
     <summary><strong>Unix-like operating systems</strong></summary>
     <br/>
@@ -152,11 +166,11 @@ Sensible fallback locations are used for the folders which are not set.
     <summary><strong>Microsoft Windows</strong></summary>
     <br/>
 
-| <a href="#other-directories"><img width="400" height="0"></a> | <a href="#other-directories"><img width="300" height="0"></a><p>Known&nbsp;Folder(s)</p> | <a href="#other-directories"><img width="1300" height="0"></a><p>Fallback(s)</p>                                                        |
-| :-----------------------------------------------------------: | :--------------------------------------------------------------------------------------: | :-------------------------------------------------------------------------------------------------------------------------------------: |
-| <kbd><b>Home</b></kbd>                                        | <kbd>Profile</kbd>                                                                       | <kbd>%USERPROFILE%</kbd>                                                                                                                |
-| <kbd><b>Applications</b></kbd>                                | <kbd>Programs</kbd><br/><kbd>CommonPrograms</kbd>                                        | <kbd>%APPDATA%\Microsoft\Windows\Start&nbsp;Menu\Programs</kbd><br/><kbd>%ProgramData%\Microsoft\Windows\Start&nbsp;Menu\Programs</kbd> |
-| <kbd><b>Fonts</b></kbd>                                       | <kbd>Fonts</kbd><br/><kbd>-</kbd>                                                        | <kbd>%SystemRoot%\Fonts</kbd><br/><kbd>%LOCALAPPDATA%\Microsoft\Windows\Fonts</kbd>                                                     |
+| <a href="#other-directories"><img width="400" height="0"></a> | <a href="#other-directories"><img width="300" height="0"></a><p>Known&nbsp;Folder(s)</p>                                                                                               | <a href="#other-directories"><img width="1300" height="0"></a><p>Fallback(s)</p>                                                                                                                                                                                                                     |
+| :-----------------------------------------------------------: | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: |
+| <kbd><b>Home</b></kbd>                                        | <kbd>Profile</kbd>                                                                                                                                                                     | <kbd>%USERPROFILE%</kbd>                                                                                                                                                                                                                                                                             |
+| <kbd><b>Applications</b></kbd>                                | <kbd>Programs</kbd><br/><kbd>CommonPrograms</kbd> <br/><kbd>ProgramFiles</kbd><br/><kbd>ProgramFilesCommon</kbd><br/><kbd>UserProgramFiles</kbd><br/><kbd>UserProgramFilesCommon</kbd> | <kbd>%APPDATA%\Microsoft\Windows\Start&nbsp;Menu\Programs</kbd><br/><kbd>%ProgramData%\Microsoft\Windows\Start&nbsp;Menu\Programs</kbd><br/><kbd>%ProgramFiles%</kbd><br/><kbd>%ProgramFiles%\Common Files</kbd><br/><kbd>%LOCALAPPDATA%\Programs</kbd><br/><kbd>%LOCALAPPDATA%\Programs\Common</kbd>|
+| <kbd><b>Fonts</b></kbd>                                       | <kbd>Fonts</kbd>                                                                                                                                                                       | <kbd>%SystemRoot%\Fonts</kbd><br/><kbd>%LOCALAPPDATA%\Microsoft\Windows\Fonts</kbd>                                                                                                                                                                                                                  |
 
 </details>
 
@@ -182,6 +196,7 @@ func main() {
 	log.Println("Home state directory:", xdg.StateHome)
 	log.Println("Cache directory:", xdg.CacheHome)
 	log.Println("Runtime directory:", xdg.RuntimeDir)
+	log.Println("Home binaries directory:", xdg.BinHome)
 
 	// Other common directories.
 	log.Println("Home directory:", xdg.Home)
@@ -192,6 +207,9 @@ func main() {
 	// ConfigFile takes one parameter which must contain the name of the file,
 	// but it can also contain a set of parent directories. If the directories
 	// don't exist, they will be created relative to the base config directory.
+	// It is recommended for files to be saved inside an application directory
+	// relative to the base directory rather than directly inside the base
+	// directory (e.g. `appname/config.yaml` instead of `appname-config.yaml`).
 	configFilePath, err := xdg.ConfigFile("appname/config.yaml")
 	if err != nil {
 		log.Fatal(err)
@@ -263,7 +281,11 @@ See [CONTRIBUTING.MD](CONTRIBUTING.md).
 [gabriel-vasile](https://github.com/gabriel-vasile),
 [KalleDK](https://github.com/KalleDK),
 [nvkv](https://github.com/nvkv),
-[djdv](https://github.com/djdv).
+[djdv](https://github.com/djdv),
+[rrjjvv](https://github.com/rrjjvv),
+[GreyXor](https://github.com/GreyXor),
+[Rican7](https://github.com/Rican7),
+[nothub](https://github.com/nothub).
 
 ## References
 

vendor/github.com/adrg/xdg/base_dirs.go

@@ -1,6 +1,10 @@
 package xdg
 
-import "github.com/adrg/xdg/internal/pathutil"
+import (
+	"os"
+
+	"github.com/adrg/xdg/internal/pathutil"
+)
 
 // XDG Base Directory environment variables.
 const (
@@ -11,6 +15,9 @@ const (
 	envStateHome  = "XDG_STATE_HOME"
 	envCacheHome  = "XDG_CACHE_HOME"
 	envRuntimeDir = "XDG_RUNTIME_DIR"
+
+	// Non-standard.
+	envBinHome = "XDG_BIN_HOME"
 )
 
 type baseDirectories struct {
@@ -22,7 +29,8 @@ type baseDirectories struct {
 	cacheHome  string
 	runtime    string
 
-	// Non-standard directories.
+	// Non-standard.
+	binHome      string
 	fonts        []string
 	applications []string
 }
@@ -44,7 +52,13 @@ func (bd baseDirectories) cacheFile(relPath string) (string, error) {
 }
 
 func (bd baseDirectories) runtimeFile(relPath string) (string, error) {
-	return pathutil.Create(relPath, []string{bd.runtime})
+	var paths []string
+	for _, p := range pathutil.Unique([]string{bd.runtime, os.TempDir()}) {
+		if pathutil.Exists(p) {
+			paths = append(paths, p)
+		}
+	}
+	return pathutil.Create(relPath, paths)
 }
 
 func (bd baseDirectories) searchDataFile(relPath string) (string, error) {
@@ -64,5 +78,5 @@ func (bd baseDirectories) searchCacheFile(relPath string) (string, error) {
 }
 
 func (bd baseDirectories) searchRuntimeFile(relPath string) (string, error) {
-	return pathutil.Search(relPath, []string{bd.runtime})
+	return pathutil.Search(relPath, pathutil.Unique([]string{bd.runtime, os.TempDir()}))
 }

vendor/github.com/adrg/xdg/doc.go

@@ -16,9 +16,10 @@ The current implementation supports most flavors of Unix, Windows, Mac OS and Pl
 	For more information regarding the Windows Known Folders see:
 	https://docs.microsoft.com/en-us/windows/win32/shell/known-folders
 
-Usage
+# Usage
 
 XDG Base Directory
+
 	package main
 
 	import (
@@ -36,6 +37,7 @@ XDG Base Directory
 		log.Println("Home state directory:", xdg.StateHome)
 		log.Println("Cache directory:", xdg.CacheHome)
 		log.Println("Runtime directory:", xdg.RuntimeDir)
+		log.Println("Home binaries directory:", xdg.BinHome)
 
 		// Other common directories.
 		log.Println("Home directory:", xdg.Home)
@@ -46,6 +48,9 @@ XDG Base Directory
 		// ConfigFile takes one parameter which must contain the name of the file,
 		// but it can also contain a set of parent directories. If the directories
 		// don't exist, they will be created relative to the base config directory.
+		// It is recommended for files to be saved inside an application directory
+		// relative to the base directory rather than directly inside the base
+		// directory (e.g. `appname/config.yaml` instead of `appname-config.yaml`).
 		configFilePath, err := xdg.ConfigFile("appname/config.yaml")
 		if err != nil {
 			log.Fatal(err)
@@ -76,6 +81,7 @@ XDG Base Directory
 	}
 
 XDG user directories
+
 	package main
 
 	import (

vendor/github.com/adrg/xdg/internal/pathutil/pathutil.go

@@ -4,22 +4,20 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
-	"strings"
 )
 
 // Unique eliminates the duplicate paths from the provided slice and returns
-// the result. The items in the output slice are in the order in which they
-// occur in the input slice. If a `home` location is provided, the paths are
-// expanded using the `ExpandHome` function.
-func Unique(paths []string, home string) []string {
+// the result. The paths are expanded using the `ExpandHome` function and only
+// absolute paths are kept. The items in the output slice are in the order in
+// which they occur in the input slice.
+func Unique(paths []string) []string {
 	var (
 		uniq     []string
 		registry = map[string]struct{}{}
 	)
 
 	for _, p := range paths {
-		p = ExpandHome(p, home)
-		if p != "" && filepath.IsAbs(p) {
+		if p = ExpandHome(p); p != "" && filepath.IsAbs(p) {
 			if _, ok := registry[p]; ok {
 				continue
 			}
@@ -32,6 +30,18 @@ func Unique(paths []string, home string) []string {
 	return uniq
 }
 
+// First returns the first absolute path from the provided slice.
+// The paths in the input slice are expanded using the `ExpandHome` function.
+func First(paths []string) string {
+	for _, p := range paths {
+		if p = ExpandHome(p); p != "" && filepath.IsAbs(p) {
+			return p
+		}
+	}
+
+	return ""
+}
+
 // Create returns a suitable location relative to which the file with the
 // specified `name` can be written. The first path from the provided `paths`
 // slice which is successfully created (or already exists) is used as a base
@@ -40,7 +50,7 @@ func Unique(paths []string, home string) []string {
 // it can also contain a set of parent directories, which will be created
 // relative to the selected parent path.
 func Create(name string, paths []string) (string, error) {
-	var searchedPaths []string
+	searchedPaths := make([]string, 0, len(paths))
 	for _, p := range paths {
 		p = filepath.Join(p, name)
 
@@ -48,22 +58,22 @@ func Create(name string, paths []string) (string, error) {
 		if Exists(dir) {
 			return p, nil
 		}
-		if err := os.MkdirAll(dir, os.ModeDir|0700); err == nil {
+		if err := os.MkdirAll(dir, os.ModeDir|0o700); err == nil {
 			return p, nil
 		}
 
 		searchedPaths = append(searchedPaths, dir)
 	}
 
-	return "", fmt.Errorf("could not create any of the following paths: %s",
-		strings.Join(searchedPaths, ", "))
+	return "", fmt.Errorf("could not create any of the following paths: %v",
+		searchedPaths)
 }
 
 // Search searches for the file with the specified `name` in the provided
 // slice of `paths`. The `name` parameter must contain the name of the file,
 // but it can also contain a set of parent directories.
 func Search(name string, paths []string) (string, error) {
-	var searchedPaths []string
+	searchedPaths := make([]string, 0, len(paths))
 	for _, p := range paths {
 		p = filepath.Join(p, name)
 		if Exists(p) {
@@ -73,6 +83,32 @@ func Search(name string, paths []string) (string, error) {
 		searchedPaths = append(searchedPaths, filepath.Dir(p))
 	}
 
-	return "", fmt.Errorf("could not locate `%s` in any of the following paths: %s",
-		filepath.Base(name), strings.Join(searchedPaths, ", "))
+	return "", fmt.Errorf("could not locate `%s` in any of the following paths: %v",
+		filepath.Base(name), searchedPaths)
+}
+
+// EnvPath returns the value of the environment variable with the specified
+// `name` if it is an absolute path, or the first absolute fallback path.
+// All paths are expanded using the `ExpandHome` function.
+func EnvPath(name string, fallbackPaths ...string) string {
+	dir := ExpandHome(os.Getenv(name))
+	if dir != "" && filepath.IsAbs(dir) {
+		return dir
+	}
+
+	return First(fallbackPaths)
+}
+
+// EnvPathList reads the value of the environment variable with the specified
+// `name` and attempts to extract a list of absolute paths from it. If there
+// are none, a list of absolute fallback paths is returned instead. Duplicate
+// paths are removed from the returned slice. All paths are expanded using the
+// `ExpandHome` function.
+func EnvPathList(name string, fallbackPaths ...string) []string {
+	dirs := Unique(filepath.SplitList(os.Getenv(name)))
+	if len(dirs) != 0 {
+		return dirs
+	}
+
+	return Unique(fallbackPaths)
 }

vendor/github.com/adrg/xdg/internal/pathutil/pathutil_plan9.go

@@ -1,20 +1,31 @@
 package pathutil
 
 import (
+	"errors"
+	"io/fs"
 	"os"
 	"path/filepath"
 	"strings"
 )
 
+// UserHomeDir returns the home directory of the current user.
+func UserHomeDir() string {
+	if home := os.Getenv("home"); home != "" {
+		return home
+	}
+
+	return "/"
+}
+
 // Exists returns true if the specified path exists.
 func Exists(path string) bool {
 	_, err := os.Stat(path)
-	return err == nil || os.IsExist(err)
+	return err == nil || errors.Is(err, fs.ErrExist)
 }
 
-// ExpandHome substitutes `~` and `$home` at the start of the specified
-// `path` using the provided `home` location.
-func ExpandHome(path, home string) string {
+// ExpandHome substitutes `~` and `$home` at the start of the specified `path`.
+func ExpandHome(path string) string {
+	home := UserHomeDir()
 	if path == "" || home == "" {
 		return path
 	}

vendor/github.com/adrg/xdg/internal/pathutil/pathutil_unix.go

@@ -1,23 +1,33 @@
 //go:build aix || darwin || dragonfly || freebsd || (js && wasm) || nacl || linux || netbsd || openbsd || solaris
-// +build aix darwin dragonfly freebsd js,wasm nacl linux netbsd openbsd solaris
 
 package pathutil
 
 import (
+	"errors"
+	"io/fs"
 	"os"
 	"path/filepath"
 	"strings"
 )
 
+// UserHomeDir returns the home directory of the current user.
+func UserHomeDir() string {
+	if home := os.Getenv("HOME"); home != "" {
+		return home
+	}
+
+	return "/"
+}
+
 // Exists returns true if the specified path exists.
 func Exists(path string) bool {
 	_, err := os.Stat(path)
-	return err == nil || os.IsExist(err)
+	return err == nil || errors.Is(err, fs.ErrExist)
 }
 
-// ExpandHome substitutes `~` and `$HOME` at the start of the specified
-// `path` using the provided `home` location.
-func ExpandHome(path, home string) string {
+// ExpandHome substitutes `~` and `$HOME` at the start of the specified `path`.
+func ExpandHome(path string) string {
+	home := UserHomeDir()
 	if path == "" || home == "" {
 		return path
 	}

vendor/github.com/adrg/xdg/internal/pathutil/pathutil_windows.go

@@ -1,6 +1,8 @@
 package pathutil
 
 import (
+	"errors"
+	"io/fs"
 	"os"
 	"path/filepath"
 	"strings"
@@ -8,6 +10,11 @@ import (
 	"golang.org/x/sys/windows"
 )
 
+// UserHomeDir returns the home directory of the current user.
+func UserHomeDir() string {
+	return KnownFolder(windows.FOLDERID_Profile, []string{"USERPROFILE"}, nil)
+}
+
 // Exists returns true if the specified path exists.
 func Exists(path string) bool {
 	fi, err := os.Lstat(path)
@@ -15,12 +22,12 @@ func Exists(path string) bool {
 		_, err = filepath.EvalSymlinks(path)
 	}
 
-	return err == nil || os.IsExist(err)
+	return err == nil || errors.Is(err, fs.ErrExist)
 }
 
-// ExpandHome substitutes `%USERPROFILE%` at the start of the specified
-// `path` using the provided `home` location.
-func ExpandHome(path, home string) string {
+// ExpandHome substitutes `%USERPROFILE%` at the start of the specified `path`.
+func ExpandHome(path string) string {
+	home := UserHomeDir()
 	if path == "" || home == "" {
 		return path
 	}

vendor/github.com/adrg/xdg/internal/userdirs/config_unix.go

@@ -0,0 +1,82 @@
+//go:build aix || dragonfly || freebsd || (js && wasm) || nacl || linux || netbsd || openbsd || solaris
+
+package userdirs
+
+import (
+	"bufio"
+	"io"
+	"os"
+	"strings"
+
+	"github.com/adrg/xdg/internal/pathutil"
+)
+
+// ParseConfigFile parses the user directories config file at the
+// specified location.
+func ParseConfigFile(name string) (*Directories, error) {
+	f, err := os.Open(name)
+	if err != nil {
+		return nil, err
+	}
+	defer f.Close()
+
+	return ParseConfig(f)
+}
+
+// ParseConfig parses the user directories config file contained in
+// the provided reader.
+func ParseConfig(r io.Reader) (*Directories, error) {
+	dirs := &Directories{}
+	fieldsMap := map[string]*string{
+		EnvDesktopDir:     &dirs.Desktop,
+		EnvDownloadDir:    &dirs.Download,
+		EnvDocumentsDir:   &dirs.Documents,
+		EnvMusicDir:       &dirs.Music,
+		EnvPicturesDir:    &dirs.Pictures,
+		EnvVideosDir:      &dirs.Videos,
+		EnvTemplatesDir:   &dirs.Templates,
+		EnvPublicShareDir: &dirs.PublicShare,
+	}
+
+	scanner := bufio.NewScanner(r)
+	for scanner.Scan() {
+		line := strings.TrimSpace(scanner.Text())
+		if len(line) == 0 || line[0] == '#' {
+			continue
+		}
+		if !strings.HasPrefix(line, "XDG_") {
+			continue
+		}
+
+		parts := strings.Split(line, "=")
+		if len(parts) < 2 {
+			continue
+		}
+
+		// Parse key.
+		field, ok := fieldsMap[strings.TrimSpace(parts[0])]
+		if !ok {
+			continue
+		}
+
+		// Parse value.
+		runes := []rune(strings.TrimSpace(parts[1]))
+
+		lenRunes := len(runes)
+		if lenRunes <= 2 || runes[0] != '"' {
+			continue
+		}
+
+		for i := 1; i < lenRunes; i++ {
+			if runes[i] == '"' {
+				*field = pathutil.ExpandHome(string(runes[1:i]))
+				break
+			}
+		}
+	}
+	if err := scanner.Err(); err != nil {
+		return nil, err
+	}
+
+	return dirs, nil
+}

vendor/github.com/adrg/xdg/internal/userdirs/userdirs.go

@@ -1,19 +1,19 @@
-package xdg
+package userdirs
 
 // XDG user directories environment variables.
 const (
-	envDesktopDir     = "XDG_DESKTOP_DIR"
-	envDownloadDir    = "XDG_DOWNLOAD_DIR"
-	envDocumentsDir   = "XDG_DOCUMENTS_DIR"
-	envMusicDir       = "XDG_MUSIC_DIR"
-	envPicturesDir    = "XDG_PICTURES_DIR"
-	envVideosDir      = "XDG_VIDEOS_DIR"
-	envTemplatesDir   = "XDG_TEMPLATES_DIR"
-	envPublicShareDir = "XDG_PUBLICSHARE_DIR"
+	EnvDesktopDir     = "XDG_DESKTOP_DIR"
+	EnvDownloadDir    = "XDG_DOWNLOAD_DIR"
+	EnvDocumentsDir   = "XDG_DOCUMENTS_DIR"
+	EnvMusicDir       = "XDG_MUSIC_DIR"
+	EnvPicturesDir    = "XDG_PICTURES_DIR"
+	EnvVideosDir      = "XDG_VIDEOS_DIR"
+	EnvTemplatesDir   = "XDG_TEMPLATES_DIR"
+	EnvPublicShareDir = "XDG_PUBLICSHARE_DIR"
 )
 
-// UserDirectories defines the locations of well known user directories.
-type UserDirectories struct {
+// Directories defines the locations of well known user directories.
+type Directories struct {
 	// Desktop defines the location of the user's desktop directory.
 	Desktop string
 

vendor/github.com/adrg/xdg/paths_darwin.go

@@ -1,18 +1,12 @@
 package xdg
 
 import (
-	"os"
 	"path/filepath"
+
+	"github.com/adrg/xdg/internal/pathutil"
+	"github.com/adrg/xdg/internal/userdirs"
 )
 
-func homeDir() string {
-	if home := os.Getenv("HOME"); home != "" {
-		return home
-	}
-
-	return "/"
-}
-
 func initDirs(home string) {
 	initBaseDirs(home)
 	initUserDirs(home)
@@ -23,19 +17,25 @@ func initBaseDirs(home string) {
 	rootAppSupport := "/Library/Application Support"
 
 	// Initialize standard directories.
-	baseDirs.dataHome = xdgPath(envDataHome, homeAppSupport)
-	baseDirs.data = xdgPaths(envDataDirs, rootAppSupport)
-	baseDirs.configHome = xdgPath(envConfigHome, homeAppSupport)
-	baseDirs.config = xdgPaths(envConfigDirs,
+	baseDirs.dataHome = pathutil.EnvPath(envDataHome, homeAppSupport)
+	baseDirs.data = pathutil.EnvPathList(envDataDirs,
+		rootAppSupport,
+		filepath.Join(home, ".local", "share"),
+	)
+	baseDirs.configHome = pathutil.EnvPath(envConfigHome, homeAppSupport)
+	baseDirs.config = pathutil.EnvPathList(envConfigDirs,
 		filepath.Join(home, "Library", "Preferences"),
 		rootAppSupport,
 		"/Library/Preferences",
+		filepath.Join(home, ".config"),
 	)
-	baseDirs.stateHome = xdgPath(envStateHome, homeAppSupport)
-	baseDirs.cacheHome = xdgPath(envCacheHome, filepath.Join(home, "Library", "Caches"))
-	baseDirs.runtime = xdgPath(envRuntimeDir, homeAppSupport)
+	baseDirs.stateHome = pathutil.EnvPath(envStateHome, homeAppSupport)
+	baseDirs.cacheHome = pathutil.EnvPath(envCacheHome, filepath.Join(home, "Library", "Caches"))
+	baseDirs.runtime = pathutil.EnvPath(envRuntimeDir, homeAppSupport)
 
 	// Initialize non-standard directories.
+	baseDirs.binHome = pathutil.EnvPath(envBinHome, filepath.Join(home, ".local", "bin"))
+
 	baseDirs.applications = []string{
 		"/Applications",
 	}
@@ -49,12 +49,12 @@ func initBaseDirs(home string) {
 }
 
 func initUserDirs(home string) {
-	UserDirs.Desktop = xdgPath(envDesktopDir, filepath.Join(home, "Desktop"))
-	UserDirs.Download = xdgPath(envDownloadDir, filepath.Join(home, "Downloads"))
-	UserDirs.Documents = xdgPath(envDocumentsDir, filepath.Join(home, "Documents"))
-	UserDirs.Music = xdgPath(envMusicDir, filepath.Join(home, "Music"))
-	UserDirs.Pictures = xdgPath(envPicturesDir, filepath.Join(home, "Pictures"))
-	UserDirs.Videos = xdgPath(envVideosDir, filepath.Join(home, "Movies"))
-	UserDirs.Templates = xdgPath(envTemplatesDir, filepath.Join(home, "Templates"))
-	UserDirs.PublicShare = xdgPath(envPublicShareDir, filepath.Join(home, "Public"))
+	UserDirs.Desktop = pathutil.EnvPath(userdirs.EnvDesktopDir, filepath.Join(home, "Desktop"))
+	UserDirs.Download = pathutil.EnvPath(userdirs.EnvDownloadDir, filepath.Join(home, "Downloads"))
+	UserDirs.Documents = pathutil.EnvPath(userdirs.EnvDocumentsDir, filepath.Join(home, "Documents"))
+	UserDirs.Music = pathutil.EnvPath(userdirs.EnvMusicDir, filepath.Join(home, "Music"))
+	UserDirs.Pictures = pathutil.EnvPath(userdirs.EnvPicturesDir, filepath.Join(home, "Pictures"))
+	UserDirs.Videos = pathutil.EnvPath(userdirs.EnvVideosDir, filepath.Join(home, "Movies"))
+	UserDirs.Templates = pathutil.EnvPath(userdirs.EnvTemplatesDir, filepath.Join(home, "Templates"))
+	UserDirs.PublicShare = pathutil.EnvPath(userdirs.EnvPublicShareDir, filepath.Join(home, "Public"))
 }

vendor/github.com/adrg/xdg/paths_plan9.go

@@ -1,18 +1,12 @@
 package xdg
 
 import (
-	"os"
 	"path/filepath"
+
+	"github.com/adrg/xdg/internal/pathutil"
+	"github.com/adrg/xdg/internal/userdirs"
 )
 
-func homeDir() string {
-	if home := os.Getenv("home"); home != "" {
-		return home
-	}
-
-	return "/"
-}
-
 func initDirs(home string) {
 	initBaseDirs(home)
 	initUserDirs(home)
@@ -23,15 +17,17 @@ func initBaseDirs(home string) {
 	rootLibDir := "/lib"
 
 	// Initialize standard directories.
-	baseDirs.dataHome = xdgPath(envDataHome, homeLibDir)
-	baseDirs.data = xdgPaths(envDataDirs, rootLibDir)
-	baseDirs.configHome = xdgPath(envConfigHome, homeLibDir)
-	baseDirs.config = xdgPaths(envConfigDirs, rootLibDir)
-	baseDirs.stateHome = xdgPath(envStateHome, filepath.Join(homeLibDir, "state"))
-	baseDirs.cacheHome = xdgPath(envCacheHome, filepath.Join(homeLibDir, "cache"))
-	baseDirs.runtime = xdgPath(envRuntimeDir, "/tmp")
+	baseDirs.dataHome = pathutil.EnvPath(envDataHome, homeLibDir)
+	baseDirs.data = pathutil.EnvPathList(envDataDirs, rootLibDir)
+	baseDirs.configHome = pathutil.EnvPath(envConfigHome, homeLibDir)
+	baseDirs.config = pathutil.EnvPathList(envConfigDirs, rootLibDir)
+	baseDirs.stateHome = pathutil.EnvPath(envStateHome, filepath.Join(homeLibDir, "state"))
+	baseDirs.cacheHome = pathutil.EnvPath(envCacheHome, filepath.Join(homeLibDir, "cache"))
+	baseDirs.runtime = pathutil.EnvPath(envRuntimeDir, "/tmp")
 
 	// Initialize non-standard directories.
+	baseDirs.binHome = pathutil.EnvPath(envBinHome, filepath.Join(home, "bin"))
+
 	baseDirs.applications = []string{
 		filepath.Join(home, "bin"),
 		"/bin",
@@ -44,12 +40,12 @@ func initBaseDirs(home string) {
 }
 
 func initUserDirs(home string) {
-	UserDirs.Desktop = xdgPath(envDesktopDir, filepath.Join(home, "desktop"))
-	UserDirs.Download = xdgPath(envDownloadDir, filepath.Join(home, "downloads"))
-	UserDirs.Documents = xdgPath(envDocumentsDir, filepath.Join(home, "documents"))
-	UserDirs.Music = xdgPath(envMusicDir, filepath.Join(home, "music"))
-	UserDirs.Pictures = xdgPath(envPicturesDir, filepath.Join(home, "pictures"))
-	UserDirs.Videos = xdgPath(envVideosDir, filepath.Join(home, "videos"))
-	UserDirs.Templates = xdgPath(envTemplatesDir, filepath.Join(home, "templates"))
-	UserDirs.PublicShare = xdgPath(envPublicShareDir, filepath.Join(home, "public"))
+	UserDirs.Desktop = pathutil.EnvPath(userdirs.EnvDesktopDir, filepath.Join(home, "desktop"))
+	UserDirs.Download = pathutil.EnvPath(userdirs.EnvDownloadDir, filepath.Join(home, "downloads"))
+	UserDirs.Documents = pathutil.EnvPath(userdirs.EnvDocumentsDir, filepath.Join(home, "documents"))
+	UserDirs.Music = pathutil.EnvPath(userdirs.EnvMusicDir, filepath.Join(home, "music"))
+	UserDirs.Pictures = pathutil.EnvPath(userdirs.EnvPicturesDir, filepath.Join(home, "pictures"))
+	UserDirs.Videos = pathutil.EnvPath(userdirs.EnvVideosDir, filepath.Join(home, "videos"))
+	UserDirs.Templates = pathutil.EnvPath(userdirs.EnvTemplatesDir, filepath.Join(home, "templates"))
+	UserDirs.PublicShare = pathutil.EnvPath(userdirs.EnvPublicShareDir, filepath.Join(home, "public"))
 }

vendor/github.com/adrg/xdg/paths_unix.go

@@ -1,5 +1,4 @@
 //go:build aix || dragonfly || freebsd || (js && wasm) || nacl || linux || netbsd || openbsd || solaris
-// +build aix dragonfly freebsd js,wasm nacl linux netbsd openbsd solaris
 
 package xdg
 
@@ -9,32 +8,27 @@ import (
 	"strconv"
 
 	"github.com/adrg/xdg/internal/pathutil"
+	"github.com/adrg/xdg/internal/userdirs"
 )
 
-func homeDir() string {
-	if home := os.Getenv("HOME"); home != "" {
-		return home
-	}
-
-	return "/"
-}
-
 func initDirs(home string) {
 	initBaseDirs(home)
-	initUserDirs(home)
+	initUserDirs(home, baseDirs.configHome)
 }
 
 func initBaseDirs(home string) {
 	// Initialize standard directories.
-	baseDirs.dataHome = xdgPath(envDataHome, filepath.Join(home, ".local", "share"))
-	baseDirs.data = xdgPaths(envDataDirs, "/usr/local/share", "/usr/share")
-	baseDirs.configHome = xdgPath(envConfigHome, filepath.Join(home, ".config"))
-	baseDirs.config = xdgPaths(envConfigDirs, "/etc/xdg")
-	baseDirs.stateHome = xdgPath(envStateHome, filepath.Join(home, ".local", "state"))
-	baseDirs.cacheHome = xdgPath(envCacheHome, filepath.Join(home, ".cache"))
-	baseDirs.runtime = xdgPath(envRuntimeDir, filepath.Join("/run/user", strconv.Itoa(os.Getuid())))
+	baseDirs.dataHome = pathutil.EnvPath(envDataHome, filepath.Join(home, ".local", "share"))
+	baseDirs.data = pathutil.EnvPathList(envDataDirs, "/usr/local/share", "/usr/share")
+	baseDirs.configHome = pathutil.EnvPath(envConfigHome, filepath.Join(home, ".config"))
+	baseDirs.config = pathutil.EnvPathList(envConfigDirs, "/etc/xdg")
+	baseDirs.stateHome = pathutil.EnvPath(envStateHome, filepath.Join(home, ".local", "state"))
+	baseDirs.cacheHome = pathutil.EnvPath(envCacheHome, filepath.Join(home, ".cache"))
+	baseDirs.runtime = pathutil.EnvPath(envRuntimeDir, filepath.Join("/run/user", strconv.Itoa(os.Getuid())))
 
 	// Initialize non-standard directories.
+	baseDirs.binHome = pathutil.EnvPath(envBinHome, filepath.Join(home, ".local", "bin"))
+
 	appDirs := []string{
 		filepath.Join(baseDirs.dataHome, "applications"),
 		filepath.Join(home, ".local/share/applications"),
@@ -55,17 +49,22 @@ func initBaseDirs(home string) {
 		fontDirs = append(fontDirs, filepath.Join(dir, "fonts"))
 	}
 
-	baseDirs.applications = pathutil.Unique(appDirs, Home)
-	baseDirs.fonts = pathutil.Unique(fontDirs, Home)
+	baseDirs.applications = pathutil.Unique(appDirs)
+	baseDirs.fonts = pathutil.Unique(fontDirs)
 }
 
-func initUserDirs(home string) {
-	UserDirs.Desktop = xdgPath(envDesktopDir, filepath.Join(home, "Desktop"))
-	UserDirs.Download = xdgPath(envDownloadDir, filepath.Join(home, "Downloads"))
-	UserDirs.Documents = xdgPath(envDocumentsDir, filepath.Join(home, "Documents"))
-	UserDirs.Music = xdgPath(envMusicDir, filepath.Join(home, "Music"))
-	UserDirs.Pictures = xdgPath(envPicturesDir, filepath.Join(home, "Pictures"))
-	UserDirs.Videos = xdgPath(envVideosDir, filepath.Join(home, "Videos"))
-	UserDirs.Templates = xdgPath(envTemplatesDir, filepath.Join(home, "Templates"))
-	UserDirs.PublicShare = xdgPath(envPublicShareDir, filepath.Join(home, "Public"))
+func initUserDirs(home, configHome string) {
+	dirs, err := userdirs.ParseConfigFile(filepath.Join(configHome, "user-dirs.dirs"))
+	if err != nil {
+		dirs = &UserDirectories{}
+	}
+
+	UserDirs.Desktop = pathutil.EnvPath(userdirs.EnvDesktopDir, dirs.Desktop, filepath.Join(home, "Desktop"))
+	UserDirs.Download = pathutil.EnvPath(userdirs.EnvDownloadDir, dirs.Download, filepath.Join(home, "Downloads"))
+	UserDirs.Documents = pathutil.EnvPath(userdirs.EnvDocumentsDir, dirs.Documents, filepath.Join(home, "Documents"))
+	UserDirs.Music = pathutil.EnvPath(userdirs.EnvMusicDir, dirs.Music, filepath.Join(home, "Music"))
+	UserDirs.Pictures = pathutil.EnvPath(userdirs.EnvPicturesDir, dirs.Pictures, filepath.Join(home, "Pictures"))
+	UserDirs.Videos = pathutil.EnvPath(userdirs.EnvVideosDir, dirs.Videos, filepath.Join(home, "Videos"))
+	UserDirs.Templates = pathutil.EnvPath(userdirs.EnvTemplatesDir, dirs.Templates, filepath.Join(home, "Templates"))
+	UserDirs.PublicShare = pathutil.EnvPath(userdirs.EnvPublicShareDir, dirs.PublicShare, filepath.Join(home, "Public"))
 }

vendor/github.com/adrg/xdg/paths_windows.go

@@ -4,17 +4,10 @@ import (
 	"path/filepath"
 
 	"github.com/adrg/xdg/internal/pathutil"
+	"github.com/adrg/xdg/internal/userdirs"
 	"golang.org/x/sys/windows"
 )
 
-func homeDir() string {
-	return pathutil.KnownFolder(
-		windows.FOLDERID_Profile,
-		[]string{"USERPROFILE"},
-		nil,
-	)
-}
-
 func initDirs(home string) {
 	kf := initKnownFolders(home)
 	initBaseDirs(home, kf)
@@ -23,19 +16,26 @@ func initDirs(home string) {
 
 func initBaseDirs(home string, kf *knownFolders) {
 	// Initialize standard directories.
-	baseDirs.dataHome = xdgPath(envDataHome, kf.localAppData)
-	baseDirs.data = xdgPaths(envDataDirs, kf.roamingAppData, kf.programData)
-	baseDirs.configHome = xdgPath(envConfigHome, kf.localAppData)
-	baseDirs.config = xdgPaths(envConfigDirs, kf.programData, kf.roamingAppData)
-	baseDirs.stateHome = xdgPath(envStateHome, kf.localAppData)
-	baseDirs.cacheHome = xdgPath(envCacheHome, filepath.Join(kf.localAppData, "cache"))
-	baseDirs.runtime = xdgPath(envRuntimeDir, kf.localAppData)
+	baseDirs.dataHome = pathutil.EnvPath(envDataHome, kf.localAppData)
+	baseDirs.data = pathutil.EnvPathList(envDataDirs, kf.roamingAppData, kf.programData)
+	baseDirs.configHome = pathutil.EnvPath(envConfigHome, kf.localAppData)
+	baseDirs.config = pathutil.EnvPathList(envConfigDirs, kf.programData, kf.roamingAppData)
+	baseDirs.stateHome = pathutil.EnvPath(envStateHome, kf.localAppData)
+	baseDirs.cacheHome = pathutil.EnvPath(envCacheHome, filepath.Join(kf.localAppData, "cache"))
+	baseDirs.runtime = pathutil.EnvPath(envRuntimeDir, kf.localAppData)
 
 	// Initialize non-standard directories.
+	baseDirs.binHome = pathutil.EnvPath(envBinHome, kf.userProgramFiles)
+
 	baseDirs.applications = []string{
 		kf.programs,
 		kf.commonPrograms,
+		kf.programFiles,
+		kf.programFilesCommon,
+		kf.userProgramFiles,
+		kf.userProgramFilesCommon,
 	}
+
 	baseDirs.fonts = []string{
 		kf.fonts,
 		filepath.Join(kf.localAppData, "Microsoft", "Windows", "Fonts"),
@@ -43,35 +43,39 @@ func initBaseDirs(home string, kf *knownFolders) {
 }
 
 func initUserDirs(home string, kf *knownFolders) {
-	UserDirs.Desktop = xdgPath(envDesktopDir, kf.desktop)
-	UserDirs.Download = xdgPath(envDownloadDir, kf.downloads)
-	UserDirs.Documents = xdgPath(envDocumentsDir, kf.documents)
-	UserDirs.Music = xdgPath(envMusicDir, kf.music)
-	UserDirs.Pictures = xdgPath(envPicturesDir, kf.pictures)
-	UserDirs.Videos = xdgPath(envVideosDir, kf.videos)
-	UserDirs.Templates = xdgPath(envTemplatesDir, kf.templates)
-	UserDirs.PublicShare = xdgPath(envPublicShareDir, kf.public)
+	UserDirs.Desktop = pathutil.EnvPath(userdirs.EnvDesktopDir, kf.desktop)
+	UserDirs.Download = pathutil.EnvPath(userdirs.EnvDownloadDir, kf.downloads)
+	UserDirs.Documents = pathutil.EnvPath(userdirs.EnvDocumentsDir, kf.documents)
+	UserDirs.Music = pathutil.EnvPath(userdirs.EnvMusicDir, kf.music)
+	UserDirs.Pictures = pathutil.EnvPath(userdirs.EnvPicturesDir, kf.pictures)
+	UserDirs.Videos = pathutil.EnvPath(userdirs.EnvVideosDir, kf.videos)
+	UserDirs.Templates = pathutil.EnvPath(userdirs.EnvTemplatesDir, kf.templates)
+	UserDirs.PublicShare = pathutil.EnvPath(userdirs.EnvPublicShareDir, kf.public)
 }
 
 type knownFolders struct {
-	systemDrive    string
-	systemRoot     string
-	programData    string
-	userProfile    string
-	userProfiles   string
-	roamingAppData string
-	localAppData   string
-	desktop        string
-	downloads      string
-	documents      string
-	music          string
-	pictures       string
-	videos         string
-	templates      string
-	public         string
-	fonts          string
-	programs       string
-	commonPrograms string
+	systemDrive            string
+	systemRoot             string
+	programData            string
+	userProfile            string
+	userProfiles           string
+	roamingAppData         string
+	localAppData           string
+	desktop                string
+	downloads              string
+	documents              string
+	music                  string
+	pictures               string
+	videos                 string
+	templates              string
+	public                 string
+	fonts                  string
+	programs               string
+	commonPrograms         string
+	programFiles           string
+	programFilesCommon     string
+	userProgramFiles       string
+	userProgramFilesCommon string
 }
 
 func initKnownFolders(home string) *knownFolders {
@@ -163,6 +167,30 @@ func initKnownFolders(home string) *knownFolders {
 		nil,
 		[]string{filepath.Join(kf.programData, "Microsoft", "Windows", "Start Menu", "Programs")},
 	)
+	kf.programFiles = pathutil.KnownFolder(
+		windows.FOLDERID_ProgramFiles,
+		[]string{"ProgramFiles"},
+		[]string{filepath.Join(kf.systemDrive, "Program Files")},
+	)
+	kf.programFilesCommon = pathutil.KnownFolder(
+		windows.FOLDERID_ProgramFilesCommon,
+		nil,
+		[]string{filepath.Join(kf.programFiles, "Common Files")},
+	)
+	kf.userProgramFiles = pathutil.KnownFolder(
+		windows.FOLDERID_UserProgramFiles,
+		nil,
+		[]string{
+			filepath.Join(kf.localAppData, "Programs"),
+		},
+	)
+	kf.userProgramFilesCommon = pathutil.KnownFolder(
+		windows.FOLDERID_UserProgramFilesCommon,
+		nil,
+		[]string{
+			filepath.Join(kf.userProgramFiles, "Common"),
+		},
+	)
 
 	return kf
 }

vendor/github.com/adrg/xdg/xdg.go

@@ -1,12 +1,13 @@
 package xdg
 
 import (
-	"os"
-	"path/filepath"
-
 	"github.com/adrg/xdg/internal/pathutil"
+	"github.com/adrg/xdg/internal/userdirs"
 )
 
+// UserDirectories defines the locations of well known user directories.
+type UserDirectories = userdirs.Directories
+
 var (
 	// Home contains the path of the user's home directory.
 	Home string
@@ -29,7 +30,7 @@ var (
 
 	// ConfigHome defines the base directory relative to which user-specific
 	// configuration files should be written. This directory is defined by
-	// the $XDG_CONFIG_HOME environment variable. If the variable is not
+	// the $XDG_CONFIG_HOME environment variable. If the variable is
 	// not set, a default equal to $HOME/.config should be used.
 	ConfigHome string
 
@@ -66,6 +67,12 @@ var (
 	// swapped out to disk.
 	RuntimeDir string
 
+	// BinHome defines the base directory relative to which user-specific
+	// binary files should be written. This directory is defined by
+	// the non-standard $XDG_BIN_HOME environment variable. If the variable is
+	// not set, a default equal to $HOME/.local/bin should be used.
+	BinHome string
+
 	// UserDirs defines the locations of well known user directories.
 	UserDirs UserDirectories
 
@@ -88,7 +95,7 @@ func init() {
 // in the environment.
 func Reload() {
 	// Initialize home directory.
-	Home = homeDir()
+	Home = pathutil.UserHomeDir()
 
 	// Initialize base and user directories.
 	initDirs(Home)
@@ -103,6 +110,7 @@ func Reload() {
 	RuntimeDir = baseDirs.runtime
 
 	// Set non-standard directories.
+	BinHome = baseDirs.binHome
 	FontDirs = baseDirs.fonts
 	ApplicationDirs = baseDirs.applications
 }
@@ -153,8 +161,9 @@ func CacheFile(relPath string) (string, error) {
 // The relPath parameter must contain the name of the runtime file, and
 // optionally, a set of parent directories (e.g. appname/app.pid).
 // If the specified directories do not exist, they will be created relative
-// to the base runtime directory. On failure, an error containing the
-// attempted paths is returned.
+// to the base runtime directory. If the base runtime directory does not exist,
+// the operating system's temporary directory is used as a fallback. On failure,
+// an error containing the attempted paths is returned.
 func RuntimeFile(relPath string) (string, error) {
 	return baseDirs.runtimeFile(relPath)
 }
@@ -193,26 +202,11 @@ func SearchCacheFile(relPath string) (string, error) {
 
 // SearchRuntimeFile searches for the specified file in the runtime search path.
 // The relPath parameter must contain the name of the runtime file, and
-// optionally, a set of parent directories (e.g. appname/app.pid). If the
-// file cannot be found, an error specifying the searched path is returned.
+// optionally, a set of parent directories (e.g. appname/app.pid). The runtime
+// file is also searched in the operating system's temporary directory in order
+// to cover cases in which the runtime base directory does not exist or is not
+// accessible. If the file cannot be found, an error specifying the searched
+// paths is returned.
 func SearchRuntimeFile(relPath string) (string, error) {
 	return baseDirs.searchRuntimeFile(relPath)
 }
-
-func xdgPath(name, defaultPath string) string {
-	dir := pathutil.ExpandHome(os.Getenv(name), Home)
-	if dir != "" && filepath.IsAbs(dir) {
-		return dir
-	}
-
-	return defaultPath
-}
-
-func xdgPaths(name string, defaultPaths ...string) []string {
-	dirs := pathutil.Unique(filepath.SplitList(os.Getenv(name)), Home)
-	if len(dirs) != 0 {
-		return dirs
-	}
-
-	return pathutil.Unique(defaultPaths, Home)
-}

vendor/github.com/davecgh/go-spew/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2012-2016 Dave Collins <dave@davec.name>
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

vendor/github.com/davecgh/go-spew/spew/bypass.go

@@ -0,0 +1,145 @@
+// Copyright (c) 2015-2016 Dave Collins <dave@davec.name>
+//
+// Permission to use, copy, modify, and distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+// NOTE: Due to the following build constraints, this file will only be compiled
+// when the code is not running on Google App Engine, compiled by GopherJS, and
+// "-tags safe" is not added to the go build command line.  The "disableunsafe"
+// tag is deprecated and thus should not be used.
+// Go versions prior to 1.4 are disabled because they use a different layout
+// for interfaces which make the implementation of unsafeReflectValue more complex.
+// +build !js,!appengine,!safe,!disableunsafe,go1.4
+
+package spew
+
+import (
+	"reflect"
+	"unsafe"
+)
+
+const (
+	// UnsafeDisabled is a build-time constant which specifies whether or
+	// not access to the unsafe package is available.
+	UnsafeDisabled = false
+
+	// ptrSize is the size of a pointer on the current arch.
+	ptrSize = unsafe.Sizeof((*byte)(nil))
+)
+
+type flag uintptr
+
+var (
+	// flagRO indicates whether the value field of a reflect.Value
+	// is read-only.
+	flagRO flag
+
+	// flagAddr indicates whether the address of the reflect.Value's
+	// value may be taken.
+	flagAddr flag
+)
+
+// flagKindMask holds the bits that make up the kind
+// part of the flags field. In all the supported versions,
+// it is in the lower 5 bits.
+const flagKindMask = flag(0x1f)
+
+// Different versions of Go have used different
+// bit layouts for the flags type. This table
+// records the known combinations.
+var okFlags = []struct {
+	ro, addr flag
+}{{
+	// From Go 1.4 to 1.5
+	ro:   1 << 5,
+	addr: 1 << 7,
+}, {
+	// Up to Go tip.
+	ro:   1<<5 | 1<<6,
+	addr: 1 << 8,
+}}
+
+var flagValOffset = func() uintptr {
+	field, ok := reflect.TypeOf(reflect.Value{}).FieldByName("flag")
+	if !ok {
+		panic("reflect.Value has no flag field")
+	}
+	return field.Offset
+}()
+
+// flagField returns a pointer to the flag field of a reflect.Value.
+func flagField(v *reflect.Value) *flag {
+	return (*flag)(unsafe.Pointer(uintptr(unsafe.Pointer(v)) + flagValOffset))
+}
+
+// unsafeReflectValue converts the passed reflect.Value into a one that bypasses
+// the typical safety restrictions preventing access to unaddressable and
+// unexported data.  It works by digging the raw pointer to the underlying
+// value out of the protected value and generating a new unprotected (unsafe)
+// reflect.Value to it.
+//
+// This allows us to check for implementations of the Stringer and error
+// interfaces to be used for pretty printing ordinarily unaddressable and
+// inaccessible values such as unexported struct fields.
+func unsafeReflectValue(v reflect.Value) reflect.Value {
+	if !v.IsValid() || (v.CanInterface() && v.CanAddr()) {
+		return v
+	}
+	flagFieldPtr := flagField(&v)
+	*flagFieldPtr &^= flagRO
+	*flagFieldPtr |= flagAddr
+	return v
+}
+
+// Sanity checks against future reflect package changes
+// to the type or semantics of the Value.flag field.
+func init() {
+	field, ok := reflect.TypeOf(reflect.Value{}).FieldByName("flag")
+	if !ok {
+		panic("reflect.Value has no flag field")
+	}
+	if field.Type.Kind() != reflect.TypeOf(flag(0)).Kind() {
+		panic("reflect.Value flag field has changed kind")
+	}
+	type t0 int
+	var t struct {
+		A t0
+		// t0 will have flagEmbedRO set.
+		t0
+		// a will have flagStickyRO set
+		a t0
+	}
+	vA := reflect.ValueOf(t).FieldByName("A")
+	va := reflect.ValueOf(t).FieldByName("a")
+	vt0 := reflect.ValueOf(t).FieldByName("t0")
+
+	// Infer flagRO from the difference between the flags
+	// for the (otherwise identical) fields in t.
+	flagPublic := *flagField(&vA)
+	flagWithRO := *flagField(&va) | *flagField(&vt0)
+	flagRO = flagPublic ^ flagWithRO
+
+	// Infer flagAddr from the difference between a value
+	// taken from a pointer and not.
+	vPtrA := reflect.ValueOf(&t).Elem().FieldByName("A")
+	flagNoPtr := *flagField(&vA)
+	flagPtr := *flagField(&vPtrA)
+	flagAddr = flagNoPtr ^ flagPtr
+
+	// Check that the inferred flags tally with one of the known versions.
+	for _, f := range okFlags {
+		if flagRO == f.ro && flagAddr == f.addr {
+			return
+		}
+	}
+	panic("reflect.Value read-only flag has changed semantics")
+}

vendor/github.com/davecgh/go-spew/spew/bypasssafe.go

@@ -0,0 +1,38 @@
+// Copyright (c) 2015-2016 Dave Collins <dave@davec.name>
+//
+// Permission to use, copy, modify, and distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+// NOTE: Due to the following build constraints, this file will only be compiled
+// when the code is running on Google App Engine, compiled by GopherJS, or
+// "-tags safe" is added to the go build command line.  The "disableunsafe"
+// tag is deprecated and thus should not be used.
+// +build js appengine safe disableunsafe !go1.4
+
+package spew
+
+import "reflect"
+
+const (
+	// UnsafeDisabled is a build-time constant which specifies whether or
+	// not access to the unsafe package is available.
+	UnsafeDisabled = true
+)
+
+// unsafeReflectValue typically converts the passed reflect.Value into a one
+// that bypasses the typical safety restrictions preventing access to
+// unaddressable and unexported data.  However, doing this relies on access to
+// the unsafe package.  This is a stub version which simply returns the passed
+// reflect.Value when the unsafe package is not available.
+func unsafeReflectValue(v reflect.Value) reflect.Value {
+	return v
+}

vendor/github.com/davecgh/go-spew/spew/common.go

@@ -0,0 +1,341 @@
+/*
+ * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+package spew
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"reflect"
+	"sort"
+	"strconv"
+)
+
+// Some constants in the form of bytes to avoid string overhead.  This mirrors
+// the technique used in the fmt package.
+var (
+	panicBytes            = []byte("(PANIC=")
+	plusBytes             = []byte("+")
+	iBytes                = []byte("i")
+	trueBytes             = []byte("true")
+	falseBytes            = []byte("false")
+	interfaceBytes        = []byte("(interface {})")
+	commaNewlineBytes     = []byte(",\n")
+	newlineBytes          = []byte("\n")
+	openBraceBytes        = []byte("{")
+	openBraceNewlineBytes = []byte("{\n")
+	closeBraceBytes       = []byte("}")
+	asteriskBytes         = []byte("*")
+	colonBytes            = []byte(":")
+	colonSpaceBytes       = []byte(": ")
+	openParenBytes        = []byte("(")
+	closeParenBytes       = []byte(")")
+	spaceBytes            = []byte(" ")
+	pointerChainBytes     = []byte("->")
+	nilAngleBytes         = []byte("<nil>")
+	maxNewlineBytes       = []byte("<max depth reached>\n")
+	maxShortBytes         = []byte("<max>")
+	circularBytes         = []byte("<already shown>")
+	circularShortBytes    = []byte("<shown>")
+	invalidAngleBytes     = []byte("<invalid>")
+	openBracketBytes      = []byte("[")
+	closeBracketBytes     = []byte("]")
+	percentBytes          = []byte("%")
+	precisionBytes        = []byte(".")
+	openAngleBytes        = []byte("<")
+	closeAngleBytes       = []byte(">")
+	openMapBytes          = []byte("map[")
+	closeMapBytes         = []byte("]")
+	lenEqualsBytes        = []byte("len=")
+	capEqualsBytes        = []byte("cap=")
+)
+
+// hexDigits is used to map a decimal value to a hex digit.
+var hexDigits = "0123456789abcdef"
+
+// catchPanic handles any panics that might occur during the handleMethods
+// calls.
+func catchPanic(w io.Writer, v reflect.Value) {
+	if err := recover(); err != nil {
+		w.Write(panicBytes)
+		fmt.Fprintf(w, "%v", err)
+		w.Write(closeParenBytes)
+	}
+}
+
+// handleMethods attempts to call the Error and String methods on the underlying
+// type the passed reflect.Value represents and outputes the result to Writer w.
+//
+// It handles panics in any called methods by catching and displaying the error
+// as the formatted value.
+func handleMethods(cs *ConfigState, w io.Writer, v reflect.Value) (handled bool) {
+	// We need an interface to check if the type implements the error or
+	// Stringer interface.  However, the reflect package won't give us an
+	// interface on certain things like unexported struct fields in order
+	// to enforce visibility rules.  We use unsafe, when it's available,
+	// to bypass these restrictions since this package does not mutate the
+	// values.
+	if !v.CanInterface() {
+		if UnsafeDisabled {
+			return false
+		}
+
+		v = unsafeReflectValue(v)
+	}
+
+	// Choose whether or not to do error and Stringer interface lookups against
+	// the base type or a pointer to the base type depending on settings.
+	// Technically calling one of these methods with a pointer receiver can
+	// mutate the value, however, types which choose to satisify an error or
+	// Stringer interface with a pointer receiver should not be mutating their
+	// state inside these interface methods.
+	if !cs.DisablePointerMethods && !UnsafeDisabled && !v.CanAddr() {
+		v = unsafeReflectValue(v)
+	}
+	if v.CanAddr() {
+		v = v.Addr()
+	}
+
+	// Is it an error or Stringer?
+	switch iface := v.Interface().(type) {
+	case error:
+		defer catchPanic(w, v)
+		if cs.ContinueOnMethod {
+			w.Write(openParenBytes)
+			w.Write([]byte(iface.Error()))
+			w.Write(closeParenBytes)
+			w.Write(spaceBytes)
+			return false
+		}
+
+		w.Write([]byte(iface.Error()))
+		return true
+
+	case fmt.Stringer:
+		defer catchPanic(w, v)
+		if cs.ContinueOnMethod {
+			w.Write(openParenBytes)
+			w.Write([]byte(iface.String()))
+			w.Write(closeParenBytes)
+			w.Write(spaceBytes)
+			return false
+		}
+		w.Write([]byte(iface.String()))
+		return true
+	}
+	return false
+}
+
+// printBool outputs a boolean value as true or false to Writer w.
+func printBool(w io.Writer, val bool) {
+	if val {
+		w.Write(trueBytes)
+	} else {
+		w.Write(falseBytes)
+	}
+}
+
+// printInt outputs a signed integer value to Writer w.
+func printInt(w io.Writer, val int64, base int) {
+	w.Write([]byte(strconv.FormatInt(val, base)))
+}
+
+// printUint outputs an unsigned integer value to Writer w.
+func printUint(w io.Writer, val uint64, base int) {
+	w.Write([]byte(strconv.FormatUint(val, base)))
+}
+
+// printFloat outputs a floating point value using the specified precision,
+// which is expected to be 32 or 64bit, to Writer w.
+func printFloat(w io.Writer, val float64, precision int) {
+	w.Write([]byte(strconv.FormatFloat(val, 'g', -1, precision)))
+}
+
+// printComplex outputs a complex value using the specified float precision
+// for the real and imaginary parts to Writer w.
+func printComplex(w io.Writer, c complex128, floatPrecision int) {
+	r := real(c)
+	w.Write(openParenBytes)
+	w.Write([]byte(strconv.FormatFloat(r, 'g', -1, floatPrecision)))
+	i := imag(c)
+	if i >= 0 {
+		w.Write(plusBytes)
+	}
+	w.Write([]byte(strconv.FormatFloat(i, 'g', -1, floatPrecision)))
+	w.Write(iBytes)
+	w.Write(closeParenBytes)
+}
+
+// printHexPtr outputs a uintptr formatted as hexadecimal with a leading '0x'
+// prefix to Writer w.
+func printHexPtr(w io.Writer, p uintptr) {
+	// Null pointer.
+	num := uint64(p)
+	if num == 0 {
+		w.Write(nilAngleBytes)
+		return
+	}
+
+	// Max uint64 is 16 bytes in hex + 2 bytes for '0x' prefix
+	buf := make([]byte, 18)
+
+	// It's simpler to construct the hex string right to left.
+	base := uint64(16)
+	i := len(buf) - 1
+	for num >= base {
+		buf[i] = hexDigits[num%base]
+		num /= base
+		i--
+	}
+	buf[i] = hexDigits[num]
+
+	// Add '0x' prefix.
+	i--
+	buf[i] = 'x'
+	i--
+	buf[i] = '0'
+
+	// Strip unused leading bytes.
+	buf = buf[i:]
+	w.Write(buf)
+}
+
+// valuesSorter implements sort.Interface to allow a slice of reflect.Value
+// elements to be sorted.
+type valuesSorter struct {
+	values  []reflect.Value
+	strings []string // either nil or same len and values
+	cs      *ConfigState
+}
+
+// newValuesSorter initializes a valuesSorter instance, which holds a set of
+// surrogate keys on which the data should be sorted.  It uses flags in
+// ConfigState to decide if and how to populate those surrogate keys.
+func newValuesSorter(values []reflect.Value, cs *ConfigState) sort.Interface {
+	vs := &valuesSorter{values: values, cs: cs}
+	if canSortSimply(vs.values[0].Kind()) {
+		return vs
+	}
+	if !cs.DisableMethods {
+		vs.strings = make([]string, len(values))
+		for i := range vs.values {
+			b := bytes.Buffer{}
+			if !handleMethods(cs, &b, vs.values[i]) {
+				vs.strings = nil
+				break
+			}
+			vs.strings[i] = b.String()
+		}
+	}
+	if vs.strings == nil && cs.SpewKeys {
+		vs.strings = make([]string, len(values))
+		for i := range vs.values {
+			vs.strings[i] = Sprintf("%#v", vs.values[i].Interface())
+		}
+	}
+	return vs
+}
+
+// canSortSimply tests whether a reflect.Kind is a primitive that can be sorted
+// directly, or whether it should be considered for sorting by surrogate keys
+// (if the ConfigState allows it).
+func canSortSimply(kind reflect.Kind) bool {
+	// This switch parallels valueSortLess, except for the default case.
+	switch kind {
+	case reflect.Bool:
+		return true
+	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
+		return true
+	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
+		return true
+	case reflect.Float32, reflect.Float64:
+		return true
+	case reflect.String:
+		return true
+	case reflect.Uintptr:
+		return true
+	case reflect.Array:
+		return true
+	}
+	return false
+}
+
+// Len returns the number of values in the slice.  It is part of the
+// sort.Interface implementation.
+func (s *valuesSorter) Len() int {
+	return len(s.values)
+}
+
+// Swap swaps the values at the passed indices.  It is part of the
+// sort.Interface implementation.
+func (s *valuesSorter) Swap(i, j int) {
+	s.values[i], s.values[j] = s.values[j], s.values[i]
+	if s.strings != nil {
+		s.strings[i], s.strings[j] = s.strings[j], s.strings[i]
+	}
+}
+
+// valueSortLess returns whether the first value should sort before the second
+// value.  It is used by valueSorter.Less as part of the sort.Interface
+// implementation.
+func valueSortLess(a, b reflect.Value) bool {
+	switch a.Kind() {
+	case reflect.Bool:
+		return !a.Bool() && b.Bool()
+	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
+		return a.Int() < b.Int()
+	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
+		return a.Uint() < b.Uint()
+	case reflect.Float32, reflect.Float64:
+		return a.Float() < b.Float()
+	case reflect.String:
+		return a.String() < b.String()
+	case reflect.Uintptr:
+		return a.Uint() < b.Uint()
+	case reflect.Array:
+		// Compare the contents of both arrays.
+		l := a.Len()
+		for i := 0; i < l; i++ {
+			av := a.Index(i)
+			bv := b.Index(i)
+			if av.Interface() == bv.Interface() {
+				continue
+			}
+			return valueSortLess(av, bv)
+		}
+	}
+	return a.String() < b.String()
+}
+
+// Less returns whether the value at index i should sort before the
+// value at index j.  It is part of the sort.Interface implementation.
+func (s *valuesSorter) Less(i, j int) bool {
+	if s.strings == nil {
+		return valueSortLess(s.values[i], s.values[j])
+	}
+	return s.strings[i] < s.strings[j]
+}
+
+// sortValues is a sort function that handles both native types and any type that
+// can be converted to error or Stringer.  Other inputs are sorted according to
+// their Value.String() value to ensure display stability.
+func sortValues(values []reflect.Value, cs *ConfigState) {
+	if len(values) == 0 {
+		return
+	}
+	sort.Sort(newValuesSorter(values, cs))
+}

vendor/github.com/davecgh/go-spew/spew/config.go

@@ -0,0 +1,306 @@
+/*
+ * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+package spew
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"os"
+)
+
+// ConfigState houses the configuration options used by spew to format and
+// display values.  There is a global instance, Config, that is used to control
+// all top-level Formatter and Dump functionality.  Each ConfigState instance
+// provides methods equivalent to the top-level functions.
+//
+// The zero value for ConfigState provides no indentation.  You would typically
+// want to set it to a space or a tab.
+//
+// Alternatively, you can use NewDefaultConfig to get a ConfigState instance
+// with default settings.  See the documentation of NewDefaultConfig for default
+// values.
+type ConfigState struct {
+	// Indent specifies the string to use for each indentation level.  The
+	// global config instance that all top-level functions use set this to a
+	// single space by default.  If you would like more indentation, you might
+	// set this to a tab with "\t" or perhaps two spaces with "  ".
+	Indent string
+
+	// MaxDepth controls the maximum number of levels to descend into nested
+	// data structures.  The default, 0, means there is no limit.
+	//
+	// NOTE: Circular data structures are properly detected, so it is not
+	// necessary to set this value unless you specifically want to limit deeply
+	// nested data structures.
+	MaxDepth int
+
+	// DisableMethods specifies whether or not error and Stringer interfaces are
+	// invoked for types that implement them.
+	DisableMethods bool
+
+	// DisablePointerMethods specifies whether or not to check for and invoke
+	// error and Stringer interfaces on types which only accept a pointer
+	// receiver when the current type is not a pointer.
+	//
+	// NOTE: This might be an unsafe action since calling one of these methods
+	// with a pointer receiver could technically mutate the value, however,
+	// in practice, types which choose to satisify an error or Stringer
+	// interface with a pointer receiver should not be mutating their state
+	// inside these interface methods.  As a result, this option relies on
+	// access to the unsafe package, so it will not have any effect when
+	// running in environments without access to the unsafe package such as
+	// Google App Engine or with the "safe" build tag specified.
+	DisablePointerMethods bool
+
+	// DisablePointerAddresses specifies whether to disable the printing of
+	// pointer addresses. This is useful when diffing data structures in tests.
+	DisablePointerAddresses bool
+
+	// DisableCapacities specifies whether to disable the printing of capacities
+	// for arrays, slices, maps and channels. This is useful when diffing
+	// data structures in tests.
+	DisableCapacities bool
+
+	// ContinueOnMethod specifies whether or not recursion should continue once
+	// a custom error or Stringer interface is invoked.  The default, false,
+	// means it will print the results of invoking the custom error or Stringer
+	// interface and return immediately instead of continuing to recurse into
+	// the internals of the data type.
+	//
+	// NOTE: This flag does not have any effect if method invocation is disabled
+	// via the DisableMethods or DisablePointerMethods options.
+	ContinueOnMethod bool
+
+	// SortKeys specifies map keys should be sorted before being printed. Use
+	// this to have a more deterministic, diffable output.  Note that only
+	// native types (bool, int, uint, floats, uintptr and string) and types
+	// that support the error or Stringer interfaces (if methods are
+	// enabled) are supported, with other types sorted according to the
+	// reflect.Value.String() output which guarantees display stability.
+	SortKeys bool
+
+	// SpewKeys specifies that, as a last resort attempt, map keys should
+	// be spewed to strings and sorted by those strings.  This is only
+	// considered if SortKeys is true.
+	SpewKeys bool
+}
+
+// Config is the active configuration of the top-level functions.
+// The configuration can be changed by modifying the contents of spew.Config.
+var Config = ConfigState{Indent: " "}
+
+// Errorf is a wrapper for fmt.Errorf that treats each argument as if it were
+// passed with a Formatter interface returned by c.NewFormatter.  It returns
+// the formatted string as a value that satisfies error.  See NewFormatter
+// for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Errorf(format, c.NewFormatter(a), c.NewFormatter(b))
+func (c *ConfigState) Errorf(format string, a ...interface{}) (err error) {
+	return fmt.Errorf(format, c.convertArgs(a)...)
+}
+
+// Fprint is a wrapper for fmt.Fprint that treats each argument as if it were
+// passed with a Formatter interface returned by c.NewFormatter.  It returns
+// the number of bytes written and any write error encountered.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Fprint(w, c.NewFormatter(a), c.NewFormatter(b))
+func (c *ConfigState) Fprint(w io.Writer, a ...interface{}) (n int, err error) {
+	return fmt.Fprint(w, c.convertArgs(a)...)
+}
+
+// Fprintf is a wrapper for fmt.Fprintf that treats each argument as if it were
+// passed with a Formatter interface returned by c.NewFormatter.  It returns
+// the number of bytes written and any write error encountered.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Fprintf(w, format, c.NewFormatter(a), c.NewFormatter(b))
+func (c *ConfigState) Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) {
+	return fmt.Fprintf(w, format, c.convertArgs(a)...)
+}
+
+// Fprintln is a wrapper for fmt.Fprintln that treats each argument as if it
+// passed with a Formatter interface returned by c.NewFormatter.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Fprintln(w, c.NewFormatter(a), c.NewFormatter(b))
+func (c *ConfigState) Fprintln(w io.Writer, a ...interface{}) (n int, err error) {
+	return fmt.Fprintln(w, c.convertArgs(a)...)
+}
+
+// Print is a wrapper for fmt.Print that treats each argument as if it were
+// passed with a Formatter interface returned by c.NewFormatter.  It returns
+// the number of bytes written and any write error encountered.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Print(c.NewFormatter(a), c.NewFormatter(b))
+func (c *ConfigState) Print(a ...interface{}) (n int, err error) {
+	return fmt.Print(c.convertArgs(a)...)
+}
+
+// Printf is a wrapper for fmt.Printf that treats each argument as if it were
+// passed with a Formatter interface returned by c.NewFormatter.  It returns
+// the number of bytes written and any write error encountered.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Printf(format, c.NewFormatter(a), c.NewFormatter(b))
+func (c *ConfigState) Printf(format string, a ...interface{}) (n int, err error) {
+	return fmt.Printf(format, c.convertArgs(a)...)
+}
+
+// Println is a wrapper for fmt.Println that treats each argument as if it were
+// passed with a Formatter interface returned by c.NewFormatter.  It returns
+// the number of bytes written and any write error encountered.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Println(c.NewFormatter(a), c.NewFormatter(b))
+func (c *ConfigState) Println(a ...interface{}) (n int, err error) {
+	return fmt.Println(c.convertArgs(a)...)
+}
+
+// Sprint is a wrapper for fmt.Sprint that treats each argument as if it were
+// passed with a Formatter interface returned by c.NewFormatter.  It returns
+// the resulting string.  See NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Sprint(c.NewFormatter(a), c.NewFormatter(b))
+func (c *ConfigState) Sprint(a ...interface{}) string {
+	return fmt.Sprint(c.convertArgs(a)...)
+}
+
+// Sprintf is a wrapper for fmt.Sprintf that treats each argument as if it were
+// passed with a Formatter interface returned by c.NewFormatter.  It returns
+// the resulting string.  See NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Sprintf(format, c.NewFormatter(a), c.NewFormatter(b))
+func (c *ConfigState) Sprintf(format string, a ...interface{}) string {
+	return fmt.Sprintf(format, c.convertArgs(a)...)
+}
+
+// Sprintln is a wrapper for fmt.Sprintln that treats each argument as if it
+// were passed with a Formatter interface returned by c.NewFormatter.  It
+// returns the resulting string.  See NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Sprintln(c.NewFormatter(a), c.NewFormatter(b))
+func (c *ConfigState) Sprintln(a ...interface{}) string {
+	return fmt.Sprintln(c.convertArgs(a)...)
+}
+
+/*
+NewFormatter returns a custom formatter that satisfies the fmt.Formatter
+interface.  As a result, it integrates cleanly with standard fmt package
+printing functions.  The formatter is useful for inline printing of smaller data
+types similar to the standard %v format specifier.
+
+The custom formatter only responds to the %v (most compact), %+v (adds pointer
+addresses), %#v (adds types), and %#+v (adds types and pointer addresses) verb
+combinations.  Any other verbs such as %x and %q will be sent to the the
+standard fmt package for formatting.  In addition, the custom formatter ignores
+the width and precision arguments (however they will still work on the format
+specifiers not handled by the custom formatter).
+
+Typically this function shouldn't be called directly.  It is much easier to make
+use of the custom formatter by calling one of the convenience functions such as
+c.Printf, c.Println, or c.Printf.
+*/
+func (c *ConfigState) NewFormatter(v interface{}) fmt.Formatter {
+	return newFormatter(c, v)
+}
+
+// Fdump formats and displays the passed arguments to io.Writer w.  It formats
+// exactly the same as Dump.
+func (c *ConfigState) Fdump(w io.Writer, a ...interface{}) {
+	fdump(c, w, a...)
+}
+
+/*
+Dump displays the passed parameters to standard out with newlines, customizable
+indentation, and additional debug information such as complete types and all
+pointer addresses used to indirect to the final value.  It provides the
+following features over the built-in printing facilities provided by the fmt
+package:
+
+	* Pointers are dereferenced and followed
+	* Circular data structures are detected and handled properly
+	* Custom Stringer/error interfaces are optionally invoked, including
+	  on unexported types
+	* Custom types which only implement the Stringer/error interfaces via
+	  a pointer receiver are optionally invoked when passing non-pointer
+	  variables
+	* Byte arrays and slices are dumped like the hexdump -C command which
+	  includes offsets, byte values in hex, and ASCII output
+
+The configuration options are controlled by modifying the public members
+of c.  See ConfigState for options documentation.
+
+See Fdump if you would prefer dumping to an arbitrary io.Writer or Sdump to
+get the formatted result as a string.
+*/
+func (c *ConfigState) Dump(a ...interface{}) {
+	fdump(c, os.Stdout, a...)
+}
+
+// Sdump returns a string with the passed arguments formatted exactly the same
+// as Dump.
+func (c *ConfigState) Sdump(a ...interface{}) string {
+	var buf bytes.Buffer
+	fdump(c, &buf, a...)
+	return buf.String()
+}
+
+// convertArgs accepts a slice of arguments and returns a slice of the same
+// length with each argument converted to a spew Formatter interface using
+// the ConfigState associated with s.
+func (c *ConfigState) convertArgs(args []interface{}) (formatters []interface{}) {
+	formatters = make([]interface{}, len(args))
+	for index, arg := range args {
+		formatters[index] = newFormatter(c, arg)
+	}
+	return formatters
+}
+
+// NewDefaultConfig returns a ConfigState with the following default settings.
+//
+// 	Indent: " "
+// 	MaxDepth: 0
+// 	DisableMethods: false
+// 	DisablePointerMethods: false
+// 	ContinueOnMethod: false
+// 	SortKeys: false
+func NewDefaultConfig() *ConfigState {
+	return &ConfigState{Indent: " "}
+}

vendor/github.com/davecgh/go-spew/spew/doc.go

@@ -0,0 +1,211 @@
+/*
+ * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/*
+Package spew implements a deep pretty printer for Go data structures to aid in
+debugging.
+
+A quick overview of the additional features spew provides over the built-in
+printing facilities for Go data types are as follows:
+
+	* Pointers are dereferenced and followed
+	* Circular data structures are detected and handled properly
+	* Custom Stringer/error interfaces are optionally invoked, including
+	  on unexported types
+	* Custom types which only implement the Stringer/error interfaces via
+	  a pointer receiver are optionally invoked when passing non-pointer
+	  variables
+	* Byte arrays and slices are dumped like the hexdump -C command which
+	  includes offsets, byte values in hex, and ASCII output (only when using
+	  Dump style)
+
+There are two different approaches spew allows for dumping Go data structures:
+
+	* Dump style which prints with newlines, customizable indentation,
+	  and additional debug information such as types and all pointer addresses
+	  used to indirect to the final value
+	* A custom Formatter interface that integrates cleanly with the standard fmt
+	  package and replaces %v, %+v, %#v, and %#+v to provide inline printing
+	  similar to the default %v while providing the additional functionality
+	  outlined above and passing unsupported format verbs such as %x and %q
+	  along to fmt
+
+Quick Start
+
+This section demonstrates how to quickly get started with spew.  See the
+sections below for further details on formatting and configuration options.
+
+To dump a variable with full newlines, indentation, type, and pointer
+information use Dump, Fdump, or Sdump:
+	spew.Dump(myVar1, myVar2, ...)
+	spew.Fdump(someWriter, myVar1, myVar2, ...)
+	str := spew.Sdump(myVar1, myVar2, ...)
+
+Alternatively, if you would prefer to use format strings with a compacted inline
+printing style, use the convenience wrappers Printf, Fprintf, etc with
+%v (most compact), %+v (adds pointer addresses), %#v (adds types), or
+%#+v (adds types and pointer addresses):
+	spew.Printf("myVar1: %v -- myVar2: %+v", myVar1, myVar2)
+	spew.Printf("myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
+	spew.Fprintf(someWriter, "myVar1: %v -- myVar2: %+v", myVar1, myVar2)
+	spew.Fprintf(someWriter, "myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
+
+Configuration Options
+
+Configuration of spew is handled by fields in the ConfigState type.  For
+convenience, all of the top-level functions use a global state available
+via the spew.Config global.
+
+It is also possible to create a ConfigState instance that provides methods
+equivalent to the top-level functions.  This allows concurrent configuration
+options.  See the ConfigState documentation for more details.
+
+The following configuration options are available:
+	* Indent
+		String to use for each indentation level for Dump functions.
+		It is a single space by default.  A popular alternative is "\t".
+
+	* MaxDepth
+		Maximum number of levels to descend into nested data structures.
+		There is no limit by default.
+
+	* DisableMethods
+		Disables invocation of error and Stringer interface methods.
+		Method invocation is enabled by default.
+
+	* DisablePointerMethods
+		Disables invocation of error and Stringer interface methods on types
+		which only accept pointer receivers from non-pointer variables.
+		Pointer method invocation is enabled by default.
+
+	* DisablePointerAddresses
+		DisablePointerAddresses specifies whether to disable the printing of
+		pointer addresses. This is useful when diffing data structures in tests.
+
+	* DisableCapacities
+		DisableCapacities specifies whether to disable the printing of
+		capacities for arrays, slices, maps and channels. This is useful when
+		diffing data structures in tests.
+
+	* ContinueOnMethod
+		Enables recursion into types after invoking error and Stringer interface
+		methods. Recursion after method invocation is disabled by default.
+
+	* SortKeys
+		Specifies map keys should be sorted before being printed. Use
+		this to have a more deterministic, diffable output.  Note that
+		only native types (bool, int, uint, floats, uintptr and string)
+		and types which implement error or Stringer interfaces are
+		supported with other types sorted according to the
+		reflect.Value.String() output which guarantees display
+		stability.  Natural map order is used by default.
+
+	* SpewKeys
+		Specifies that, as a last resort attempt, map keys should be
+		spewed to strings and sorted by those strings.  This is only
+		considered if SortKeys is true.
+
+Dump Usage
+
+Simply call spew.Dump with a list of variables you want to dump:
+
+	spew.Dump(myVar1, myVar2, ...)
+
+You may also call spew.Fdump if you would prefer to output to an arbitrary
+io.Writer.  For example, to dump to standard error:
+
+	spew.Fdump(os.Stderr, myVar1, myVar2, ...)
+
+A third option is to call spew.Sdump to get the formatted output as a string:
+
+	str := spew.Sdump(myVar1, myVar2, ...)
+
+Sample Dump Output
+
+See the Dump example for details on the setup of the types and variables being
+shown here.
+
+	(main.Foo) {
+	 unexportedField: (*main.Bar)(0xf84002e210)({
+	  flag: (main.Flag) flagTwo,
+	  data: (uintptr) <nil>
+	 }),
+	 ExportedField: (map[interface {}]interface {}) (len=1) {
+	  (string) (len=3) "one": (bool) true
+	 }
+	}
+
+Byte (and uint8) arrays and slices are displayed uniquely like the hexdump -C
+command as shown.
+	([]uint8) (len=32 cap=32) {
+	 00000000  11 12 13 14 15 16 17 18  19 1a 1b 1c 1d 1e 1f 20  |............... |
+	 00000010  21 22 23 24 25 26 27 28  29 2a 2b 2c 2d 2e 2f 30  |!"#$%&'()*+,-./0|
+	 00000020  31 32                                             |12|
+	}
+
+Custom Formatter
+
+Spew provides a custom formatter that implements the fmt.Formatter interface
+so that it integrates cleanly with standard fmt package printing functions. The
+formatter is useful for inline printing of smaller data types similar to the
+standard %v format specifier.
+
+The custom formatter only responds to the %v (most compact), %+v (adds pointer
+addresses), %#v (adds types), or %#+v (adds types and pointer addresses) verb
+combinations.  Any other verbs such as %x and %q will be sent to the the
+standard fmt package for formatting.  In addition, the custom formatter ignores
+the width and precision arguments (however they will still work on the format
+specifiers not handled by the custom formatter).
+
+Custom Formatter Usage
+
+The simplest way to make use of the spew custom formatter is to call one of the
+convenience functions such as spew.Printf, spew.Println, or spew.Printf.  The
+functions have syntax you are most likely already familiar with:
+
+	spew.Printf("myVar1: %v -- myVar2: %+v", myVar1, myVar2)
+	spew.Printf("myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
+	spew.Println(myVar, myVar2)
+	spew.Fprintf(os.Stderr, "myVar1: %v -- myVar2: %+v", myVar1, myVar2)
+	spew.Fprintf(os.Stderr, "myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
+
+See the Index for the full list convenience functions.
+
+Sample Formatter Output
+
+Double pointer to a uint8:
+	  %v: <**>5
+	 %+v: <**>(0xf8400420d0->0xf8400420c8)5
+	 %#v: (**uint8)5
+	%#+v: (**uint8)(0xf8400420d0->0xf8400420c8)5
+
+Pointer to circular struct with a uint8 field and a pointer to itself:
+	  %v: <*>{1 <*><shown>}
+	 %+v: <*>(0xf84003e260){ui8:1 c:<*>(0xf84003e260)<shown>}
+	 %#v: (*main.circular){ui8:(uint8)1 c:(*main.circular)<shown>}
+	%#+v: (*main.circular)(0xf84003e260){ui8:(uint8)1 c:(*main.circular)(0xf84003e260)<shown>}
+
+See the Printf example for details on the setup of variables being shown
+here.
+
+Errors
+
+Since it is possible for custom Stringer/error interfaces to panic, spew
+detects them and handles them internally by printing the panic information
+inline with the output.  Since spew is intended to provide deep pretty printing
+capabilities on structures, it intentionally does not return any errors.
+*/
+package spew

vendor/github.com/davecgh/go-spew/spew/dump.go

@@ -0,0 +1,509 @@
+/*
+ * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+package spew
+
+import (
+	"bytes"
+	"encoding/hex"
+	"fmt"
+	"io"
+	"os"
+	"reflect"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+var (
+	// uint8Type is a reflect.Type representing a uint8.  It is used to
+	// convert cgo types to uint8 slices for hexdumping.
+	uint8Type = reflect.TypeOf(uint8(0))
+
+	// cCharRE is a regular expression that matches a cgo char.
+	// It is used to detect character arrays to hexdump them.
+	cCharRE = regexp.MustCompile(`^.*\._Ctype_char$`)
+
+	// cUnsignedCharRE is a regular expression that matches a cgo unsigned
+	// char.  It is used to detect unsigned character arrays to hexdump
+	// them.
+	cUnsignedCharRE = regexp.MustCompile(`^.*\._Ctype_unsignedchar$`)
+
+	// cUint8tCharRE is a regular expression that matches a cgo uint8_t.
+	// It is used to detect uint8_t arrays to hexdump them.
+	cUint8tCharRE = regexp.MustCompile(`^.*\._Ctype_uint8_t$`)
+)
+
+// dumpState contains information about the state of a dump operation.
+type dumpState struct {
+	w                io.Writer
+	depth            int
+	pointers         map[uintptr]int
+	ignoreNextType   bool
+	ignoreNextIndent bool
+	cs               *ConfigState
+}
+
+// indent performs indentation according to the depth level and cs.Indent
+// option.
+func (d *dumpState) indent() {
+	if d.ignoreNextIndent {
+		d.ignoreNextIndent = false
+		return
+	}
+	d.w.Write(bytes.Repeat([]byte(d.cs.Indent), d.depth))
+}
+
+// unpackValue returns values inside of non-nil interfaces when possible.
+// This is useful for data types like structs, arrays, slices, and maps which
+// can contain varying types packed inside an interface.
+func (d *dumpState) unpackValue(v reflect.Value) reflect.Value {
+	if v.Kind() == reflect.Interface && !v.IsNil() {
+		v = v.Elem()
+	}
+	return v
+}
+
+// dumpPtr handles formatting of pointers by indirecting them as necessary.
+func (d *dumpState) dumpPtr(v reflect.Value) {
+	// Remove pointers at or below the current depth from map used to detect
+	// circular refs.
+	for k, depth := range d.pointers {
+		if depth >= d.depth {
+			delete(d.pointers, k)
+		}
+	}
+
+	// Keep list of all dereferenced pointers to show later.
+	pointerChain := make([]uintptr, 0)
+
+	// Figure out how many levels of indirection there are by dereferencing
+	// pointers and unpacking interfaces down the chain while detecting circular
+	// references.
+	nilFound := false
+	cycleFound := false
+	indirects := 0
+	ve := v
+	for ve.Kind() == reflect.Ptr {
+		if ve.IsNil() {
+			nilFound = true
+			break
+		}
+		indirects++
+		addr := ve.Pointer()
+		pointerChain = append(pointerChain, addr)
+		if pd, ok := d.pointers[addr]; ok && pd < d.depth {
+			cycleFound = true
+			indirects--
+			break
+		}
+		d.pointers[addr] = d.depth
+
+		ve = ve.Elem()
+		if ve.Kind() == reflect.Interface {
+			if ve.IsNil() {
+				nilFound = true
+				break
+			}
+			ve = ve.Elem()
+		}
+	}
+
+	// Display type information.
+	d.w.Write(openParenBytes)
+	d.w.Write(bytes.Repeat(asteriskBytes, indirects))
+	d.w.Write([]byte(ve.Type().String()))
+	d.w.Write(closeParenBytes)
+
+	// Display pointer information.
+	if !d.cs.DisablePointerAddresses && len(pointerChain) > 0 {
+		d.w.Write(openParenBytes)
+		for i, addr := range pointerChain {
+			if i > 0 {
+				d.w.Write(pointerChainBytes)
+			}
+			printHexPtr(d.w, addr)
+		}
+		d.w.Write(closeParenBytes)
+	}
+
+	// Display dereferenced value.
+	d.w.Write(openParenBytes)
+	switch {
+	case nilFound:
+		d.w.Write(nilAngleBytes)
+
+	case cycleFound:
+		d.w.Write(circularBytes)
+
+	default:
+		d.ignoreNextType = true
+		d.dump(ve)
+	}
+	d.w.Write(closeParenBytes)
+}
+
+// dumpSlice handles formatting of arrays and slices.  Byte (uint8 under
+// reflection) arrays and slices are dumped in hexdump -C fashion.
+func (d *dumpState) dumpSlice(v reflect.Value) {
+	// Determine whether this type should be hex dumped or not.  Also,
+	// for types which should be hexdumped, try to use the underlying data
+	// first, then fall back to trying to convert them to a uint8 slice.
+	var buf []uint8
+	doConvert := false
+	doHexDump := false
+	numEntries := v.Len()
+	if numEntries > 0 {
+		vt := v.Index(0).Type()
+		vts := vt.String()
+		switch {
+		// C types that need to be converted.
+		case cCharRE.MatchString(vts):
+			fallthrough
+		case cUnsignedCharRE.MatchString(vts):
+			fallthrough
+		case cUint8tCharRE.MatchString(vts):
+			doConvert = true
+
+		// Try to use existing uint8 slices and fall back to converting
+		// and copying if that fails.
+		case vt.Kind() == reflect.Uint8:
+			// We need an addressable interface to convert the type
+			// to a byte slice.  However, the reflect package won't
+			// give us an interface on certain things like
+			// unexported struct fields in order to enforce
+			// visibility rules.  We use unsafe, when available, to
+			// bypass these restrictions since this package does not
+			// mutate the values.
+			vs := v
+			if !vs.CanInterface() || !vs.CanAddr() {
+				vs = unsafeReflectValue(vs)
+			}
+			if !UnsafeDisabled {
+				vs = vs.Slice(0, numEntries)
+
+				// Use the existing uint8 slice if it can be
+				// type asserted.
+				iface := vs.Interface()
+				if slice, ok := iface.([]uint8); ok {
+					buf = slice
+					doHexDump = true
+					break
+				}
+			}
+
+			// The underlying data needs to be converted if it can't
+			// be type asserted to a uint8 slice.
+			doConvert = true
+		}
+
+		// Copy and convert the underlying type if needed.
+		if doConvert && vt.ConvertibleTo(uint8Type) {
+			// Convert and copy each element into a uint8 byte
+			// slice.
+			buf = make([]uint8, numEntries)
+			for i := 0; i < numEntries; i++ {
+				vv := v.Index(i)
+				buf[i] = uint8(vv.Convert(uint8Type).Uint())
+			}
+			doHexDump = true
+		}
+	}
+
+	// Hexdump the entire slice as needed.
+	if doHexDump {
+		indent := strings.Repeat(d.cs.Indent, d.depth)
+		str := indent + hex.Dump(buf)
+		str = strings.Replace(str, "\n", "\n"+indent, -1)
+		str = strings.TrimRight(str, d.cs.Indent)
+		d.w.Write([]byte(str))
+		return
+	}
+
+	// Recursively call dump for each item.
+	for i := 0; i < numEntries; i++ {
+		d.dump(d.unpackValue(v.Index(i)))
+		if i < (numEntries - 1) {
+			d.w.Write(commaNewlineBytes)
+		} else {
+			d.w.Write(newlineBytes)
+		}
+	}
+}
+
+// dump is the main workhorse for dumping a value.  It uses the passed reflect
+// value to figure out what kind of object we are dealing with and formats it
+// appropriately.  It is a recursive function, however circular data structures
+// are detected and handled properly.
+func (d *dumpState) dump(v reflect.Value) {
+	// Handle invalid reflect values immediately.
+	kind := v.Kind()
+	if kind == reflect.Invalid {
+		d.w.Write(invalidAngleBytes)
+		return
+	}
+
+	// Handle pointers specially.
+	if kind == reflect.Ptr {
+		d.indent()
+		d.dumpPtr(v)
+		return
+	}
+
+	// Print type information unless already handled elsewhere.
+	if !d.ignoreNextType {
+		d.indent()
+		d.w.Write(openParenBytes)
+		d.w.Write([]byte(v.Type().String()))
+		d.w.Write(closeParenBytes)
+		d.w.Write(spaceBytes)
+	}
+	d.ignoreNextType = false
+
+	// Display length and capacity if the built-in len and cap functions
+	// work with the value's kind and the len/cap itself is non-zero.
+	valueLen, valueCap := 0, 0
+	switch v.Kind() {
+	case reflect.Array, reflect.Slice, reflect.Chan:
+		valueLen, valueCap = v.Len(), v.Cap()
+	case reflect.Map, reflect.String:
+		valueLen = v.Len()
+	}
+	if valueLen != 0 || !d.cs.DisableCapacities && valueCap != 0 {
+		d.w.Write(openParenBytes)
+		if valueLen != 0 {
+			d.w.Write(lenEqualsBytes)
+			printInt(d.w, int64(valueLen), 10)
+		}
+		if !d.cs.DisableCapacities && valueCap != 0 {
+			if valueLen != 0 {
+				d.w.Write(spaceBytes)
+			}
+			d.w.Write(capEqualsBytes)
+			printInt(d.w, int64(valueCap), 10)
+		}
+		d.w.Write(closeParenBytes)
+		d.w.Write(spaceBytes)
+	}
+
+	// Call Stringer/error interfaces if they exist and the handle methods flag
+	// is enabled
+	if !d.cs.DisableMethods {
+		if (kind != reflect.Invalid) && (kind != reflect.Interface) {
+			if handled := handleMethods(d.cs, d.w, v); handled {
+				return
+			}
+		}
+	}
+
+	switch kind {
+	case reflect.Invalid:
+		// Do nothing.  We should never get here since invalid has already
+		// been handled above.
+
+	case reflect.Bool:
+		printBool(d.w, v.Bool())
+
+	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
+		printInt(d.w, v.Int(), 10)
+
+	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
+		printUint(d.w, v.Uint(), 10)
+
+	case reflect.Float32:
+		printFloat(d.w, v.Float(), 32)
+
+	case reflect.Float64:
+		printFloat(d.w, v.Float(), 64)
+
+	case reflect.Complex64:
+		printComplex(d.w, v.Complex(), 32)
+
+	case reflect.Complex128:
+		printComplex(d.w, v.Complex(), 64)
+
+	case reflect.Slice:
+		if v.IsNil() {
+			d.w.Write(nilAngleBytes)
+			break
+		}
+		fallthrough
+
+	case reflect.Array:
+		d.w.Write(openBraceNewlineBytes)
+		d.depth++
+		if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) {
+			d.indent()
+			d.w.Write(maxNewlineBytes)
+		} else {
+			d.dumpSlice(v)
+		}
+		d.depth--
+		d.indent()
+		d.w.Write(closeBraceBytes)
+
+	case reflect.String:
+		d.w.Write([]byte(strconv.Quote(v.String())))
+
+	case reflect.Interface:
+		// The only time we should get here is for nil interfaces due to
+		// unpackValue calls.
+		if v.IsNil() {
+			d.w.Write(nilAngleBytes)
+		}
+
+	case reflect.Ptr:
+		// Do nothing.  We should never get here since pointers have already
+		// been handled above.
+
+	case reflect.Map:
+		// nil maps should be indicated as different than empty maps
+		if v.IsNil() {
+			d.w.Write(nilAngleBytes)
+			break
+		}
+
+		d.w.Write(openBraceNewlineBytes)
+		d.depth++
+		if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) {
+			d.indent()
+			d.w.Write(maxNewlineBytes)
+		} else {
+			numEntries := v.Len()
+			keys := v.MapKeys()
+			if d.cs.SortKeys {
+				sortValues(keys, d.cs)
+			}
+			for i, key := range keys {
+				d.dump(d.unpackValue(key))
+				d.w.Write(colonSpaceBytes)
+				d.ignoreNextIndent = true
+				d.dump(d.unpackValue(v.MapIndex(key)))
+				if i < (numEntries - 1) {
+					d.w.Write(commaNewlineBytes)
+				} else {
+					d.w.Write(newlineBytes)
+				}
+			}
+		}
+		d.depth--
+		d.indent()
+		d.w.Write(closeBraceBytes)
+
+	case reflect.Struct:
+		d.w.Write(openBraceNewlineBytes)
+		d.depth++
+		if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) {
+			d.indent()
+			d.w.Write(maxNewlineBytes)
+		} else {
+			vt := v.Type()
+			numFields := v.NumField()
+			for i := 0; i < numFields; i++ {
+				d.indent()
+				vtf := vt.Field(i)
+				d.w.Write([]byte(vtf.Name))
+				d.w.Write(colonSpaceBytes)
+				d.ignoreNextIndent = true
+				d.dump(d.unpackValue(v.Field(i)))
+				if i < (numFields - 1) {
+					d.w.Write(commaNewlineBytes)
+				} else {
+					d.w.Write(newlineBytes)
+				}
+			}
+		}
+		d.depth--
+		d.indent()
+		d.w.Write(closeBraceBytes)
+
+	case reflect.Uintptr:
+		printHexPtr(d.w, uintptr(v.Uint()))
+
+	case reflect.UnsafePointer, reflect.Chan, reflect.Func:
+		printHexPtr(d.w, v.Pointer())
+
+	// There were not any other types at the time this code was written, but
+	// fall back to letting the default fmt package handle it in case any new
+	// types are added.
+	default:
+		if v.CanInterface() {
+			fmt.Fprintf(d.w, "%v", v.Interface())
+		} else {
+			fmt.Fprintf(d.w, "%v", v.String())
+		}
+	}
+}
+
+// fdump is a helper function to consolidate the logic from the various public
+// methods which take varying writers and config states.
+func fdump(cs *ConfigState, w io.Writer, a ...interface{}) {
+	for _, arg := range a {
+		if arg == nil {
+			w.Write(interfaceBytes)
+			w.Write(spaceBytes)
+			w.Write(nilAngleBytes)
+			w.Write(newlineBytes)
+			continue
+		}
+
+		d := dumpState{w: w, cs: cs}
+		d.pointers = make(map[uintptr]int)
+		d.dump(reflect.ValueOf(arg))
+		d.w.Write(newlineBytes)
+	}
+}
+
+// Fdump formats and displays the passed arguments to io.Writer w.  It formats
+// exactly the same as Dump.
+func Fdump(w io.Writer, a ...interface{}) {
+	fdump(&Config, w, a...)
+}
+
+// Sdump returns a string with the passed arguments formatted exactly the same
+// as Dump.
+func Sdump(a ...interface{}) string {
+	var buf bytes.Buffer
+	fdump(&Config, &buf, a...)
+	return buf.String()
+}
+
+/*
+Dump displays the passed parameters to standard out with newlines, customizable
+indentation, and additional debug information such as complete types and all
+pointer addresses used to indirect to the final value.  It provides the
+following features over the built-in printing facilities provided by the fmt
+package:
+
+	* Pointers are dereferenced and followed
+	* Circular data structures are detected and handled properly
+	* Custom Stringer/error interfaces are optionally invoked, including
+	  on unexported types
+	* Custom types which only implement the Stringer/error interfaces via
+	  a pointer receiver are optionally invoked when passing non-pointer
+	  variables
+	* Byte arrays and slices are dumped like the hexdump -C command which
+	  includes offsets, byte values in hex, and ASCII output
+
+The configuration options are controlled by an exported package global,
+spew.Config.  See ConfigState for options documentation.
+
+See Fdump if you would prefer dumping to an arbitrary io.Writer or Sdump to
+get the formatted result as a string.
+*/
+func Dump(a ...interface{}) {
+	fdump(&Config, os.Stdout, a...)
+}

vendor/github.com/davecgh/go-spew/spew/format.go

@@ -0,0 +1,419 @@
+/*
+ * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+package spew
+
+import (
+	"bytes"
+	"fmt"
+	"reflect"
+	"strconv"
+	"strings"
+)
+
+// supportedFlags is a list of all the character flags supported by fmt package.
+const supportedFlags = "0-+# "
+
+// formatState implements the fmt.Formatter interface and contains information
+// about the state of a formatting operation.  The NewFormatter function can
+// be used to get a new Formatter which can be used directly as arguments
+// in standard fmt package printing calls.
+type formatState struct {
+	value          interface{}
+	fs             fmt.State
+	depth          int
+	pointers       map[uintptr]int
+	ignoreNextType bool
+	cs             *ConfigState
+}
+
+// buildDefaultFormat recreates the original format string without precision
+// and width information to pass in to fmt.Sprintf in the case of an
+// unrecognized type.  Unless new types are added to the language, this
+// function won't ever be called.
+func (f *formatState) buildDefaultFormat() (format string) {
+	buf := bytes.NewBuffer(percentBytes)
+
+	for _, flag := range supportedFlags {
+		if f.fs.Flag(int(flag)) {
+			buf.WriteRune(flag)
+		}
+	}
+
+	buf.WriteRune('v')
+
+	format = buf.String()
+	return format
+}
+
+// constructOrigFormat recreates the original format string including precision
+// and width information to pass along to the standard fmt package.  This allows
+// automatic deferral of all format strings this package doesn't support.
+func (f *formatState) constructOrigFormat(verb rune) (format string) {
+	buf := bytes.NewBuffer(percentBytes)
+
+	for _, flag := range supportedFlags {
+		if f.fs.Flag(int(flag)) {
+			buf.WriteRune(flag)
+		}
+	}
+
+	if width, ok := f.fs.Width(); ok {
+		buf.WriteString(strconv.Itoa(width))
+	}
+
+	if precision, ok := f.fs.Precision(); ok {
+		buf.Write(precisionBytes)
+		buf.WriteString(strconv.Itoa(precision))
+	}
+
+	buf.WriteRune(verb)
+
+	format = buf.String()
+	return format
+}
+
+// unpackValue returns values inside of non-nil interfaces when possible and
+// ensures that types for values which have been unpacked from an interface
+// are displayed when the show types flag is also set.
+// This is useful for data types like structs, arrays, slices, and maps which
+// can contain varying types packed inside an interface.
+func (f *formatState) unpackValue(v reflect.Value) reflect.Value {
+	if v.Kind() == reflect.Interface {
+		f.ignoreNextType = false
+		if !v.IsNil() {
+			v = v.Elem()
+		}
+	}
+	return v
+}
+
+// formatPtr handles formatting of pointers by indirecting them as necessary.
+func (f *formatState) formatPtr(v reflect.Value) {
+	// Display nil if top level pointer is nil.
+	showTypes := f.fs.Flag('#')
+	if v.IsNil() && (!showTypes || f.ignoreNextType) {
+		f.fs.Write(nilAngleBytes)
+		return
+	}
+
+	// Remove pointers at or below the current depth from map used to detect
+	// circular refs.
+	for k, depth := range f.pointers {
+		if depth >= f.depth {
+			delete(f.pointers, k)
+		}
+	}
+
+	// Keep list of all dereferenced pointers to possibly show later.
+	pointerChain := make([]uintptr, 0)
+
+	// Figure out how many levels of indirection there are by derferencing
+	// pointers and unpacking interfaces down the chain while detecting circular
+	// references.
+	nilFound := false
+	cycleFound := false
+	indirects := 0
+	ve := v
+	for ve.Kind() == reflect.Ptr {
+		if ve.IsNil() {
+			nilFound = true
+			break
+		}
+		indirects++
+		addr := ve.Pointer()
+		pointerChain = append(pointerChain, addr)
+		if pd, ok := f.pointers[addr]; ok && pd < f.depth {
+			cycleFound = true
+			indirects--
+			break
+		}
+		f.pointers[addr] = f.depth
+
+		ve = ve.Elem()
+		if ve.Kind() == reflect.Interface {
+			if ve.IsNil() {
+				nilFound = true
+				break
+			}
+			ve = ve.Elem()
+		}
+	}
+
+	// Display type or indirection level depending on flags.
+	if showTypes && !f.ignoreNextType {
+		f.fs.Write(openParenBytes)
+		f.fs.Write(bytes.Repeat(asteriskBytes, indirects))
+		f.fs.Write([]byte(ve.Type().String()))
+		f.fs.Write(closeParenBytes)
+	} else {
+		if nilFound || cycleFound {
+			indirects += strings.Count(ve.Type().String(), "*")
+		}
+		f.fs.Write(openAngleBytes)
+		f.fs.Write([]byte(strings.Repeat("*", indirects)))
+		f.fs.Write(closeAngleBytes)
+	}
+
+	// Display pointer information depending on flags.
+	if f.fs.Flag('+') && (len(pointerChain) > 0) {
+		f.fs.Write(openParenBytes)
+		for i, addr := range pointerChain {
+			if i > 0 {
+				f.fs.Write(pointerChainBytes)
+			}
+			printHexPtr(f.fs, addr)
+		}
+		f.fs.Write(closeParenBytes)
+	}
+
+	// Display dereferenced value.
+	switch {
+	case nilFound:
+		f.fs.Write(nilAngleBytes)
+
+	case cycleFound:
+		f.fs.Write(circularShortBytes)
+
+	default:
+		f.ignoreNextType = true
+		f.format(ve)
+	}
+}
+
+// format is the main workhorse for providing the Formatter interface.  It
+// uses the passed reflect value to figure out what kind of object we are
+// dealing with and formats it appropriately.  It is a recursive function,
+// however circular data structures are detected and handled properly.
+func (f *formatState) format(v reflect.Value) {
+	// Handle invalid reflect values immediately.
+	kind := v.Kind()
+	if kind == reflect.Invalid {
+		f.fs.Write(invalidAngleBytes)
+		return
+	}
+
+	// Handle pointers specially.
+	if kind == reflect.Ptr {
+		f.formatPtr(v)
+		return
+	}
+
+	// Print type information unless already handled elsewhere.
+	if !f.ignoreNextType && f.fs.Flag('#') {
+		f.fs.Write(openParenBytes)
+		f.fs.Write([]byte(v.Type().String()))
+		f.fs.Write(closeParenBytes)
+	}
+	f.ignoreNextType = false
+
+	// Call Stringer/error interfaces if they exist and the handle methods
+	// flag is enabled.
+	if !f.cs.DisableMethods {
+		if (kind != reflect.Invalid) && (kind != reflect.Interface) {
+			if handled := handleMethods(f.cs, f.fs, v); handled {
+				return
+			}
+		}
+	}
+
+	switch kind {
+	case reflect.Invalid:
+		// Do nothing.  We should never get here since invalid has already
+		// been handled above.
+
+	case reflect.Bool:
+		printBool(f.fs, v.Bool())
+
+	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
+		printInt(f.fs, v.Int(), 10)
+
+	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
+		printUint(f.fs, v.Uint(), 10)
+
+	case reflect.Float32:
+		printFloat(f.fs, v.Float(), 32)
+
+	case reflect.Float64:
+		printFloat(f.fs, v.Float(), 64)
+
+	case reflect.Complex64:
+		printComplex(f.fs, v.Complex(), 32)
+
+	case reflect.Complex128:
+		printComplex(f.fs, v.Complex(), 64)
+
+	case reflect.Slice:
+		if v.IsNil() {
+			f.fs.Write(nilAngleBytes)
+			break
+		}
+		fallthrough
+
+	case reflect.Array:
+		f.fs.Write(openBracketBytes)
+		f.depth++
+		if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) {
+			f.fs.Write(maxShortBytes)
+		} else {
+			numEntries := v.Len()
+			for i := 0; i < numEntries; i++ {
+				if i > 0 {
+					f.fs.Write(spaceBytes)
+				}
+				f.ignoreNextType = true
+				f.format(f.unpackValue(v.Index(i)))
+			}
+		}
+		f.depth--
+		f.fs.Write(closeBracketBytes)
+
+	case reflect.String:
+		f.fs.Write([]byte(v.String()))
+
+	case reflect.Interface:
+		// The only time we should get here is for nil interfaces due to
+		// unpackValue calls.
+		if v.IsNil() {
+			f.fs.Write(nilAngleBytes)
+		}
+
+	case reflect.Ptr:
+		// Do nothing.  We should never get here since pointers have already
+		// been handled above.
+
+	case reflect.Map:
+		// nil maps should be indicated as different than empty maps
+		if v.IsNil() {
+			f.fs.Write(nilAngleBytes)
+			break
+		}
+
+		f.fs.Write(openMapBytes)
+		f.depth++
+		if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) {
+			f.fs.Write(maxShortBytes)
+		} else {
+			keys := v.MapKeys()
+			if f.cs.SortKeys {
+				sortValues(keys, f.cs)
+			}
+			for i, key := range keys {
+				if i > 0 {
+					f.fs.Write(spaceBytes)
+				}
+				f.ignoreNextType = true
+				f.format(f.unpackValue(key))
+				f.fs.Write(colonBytes)
+				f.ignoreNextType = true
+				f.format(f.unpackValue(v.MapIndex(key)))
+			}
+		}
+		f.depth--
+		f.fs.Write(closeMapBytes)
+
+	case reflect.Struct:
+		numFields := v.NumField()
+		f.fs.Write(openBraceBytes)
+		f.depth++
+		if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) {
+			f.fs.Write(maxShortBytes)
+		} else {
+			vt := v.Type()
+			for i := 0; i < numFields; i++ {
+				if i > 0 {
+					f.fs.Write(spaceBytes)
+				}
+				vtf := vt.Field(i)
+				if f.fs.Flag('+') || f.fs.Flag('#') {
+					f.fs.Write([]byte(vtf.Name))
+					f.fs.Write(colonBytes)
+				}
+				f.format(f.unpackValue(v.Field(i)))
+			}
+		}
+		f.depth--
+		f.fs.Write(closeBraceBytes)
+
+	case reflect.Uintptr:
+		printHexPtr(f.fs, uintptr(v.Uint()))
+
+	case reflect.UnsafePointer, reflect.Chan, reflect.Func:
+		printHexPtr(f.fs, v.Pointer())
+
+	// There were not any other types at the time this code was written, but
+	// fall back to letting the default fmt package handle it if any get added.
+	default:
+		format := f.buildDefaultFormat()
+		if v.CanInterface() {
+			fmt.Fprintf(f.fs, format, v.Interface())
+		} else {
+			fmt.Fprintf(f.fs, format, v.String())
+		}
+	}
+}
+
+// Format satisfies the fmt.Formatter interface. See NewFormatter for usage
+// details.
+func (f *formatState) Format(fs fmt.State, verb rune) {
+	f.fs = fs
+
+	// Use standard formatting for verbs that are not v.
+	if verb != 'v' {
+		format := f.constructOrigFormat(verb)
+		fmt.Fprintf(fs, format, f.value)
+		return
+	}
+
+	if f.value == nil {
+		if fs.Flag('#') {
+			fs.Write(interfaceBytes)
+		}
+		fs.Write(nilAngleBytes)
+		return
+	}
+
+	f.format(reflect.ValueOf(f.value))
+}
+
+// newFormatter is a helper function to consolidate the logic from the various
+// public methods which take varying config states.
+func newFormatter(cs *ConfigState, v interface{}) fmt.Formatter {
+	fs := &formatState{value: v, cs: cs}
+	fs.pointers = make(map[uintptr]int)
+	return fs
+}
+
+/*
+NewFormatter returns a custom formatter that satisfies the fmt.Formatter
+interface.  As a result, it integrates cleanly with standard fmt package
+printing functions.  The formatter is useful for inline printing of smaller data
+types similar to the standard %v format specifier.
+
+The custom formatter only responds to the %v (most compact), %+v (adds pointer
+addresses), %#v (adds types), or %#+v (adds types and pointer addresses) verb
+combinations.  Any other verbs such as %x and %q will be sent to the the
+standard fmt package for formatting.  In addition, the custom formatter ignores
+the width and precision arguments (however they will still work on the format
+specifiers not handled by the custom formatter).
+
+Typically this function shouldn't be called directly.  It is much easier to make
+use of the custom formatter by calling one of the convenience functions such as
+Printf, Println, or Fprintf.
+*/
+func NewFormatter(v interface{}) fmt.Formatter {
+	return newFormatter(&Config, v)
+}

vendor/github.com/davecgh/go-spew/spew/spew.go

@@ -0,0 +1,148 @@
+/*
+ * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+package spew
+
+import (
+	"fmt"
+	"io"
+)
+
+// Errorf is a wrapper for fmt.Errorf that treats each argument as if it were
+// passed with a default Formatter interface returned by NewFormatter.  It
+// returns the formatted string as a value that satisfies error.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Errorf(format, spew.NewFormatter(a), spew.NewFormatter(b))
+func Errorf(format string, a ...interface{}) (err error) {
+	return fmt.Errorf(format, convertArgs(a)...)
+}
+
+// Fprint is a wrapper for fmt.Fprint that treats each argument as if it were
+// passed with a default Formatter interface returned by NewFormatter.  It
+// returns the number of bytes written and any write error encountered.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Fprint(w, spew.NewFormatter(a), spew.NewFormatter(b))
+func Fprint(w io.Writer, a ...interface{}) (n int, err error) {
+	return fmt.Fprint(w, convertArgs(a)...)
+}
+
+// Fprintf is a wrapper for fmt.Fprintf that treats each argument as if it were
+// passed with a default Formatter interface returned by NewFormatter.  It
+// returns the number of bytes written and any write error encountered.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Fprintf(w, format, spew.NewFormatter(a), spew.NewFormatter(b))
+func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) {
+	return fmt.Fprintf(w, format, convertArgs(a)...)
+}
+
+// Fprintln is a wrapper for fmt.Fprintln that treats each argument as if it
+// passed with a default Formatter interface returned by NewFormatter.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Fprintln(w, spew.NewFormatter(a), spew.NewFormatter(b))
+func Fprintln(w io.Writer, a ...interface{}) (n int, err error) {
+	return fmt.Fprintln(w, convertArgs(a)...)
+}
+
+// Print is a wrapper for fmt.Print that treats each argument as if it were
+// passed with a default Formatter interface returned by NewFormatter.  It
+// returns the number of bytes written and any write error encountered.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Print(spew.NewFormatter(a), spew.NewFormatter(b))
+func Print(a ...interface{}) (n int, err error) {
+	return fmt.Print(convertArgs(a)...)
+}
+
+// Printf is a wrapper for fmt.Printf that treats each argument as if it were
+// passed with a default Formatter interface returned by NewFormatter.  It
+// returns the number of bytes written and any write error encountered.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Printf(format, spew.NewFormatter(a), spew.NewFormatter(b))
+func Printf(format string, a ...interface{}) (n int, err error) {
+	return fmt.Printf(format, convertArgs(a)...)
+}
+
+// Println is a wrapper for fmt.Println that treats each argument as if it were
+// passed with a default Formatter interface returned by NewFormatter.  It
+// returns the number of bytes written and any write error encountered.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Println(spew.NewFormatter(a), spew.NewFormatter(b))
+func Println(a ...interface{}) (n int, err error) {
+	return fmt.Println(convertArgs(a)...)
+}
+
+// Sprint is a wrapper for fmt.Sprint that treats each argument as if it were
+// passed with a default Formatter interface returned by NewFormatter.  It
+// returns the resulting string.  See NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Sprint(spew.NewFormatter(a), spew.NewFormatter(b))
+func Sprint(a ...interface{}) string {
+	return fmt.Sprint(convertArgs(a)...)
+}
+
+// Sprintf is a wrapper for fmt.Sprintf that treats each argument as if it were
+// passed with a default Formatter interface returned by NewFormatter.  It
+// returns the resulting string.  See NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Sprintf(format, spew.NewFormatter(a), spew.NewFormatter(b))
+func Sprintf(format string, a ...interface{}) string {
+	return fmt.Sprintf(format, convertArgs(a)...)
+}
+
+// Sprintln is a wrapper for fmt.Sprintln that treats each argument as if it
+// were passed with a default Formatter interface returned by NewFormatter.  It
+// returns the resulting string.  See NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Sprintln(spew.NewFormatter(a), spew.NewFormatter(b))
+func Sprintln(a ...interface{}) string {
+	return fmt.Sprintln(convertArgs(a)...)
+}
+
+// convertArgs accepts a slice of arguments and returns a slice of the same
+// length with each argument converted to a default spew Formatter interface.
+func convertArgs(args []interface{}) (formatters []interface{}) {
+	formatters = make([]interface{}, len(args))
+	for index, arg := range args {
+		formatters[index] = NewFormatter(arg)
+	}
+	return formatters
+}

vendor/github.com/go-co-op/gocron/v2/.golangci.yaml

@@ -2,22 +2,27 @@ run:
   timeout: 5m
   issues-exit-code: 1
   tests: true
-  skip-dirs:
-    - local
 
 issues:
   max-same-issues: 100
   include:
     - EXC0012
     - EXC0014
+  exclude-dirs:
+    - local
+  exclude-rules:
+    - path: example_test.go
+      linters:
+        - revive
+      text: "seems to be unused"
+  fix: true
 
 linters:
   enable:
     - bodyclose
-    - exportloopref
+    - copyloopvar
     - gofumpt
     - goimports
-    - gosec
     - gosimple
     - govet
     - ineffassign
@@ -29,21 +34,9 @@ linters:
     - whitespace
 
 output:
-  # colored-line-number|line-number|json|tab|checkstyle|code-climate, default is "colored-line-number"
-  format: colored-line-number
-  # print lines of code with issue, default is true
+  formats:
+    - format: colored-line-number
   print-issued-lines: true
-  # print linter name in the end of issue text, default is true
   print-linter-name: true
-  # make issues output unique by line, default is true
-  uniq-by-line: true
-  # add a prefix to the output file references; default is no prefix
   path-prefix: ""
-  # sorts results by: filepath, line and column
   sort-results: true
-
-linters-settings:
-  golint:
-    min-confidence: 0.8
-
-fix: true

vendor/github.com/go-co-op/gocron/v2/.pre-commit-config.yaml

@@ -12,7 +12,7 @@ repos:
       - id: end-of-file-fixer
       - id: trailing-whitespace
   - repo: https://github.com/golangci/golangci-lint
-    rev: v1.55.2
+    rev: v1.64.5
     hooks:
       - id: golangci-lint
   - repo: https://github.com/TekWizely/pre-commit-golang

vendor/github.com/go-co-op/gocron/v2/Makefile

@@ -1,4 +1,4 @@
-.PHONY: fmt lint test mocks test_coverage
+.PHONY: fmt lint test mocks test_coverage test_ci
 
 GO_PKGS   := $(shell go list -f {{.Dir}} ./...)
 
@@ -6,7 +6,7 @@ fmt:
 	@go list -f {{.Dir}} ./... | xargs -I{} gofmt -w -s {}
 
 lint:
-	@grep "^func " example_test.go | sort -c
+	@grep "^func [a-zA-Z]" example_test.go | sort -c
 	@golangci-lint run
 
 test:
@@ -15,5 +15,8 @@ test:
 test_coverage:
 	@go test -race -v $(GO_FLAGS) -count=1 -coverprofile=coverage.out -covermode=atomic $(GO_PKGS)
 
+test_ci:
+	@go test -race -v $(GO_FLAGS) -count=1 $(GO_PKGS)
+
 mocks:
 	@go generate ./...

vendor/github.com/go-co-op/gocron/v2/README.md

@@ -53,6 +53,11 @@ func main() {
 	// start the scheduler
 	s.Start()
 
+	// block until you are ready to shut down
+	select {
+	case <-time.After(time.Minute):
+	}
+
 	// when you're done, shut it down
 	err = s.Shutdown()
 	if err != nil {
@@ -61,6 +66,11 @@ func main() {
 }
 ```
 
+## Examples
+
+- [Go doc examples](https://pkg.go.dev/github.com/go-co-op/gocron/v2#pkg-examples)
+- [Examples directory](examples)
+
 ## Concepts
 
 - **Job**: The job encapsulates a "task", which is made up of a go function and any function parameters. The Job then
@@ -88,7 +98,7 @@ Jobs can be run every x weeks on specific days of the week and at specific times
 - [**Monthly**](https://pkg.go.dev/github.com/go-co-op/gocron/v2#MonthlyJob):
 Jobs can be run every x months on specific days of the month and at specific times.
 - [**One time**](https://pkg.go.dev/github.com/go-co-op/gocron/v2#OneTimeJob):
-Jobs can be run once at a specific time. These are non-recurring jobs.
+Jobs can be run at specific time(s) (either once or many times).
 
 ### Concurrency Limits
 Jobs can be limited individually or across the entire scheduler.
@@ -106,10 +116,13 @@ Multiple instances of gocron can be run.
 - [**Elector**](https://pkg.go.dev/github.com/go-co-op/gocron/v2#WithDistributedElector):
 An elector can be used to elect a single instance of gocron to run as the primary with the
 other instances checking to see if a new leader needs to be elected.
-- Implementations: [go-co-op electors](https://github.com/go-co-op?q=-elector&type=all&language=&sort=)
+  - Implementations: [go-co-op electors](https://github.com/go-co-op?q=-elector&type=all&language=&sort=)
+    (don't see what you need? request on slack to get a repo created to contribute it!)
 - [**Locker**](https://pkg.go.dev/github.com/go-co-op/gocron/v2#WithDistributedLocker):
 A locker can be used to lock each run of a job to a single instance of gocron.
-- Implementations: [go-co-op lockers](https://github.com/go-co-op?q=-lock&type=all&language=&sort=)
+Locker can be at job or scheduler, if it is defined both at job and scheduler then locker of job will take precedence.
+  - Implementations: [go-co-op lockers](https://github.com/go-co-op?q=-lock&type=all&language=&sort=)
+    (don't see what you need? request on slack to get a repo created to contribute it!)
 
 ### Events
 Job events can trigger actions.
@@ -135,6 +148,14 @@ Logs can be enabled.
 The Logger interface can be implemented with your desired logging library.
 The provided NewLogger uses the standard library's log package.
 
+### Metrics
+Metrics may be collected from the execution of each job.
+- [**Monitor**](https://pkg.go.dev/github.com/go-co-op/gocron/v2#Monitor):
+- [**MonitorStatus**](https://pkg.go.dev/github.com/go-co-op/gocron/v2#MonitorStatus) (includes status and error (if any) of the Job)
+A monitor can be used to collect metrics for each job from a scheduler.
+  - Implementations: [go-co-op monitors](https://github.com/go-co-op?q=-monitor&type=all&language=&sort=)
+    (don't see what you need? request on slack to get a repo created to contribute it!)
+
 ### Testing
 The gocron library is set up to enable testing.
 - Mocks are provided in [the mock package](mocks) using [gomock](https://github.com/uber-go/mock).
@@ -148,8 +169,20 @@ We appreciate the support for free and open source software!
 
 This project is supported by:
 
-- [Jetbrains](https://www.jetbrains.com/?from=gocron)
-- [Sentry](https://sentry.io/welcome/)
+[Jetbrains](https://www.jetbrains.com/?from=gocron)
+
+![JetBrains logo](https://resources.jetbrains.com/storage/products/company/brand/logos/jetbrains.png)
+
+
+[Sentry](https://sentry.io/welcome/)
+
+<p align="left">
+  <p align="left">
+    <a href="https://sentry.io/?utm_source=github&utm_medium=logo" target="_blank">
+      <img src="https://sentry-brand.storage.googleapis.com/sentry-wordmark-dark-280x84.png" alt="Sentry" width="280" height="84" />
+    </a>
+  </p>
+</p>
 
 ## Star History
 

vendor/github.com/go-co-op/gocron/v2/SECURITY.md

@@ -2,14 +2,15 @@
 
 ## Supported Versions
 
-The current plan is to maintain version 1 as long as possible incorporating any necessary security patches.
+The current plan is to maintain version 2 as long as possible incorporating any necessary security patches. Version 1 is deprecated and will no longer be patched.
 
 | Version | Supported          |
 | ------- | ------------------ |
-| 1.x.x   | :white_check_mark: |
+| 1.x.x   | :heavy_multiplication_x: |
+| 2.x.x   | :white_check_mark: |
 
 ## Reporting a Vulnerability
 
 Vulnerabilities can be reported by [opening an issue](https://github.com/go-co-op/gocron/issues/new/choose) or reaching out on Slack: [<img src="https://img.shields.io/badge/gophers-gocron-brightgreen?logo=slack">](https://gophers.slack.com/archives/CQ7T0T1FW)
 
-We will do our best to addrerss any vulnerabilities in an expeditious manner.
+We will do our best to address any vulnerabilities in an expeditious manner.

vendor/github.com/go-co-op/gocron/v2/codecov.yml

@@ -1,5 +0,0 @@
-coverage:
-  status:
-    project:
-      default:
-        if_ci_failed: success

vendor/github.com/go-co-op/gocron/v2/errors.go

@@ -4,11 +4,14 @@ import "fmt"
 
 // Public error definitions
 var (
+	ErrCronJobInvalid                = fmt.Errorf("gocron: CronJob: invalid crontab")
 	ErrCronJobParse                  = fmt.Errorf("gocron: CronJob: crontab parse failure")
 	ErrDailyJobAtTimeNil             = fmt.Errorf("gocron: DailyJob: atTime within atTimes must not be nil")
 	ErrDailyJobAtTimesNil            = fmt.Errorf("gocron: DailyJob: atTimes must not be nil")
 	ErrDailyJobHours                 = fmt.Errorf("gocron: DailyJob: atTimes hours must be between 0 and 23 inclusive")
+	ErrDailyJobZeroInterval          = fmt.Errorf("gocron: DailyJob: interval must be greater than 0")
 	ErrDailyJobMinutesSeconds        = fmt.Errorf("gocron: DailyJob: atTimes minutes and seconds must be between 0 and 59 inclusive")
+	ErrDurationJobIntervalZero       = fmt.Errorf("gocron: DurationJob: time interval is 0")
 	ErrDurationRandomJobMinMax       = fmt.Errorf("gocron: DurationRandomJob: minimum duration must be less than maximum duration")
 	ErrEventListenerFuncNil          = fmt.Errorf("gocron: eventListenerFunc must not be nil")
 	ErrJobNotFound                   = fmt.Errorf("gocron: job not found")
@@ -18,6 +21,7 @@ var (
 	ErrMonthlyJobAtTimesNil          = fmt.Errorf("gocron: MonthlyJob: atTimes must not be nil")
 	ErrMonthlyJobDaysNil             = fmt.Errorf("gocron: MonthlyJob: daysOfTheMonth must not be nil")
 	ErrMonthlyJobHours               = fmt.Errorf("gocron: MonthlyJob: atTimes hours must be between 0 and 23 inclusive")
+	ErrMonthlyJobZeroInterval        = fmt.Errorf("gocron: MonthlyJob: interval must be greater than 0")
 	ErrMonthlyJobMinutesSeconds      = fmt.Errorf("gocron: MonthlyJob: atTimes minutes and seconds must be between 0 and 59 inclusive")
 	ErrNewJobTaskNil                 = fmt.Errorf("gocron: NewJob: Task must not be nil")
 	ErrNewJobTaskNotFunc             = fmt.Errorf("gocron: NewJob: Task.Function must be of kind reflect.Func")
@@ -31,15 +35,24 @@ var (
 	ErrWeeklyJobAtTimesNil           = fmt.Errorf("gocron: WeeklyJob: atTimes must not be nil")
 	ErrWeeklyJobDaysOfTheWeekNil     = fmt.Errorf("gocron: WeeklyJob: daysOfTheWeek must not be nil")
 	ErrWeeklyJobHours                = fmt.Errorf("gocron: WeeklyJob: atTimes hours must be between 0 and 23 inclusive")
+	ErrWeeklyJobZeroInterval         = fmt.Errorf("gocron: WeeklyJob: interval must be greater than 0")
 	ErrWeeklyJobMinutesSeconds       = fmt.Errorf("gocron: WeeklyJob: atTimes minutes and seconds must be between 0 and 59 inclusive")
+	ErrPanicRecovered                = fmt.Errorf("gocron: panic recovered")
 	ErrWithClockNil                  = fmt.Errorf("gocron: WithClock: clock must not be nil")
+	ErrWithContextNil                = fmt.Errorf("gocron: WithContext: context must not be nil")
 	ErrWithDistributedElectorNil     = fmt.Errorf("gocron: WithDistributedElector: elector must not be nil")
 	ErrWithDistributedLockerNil      = fmt.Errorf("gocron: WithDistributedLocker: locker must not be nil")
+	ErrWithDistributedJobLockerNil   = fmt.Errorf("gocron: WithDistributedJobLocker: locker must not be nil")
+	ErrWithIdentifierNil             = fmt.Errorf("gocron: WithIdentifier: identifier must not be nil")
 	ErrWithLimitConcurrentJobsZero   = fmt.Errorf("gocron: WithLimitConcurrentJobs: limit must be greater than 0")
 	ErrWithLocationNil               = fmt.Errorf("gocron: WithLocation: location must not be nil")
 	ErrWithLoggerNil                 = fmt.Errorf("gocron: WithLogger: logger must not be nil")
+	ErrWithMonitorNil                = fmt.Errorf("gocron: WithMonitor: monitor must not be nil")
 	ErrWithNameEmpty                 = fmt.Errorf("gocron: WithName: name must not be empty")
 	ErrWithStartDateTimePast         = fmt.Errorf("gocron: WithStartDateTime: start must not be in the past")
+	ErrWithStopDateTimePast          = fmt.Errorf("gocron: WithStopDateTime: end must not be in the past")
+	ErrStartTimeLaterThanEndTime     = fmt.Errorf("gocron: WithStartDateTime: start must not be later than end")
+	ErrStopTimeEarlierThanStartTime  = fmt.Errorf("gocron: WithStopDateTime: end must not be earlier than start")
 	ErrWithStopTimeoutZeroOrNegative = fmt.Errorf("gocron: WithStopTimeout: timeout must be greater than 0")
 )
 

vendor/github.com/go-co-op/gocron/v2/executor.go

@@ -2,27 +2,60 @@ package gocron
 
 import (
 	"context"
+	"fmt"
 	"strconv"
 	"sync"
 	"time"
 
+	"github.com/jonboulle/clockwork"
+
 	"github.com/google/uuid"
 )
 
 type executor struct {
-	ctx              context.Context
-	cancel           context.CancelFunc
-	logger           Logger
-	stopCh           chan struct{}
-	jobsIn           chan jobIn
-	jobIDsOut        chan uuid.UUID
-	jobOutRequest    chan jobOutRequest
-	stopTimeout      time.Duration
-	done             chan error
-	singletonRunners map[uuid.UUID]singletonRunner
-	limitMode        *limitModeConfig
-	elector          Elector
-	locker           Locker
+	// context used for shutting down
+	ctx context.Context
+	// cancel used by the executor to signal a stop of it's functions
+	cancel context.CancelFunc
+	// clock used for regular time or mocking time
+	clock clockwork.Clock
+	// the executor's logger
+	logger Logger
+
+	// receives jobs scheduled to execute
+	jobsIn chan jobIn
+	// sends out jobs for rescheduling
+	jobsOutForRescheduling chan uuid.UUID
+	// sends out jobs once completed
+	jobsOutCompleted chan uuid.UUID
+	// used to request jobs from the scheduler
+	jobOutRequest chan jobOutRequest
+
+	// sends out job needs to update the next runs
+	jobUpdateNextRuns chan uuid.UUID
+
+	// used by the executor to receive a stop signal from the scheduler
+	stopCh chan struct{}
+	// ensure that stop runs before the next call to start and only runs once
+	stopOnce *sync.Once
+	// the timeout value when stopping
+	stopTimeout time.Duration
+	// used to signal that the executor has completed shutdown
+	done chan error
+
+	// runners for any singleton type jobs
+	// map[uuid.UUID]singletonRunner
+	singletonRunners *sync.Map
+	// config for limit mode
+	limitMode *limitModeConfig
+	// the elector when running distributed instances
+	elector Elector
+	// the locker when running distributed instances
+	locker Locker
+	// monitor for reporting metrics
+	monitor Monitor
+	// monitorStatus for reporting metrics
+	monitorStatus MonitorStatus
 }
 
 type jobIn struct {
@@ -57,6 +90,7 @@ func (e *executor) start() {
 	// any other uses within the executor should create a context
 	// using the executor context as parent.
 	e.ctx, e.cancel = context.WithCancel(context.Background())
+	e.stopOnce = &sync.Once{}
 
 	// the standardJobsWg tracks
 	standardJobsWg := &waitGroupWithMutex{}
@@ -66,7 +100,7 @@ func (e *executor) start() {
 	limitModeJobsWg := &waitGroupWithMutex{}
 
 	// create a fresh map for tracking singleton runners
-	e.singletonRunners = make(map[uuid.UUID]singletonRunner)
+	e.singletonRunners = &sync.Map{}
 
 	// start the for leap that is the executor
 	// selecting on channels for work to do
@@ -100,7 +134,7 @@ func (e *executor) start() {
 
 			// spin off into a goroutine to unblock the executor and
 			// allow for processing for more work
-			go func() {
+			go func(executorCtx context.Context) {
 				// make sure to cancel the above context per the docs
 				// // Canceling this context releases resources associated with it, so code should
 				// // call cancel as soon as the operations running in this Context complete.
@@ -121,12 +155,7 @@ func (e *executor) start() {
 							// all runners are busy, reschedule the work for later
 							// which means we just skip it here and do nothing
 							// TODO when metrics are added, this should increment a rescheduled metric
-							if jIn.shouldSendOut {
-								select {
-								case e.jobIDsOut <- jIn.id:
-								default:
-								}
-							}
+							e.sendOutForRescheduling(&jIn)
 						}
 					} else {
 						// since we're not using LimitModeReschedule, but instead using LimitModeWait
@@ -134,6 +163,7 @@ func (e *executor) start() {
 						// to work through the channel backlog. A hard limit of 1000 is in place
 						// at which point this call would block.
 						// TODO when metrics are added, this should increment a wait metric
+						e.sendOutForRescheduling(&jIn)
 						e.limitMode.in <- jIn
 					}
 				} else {
@@ -150,15 +180,18 @@ func (e *executor) start() {
 					if j.singletonMode {
 						// for singleton mode, get the existing runner for the job
 						// or spin up a new one
-						runner, ok := e.singletonRunners[jIn.id]
+						runner := &singletonRunner{}
+						runnerSrc, ok := e.singletonRunners.Load(jIn.id)
 						if !ok {
 							runner.in = make(chan jobIn, 1000)
 							if j.singletonLimitMode == LimitModeReschedule {
 								runner.rescheduleLimiter = make(chan struct{}, 1)
 							}
-							e.singletonRunners[jIn.id] = runner
+							e.singletonRunners.Store(jIn.id, runner)
 							singletonJobsWg.Add(1)
 							go e.singletonModeRunner("singleton-"+jIn.id.String(), runner.in, singletonJobsWg, j.singletonLimitMode, runner.rescheduleLimiter)
+						} else {
+							runner = runnerSrc.(*singletonRunner)
 						}
 
 						if j.singletonLimitMode == LimitModeReschedule {
@@ -167,25 +200,21 @@ func (e *executor) start() {
 							select {
 							case runner.rescheduleLimiter <- struct{}{}:
 								runner.in <- jIn
+								e.sendOutForRescheduling(&jIn)
 							default:
 								// runner is busy, reschedule the work for later
 								// which means we just skip it here and do nothing
-								// TODO when metrics are added, this should increment a rescheduled metric
-								if jIn.shouldSendOut {
-									select {
-									case e.jobIDsOut <- jIn.id:
-									default:
-									}
-								}
+								e.incrementJobCounter(*j, SingletonRescheduled)
+								e.sendOutForRescheduling(&jIn)
 							}
 						} else {
 							// wait mode, fill up that queue (buffered channel, so it's ok)
 							runner.in <- jIn
+							e.sendOutForRescheduling(&jIn)
 						}
 					} else {
 						select {
-						case <-e.stopCh:
-							e.stop(standardJobsWg, singletonJobsWg, limitModeJobsWg)
+						case <-executorCtx.Done():
 							return
 						default:
 						}
@@ -196,12 +225,12 @@ func (e *executor) start() {
 						// complete.
 						standardJobsWg.Add(1)
 						go func(j internalJob) {
-							e.runJob(j, jIn.shouldSendOut)
+							e.runJob(j, jIn)
 							standardJobsWg.Done()
 						}(*j)
 					}
 				}
-			}()
+			}(e.ctx)
 		case <-e.stopCh:
 			e.stop(standardJobsWg, singletonJobsWg, limitModeJobsWg)
 			return
@@ -209,6 +238,28 @@ func (e *executor) start() {
 	}
 }
 
+func (e *executor) sendOutForRescheduling(jIn *jobIn) {
+	if jIn.shouldSendOut {
+		select {
+		case e.jobsOutForRescheduling <- jIn.id:
+		case <-e.ctx.Done():
+			return
+		}
+	}
+	// we need to set this to false now, because to handle
+	// non-limit jobs, we send out from the e.runJob function
+	// and in this case we don't want to send out twice.
+	jIn.shouldSendOut = false
+}
+
+func (e *executor) sendOutForNextRunUpdate(jIn *jobIn) {
+	select {
+	case e.jobUpdateNextRuns <- jIn.id:
+	case <-e.ctx.Done():
+		return
+	}
+}
+
 func (e *executor) limitModeRunner(name string, in chan jobIn, wg *waitGroupWithMutex, limitMode LimitMode, rescheduleLimiter chan struct{}) {
 	e.logger.Debug("gocron: limitModeRunner starting", "name", name)
 	for {
@@ -239,24 +290,21 @@ func (e *executor) limitModeRunner(name string, in chan jobIn, wg *waitGroupWith
 								return
 							case <-j.ctx.Done():
 								return
-							case e.jobIDsOut <- j.id:
+							case e.jobsOutForRescheduling <- j.id:
 							}
 						}
 						// remove the limiter block, as this particular job
 						// was a singleton already running, and we want to
 						// allow another job to be scheduled
 						if limitMode == LimitModeReschedule {
-							select {
-							case <-rescheduleLimiter:
-							default:
-							}
+							<-rescheduleLimiter
 						}
 						continue
 					}
 					e.limitMode.singletonJobs[jIn.id] = struct{}{}
 					e.limitMode.singletonJobsMu.Unlock()
 				}
-				e.runJob(*j, jIn.shouldSendOut)
+				e.runJob(*j, jIn)
 
 				if j.singletonMode {
 					e.limitMode.singletonJobsMu.Lock()
@@ -267,10 +315,7 @@ func (e *executor) limitModeRunner(name string, in chan jobIn, wg *waitGroupWith
 
 			// remove the limiter block to allow another job to be scheduled
 			if limitMode == LimitModeReschedule {
-				select {
-				case <-rescheduleLimiter:
-				default:
-				}
+				<-rescheduleLimiter
 			}
 		case <-e.ctx.Done():
 			e.logger.Debug("limitModeRunner shutting down", "name", name)
@@ -297,15 +342,16 @@ func (e *executor) singletonModeRunner(name string, in chan jobIn, wg *waitGroup
 			j := requestJobCtx(ctx, jIn.id, e.jobOutRequest)
 			cancel()
 			if j != nil {
-				e.runJob(*j, jIn.shouldSendOut)
+				// need to set shouldSendOut = false here, as there is a duplicative call to sendOutForRescheduling
+				// inside the runJob function that needs to be skipped. sendOutForRescheduling is previously called
+				// when the job is sent to the singleton mode runner.
+				jIn.shouldSendOut = false
+				e.runJob(*j, jIn)
 			}
 
 			// remove the limiter block to allow another job to be scheduled
 			if limitMode == LimitModeReschedule {
-				select {
-				case <-rescheduleLimiter:
-				default:
-				}
+				<-rescheduleLimiter
 			}
 		case <-e.ctx.Done():
 			e.logger.Debug("singletonModeRunner shutting down", "name", name)
@@ -315,7 +361,7 @@ func (e *executor) singletonModeRunner(name string, in chan jobIn, wg *waitGroup
 	}
 }
 
-func (e *executor) runJob(j internalJob, shouldSendOut bool) {
+func (e *executor) runJob(j internalJob, jIn jobIn) {
 	if j.ctx == nil {
 		return
 	}
@@ -327,114 +373,190 @@ func (e *executor) runJob(j internalJob, shouldSendOut bool) {
 	default:
 	}
 
+	if j.stopTimeReached(e.clock.Now()) {
+		return
+	}
+
 	if e.elector != nil {
 		if err := e.elector.IsLeader(j.ctx); err != nil {
+			e.sendOutForRescheduling(&jIn)
+			e.incrementJobCounter(j, Skip)
 			return
 		}
-	} else if e.locker != nil {
+	} else if !j.disabledLocker && j.locker != nil {
+		lock, err := j.locker.Lock(j.ctx, j.name)
+		if err != nil {
+			_ = callJobFuncWithParams(j.afterLockError, j.id, j.name, err)
+			e.sendOutForRescheduling(&jIn)
+			e.incrementJobCounter(j, Skip)
+			e.sendOutForNextRunUpdate(&jIn)
+			return
+		}
+		defer func() { _ = lock.Unlock(j.ctx) }()
+	} else if !j.disabledLocker && e.locker != nil {
 		lock, err := e.locker.Lock(j.ctx, j.name)
 		if err != nil {
+			_ = callJobFuncWithParams(j.afterLockError, j.id, j.name, err)
+			e.sendOutForRescheduling(&jIn)
+			e.incrementJobCounter(j, Skip)
+			e.sendOutForNextRunUpdate(&jIn)
 			return
 		}
 		defer func() { _ = lock.Unlock(j.ctx) }()
 	}
+
 	_ = callJobFuncWithParams(j.beforeJobRuns, j.id, j.name)
 
-	if shouldSendOut {
+	err := callJobFuncWithParams(j.beforeJobRunsSkipIfBeforeFuncErrors, j.id, j.name)
+	if err != nil {
+		e.sendOutForRescheduling(&jIn)
+
 		select {
+		case e.jobsOutCompleted <- j.id:
 		case <-e.ctx.Done():
-			return
-		case <-j.ctx.Done():
-			return
-		case e.jobIDsOut <- j.id:
 		}
+
+		return
 	}
 
-	err := callJobFuncWithParams(j.function, j.parameters...)
+	e.sendOutForRescheduling(&jIn)
+	select {
+	case e.jobsOutCompleted <- j.id:
+	case <-e.ctx.Done():
+	}
+
+	startTime := time.Now()
+	if j.afterJobRunsWithPanic != nil {
+		err = e.callJobWithRecover(j)
+	} else {
+		err = callJobFuncWithParams(j.function, j.parameters...)
+	}
+	e.recordJobTiming(startTime, time.Now(), j)
 	if err != nil {
 		_ = callJobFuncWithParams(j.afterJobRunsWithError, j.id, j.name, err)
+		e.incrementJobCounter(j, Fail)
+		e.recordJobTimingWithStatus(startTime, time.Now(), j, Fail, err)
 	} else {
 		_ = callJobFuncWithParams(j.afterJobRuns, j.id, j.name)
+		e.incrementJobCounter(j, Success)
+		e.recordJobTimingWithStatus(startTime, time.Now(), j, Success, nil)
+	}
+}
+
+func (e *executor) callJobWithRecover(j internalJob) (err error) {
+	defer func() {
+		if recoverData := recover(); recoverData != nil {
+			_ = callJobFuncWithParams(j.afterJobRunsWithPanic, j.id, j.name, recoverData)
+
+			// if panic is occurred, we should return an error
+			err = fmt.Errorf("%w from %v", ErrPanicRecovered, recoverData)
+		}
+	}()
+
+	return callJobFuncWithParams(j.function, j.parameters...)
+}
+
+func (e *executor) recordJobTiming(start time.Time, end time.Time, j internalJob) {
+	if e.monitor != nil {
+		e.monitor.RecordJobTiming(start, end, j.id, j.name, j.tags)
+	}
+}
+
+func (e *executor) recordJobTimingWithStatus(start time.Time, end time.Time, j internalJob, status JobStatus, err error) {
+	if e.monitorStatus != nil {
+		e.monitorStatus.RecordJobTimingWithStatus(start, end, j.id, j.name, j.tags, status, err)
+	}
+}
+
+func (e *executor) incrementJobCounter(j internalJob, status JobStatus) {
+	if e.monitor != nil {
+		e.monitor.IncrementJob(j.id, j.name, j.tags, status)
 	}
 }
 
 func (e *executor) stop(standardJobsWg, singletonJobsWg, limitModeJobsWg *waitGroupWithMutex) {
-	e.logger.Debug("gocron: stopping executor")
-	// we've been asked to stop. This is either because the scheduler has been told
-	// to stop all jobs or the scheduler has been asked to completely shutdown.
-	//
-	// cancel tells all the functions to stop their work and send in a done response
-	e.cancel()
+	e.stopOnce.Do(func() {
+		e.logger.Debug("gocron: stopping executor")
+		// we've been asked to stop. This is either because the scheduler has been told
+		// to stop all jobs or the scheduler has been asked to completely shutdown.
+		//
+		// cancel tells all the functions to stop their work and send in a done response
+		e.cancel()
 
-	// the wait for job channels are used to report back whether we successfully waited
-	// for all jobs to complete or if we hit the configured timeout.
-	waitForJobs := make(chan struct{}, 1)
-	waitForSingletons := make(chan struct{}, 1)
-	waitForLimitMode := make(chan struct{}, 1)
+		// the wait for job channels are used to report back whether we successfully waited
+		// for all jobs to complete or if we hit the configured timeout.
+		waitForJobs := make(chan struct{}, 1)
+		waitForSingletons := make(chan struct{}, 1)
+		waitForLimitMode := make(chan struct{}, 1)
 
-	// the waiter context is used to cancel the functions waiting on jobs.
-	// this is done to avoid goroutine leaks.
-	waiterCtx, waiterCancel := context.WithCancel(context.Background())
+		// the waiter context is used to cancel the functions waiting on jobs.
+		// this is done to avoid goroutine leaks.
+		waiterCtx, waiterCancel := context.WithCancel(context.Background())
 
-	// wait for standard jobs to complete
-	go func() {
-		e.logger.Debug("gocron: waiting for standard jobs to complete")
+		// wait for standard jobs to complete
 		go func() {
-			// this is done in a separate goroutine, so we aren't
-			// blocked by the WaitGroup's Wait call in the event
-			// that the waiter context is cancelled.
-			// This particular goroutine could leak in the event that
-			// some long-running standard job doesn't complete.
-			standardJobsWg.Wait()
-			e.logger.Debug("gocron: standard jobs completed")
-			waitForJobs <- struct{}{}
+			e.logger.Debug("gocron: waiting for standard jobs to complete")
+			go func() {
+				// this is done in a separate goroutine, so we aren't
+				// blocked by the WaitGroup's Wait call in the event
+				// that the waiter context is cancelled.
+				// This particular goroutine could leak in the event that
+				// some long-running standard job doesn't complete.
+				standardJobsWg.Wait()
+				e.logger.Debug("gocron: standard jobs completed")
+				waitForJobs <- struct{}{}
+			}()
+			<-waiterCtx.Done()
 		}()
-		<-waiterCtx.Done()
-	}()
 
-	// wait for per job singleton limit mode runner jobs to complete
-	go func() {
-		e.logger.Debug("gocron: waiting for singleton jobs to complete")
+		// wait for per job singleton limit mode runner jobs to complete
 		go func() {
-			singletonJobsWg.Wait()
-			e.logger.Debug("gocron: singleton jobs completed")
-			waitForSingletons <- struct{}{}
+			e.logger.Debug("gocron: waiting for singleton jobs to complete")
+			go func() {
+				singletonJobsWg.Wait()
+				e.logger.Debug("gocron: singleton jobs completed")
+				waitForSingletons <- struct{}{}
+			}()
+			<-waiterCtx.Done()
 		}()
-		<-waiterCtx.Done()
-	}()
 
-	// wait for limit mode runners to complete
-	go func() {
-		e.logger.Debug("gocron: waiting for limit mode jobs to complete")
+		// wait for limit mode runners to complete
 		go func() {
-			limitModeJobsWg.Wait()
-			e.logger.Debug("gocron: limitMode jobs completed")
-			waitForLimitMode <- struct{}{}
+			e.logger.Debug("gocron: waiting for limit mode jobs to complete")
+			go func() {
+				limitModeJobsWg.Wait()
+				e.logger.Debug("gocron: limitMode jobs completed")
+				waitForLimitMode <- struct{}{}
+			}()
+			<-waiterCtx.Done()
 		}()
-		<-waiterCtx.Done()
-	}()
 
-	// now either wait for all the jobs to complete,
-	// or hit the timeout.
-	var count int
-	timeout := time.Now().Add(e.stopTimeout)
-	for time.Now().Before(timeout) && count < 3 {
-		select {
-		case <-waitForJobs:
-			count++
-		case <-waitForSingletons:
-			count++
-		case <-waitForLimitMode:
-			count++
-		default:
+		// now either wait for all the jobs to complete,
+		// or hit the timeout.
+		var count int
+		timeout := time.Now().Add(e.stopTimeout)
+		for time.Now().Before(timeout) && count < 3 {
+			select {
+			case <-waitForJobs:
+				count++
+			case <-waitForSingletons:
+				count++
+			case <-waitForLimitMode:
+				count++
+			default:
+			}
 		}
-	}
-	if count < 3 {
-		e.done <- ErrStopJobsTimedOut
-		e.logger.Debug("gocron: executor stopped - timed out")
-	} else {
-		e.done <- nil
-		e.logger.Debug("gocron: executor stopped")
-	}
-	waiterCancel()
+		if count < 3 {
+			e.done <- ErrStopJobsTimedOut
+			e.logger.Debug("gocron: executor stopped - timed out")
+		} else {
+			e.done <- nil
+			e.logger.Debug("gocron: executor stopped")
+		}
+		waiterCancel()
+
+		if e.limitMode != nil {
+			e.limitMode.started = false
+		}
+	})
 }

vendor/github.com/go-co-op/gocron/v2/job.go

@@ -6,25 +6,32 @@ import (
 	"errors"
 	"fmt"
 	"math/rand"
+	"slices"
 	"strings"
 	"time"
 
 	"github.com/google/uuid"
 	"github.com/jonboulle/clockwork"
 	"github.com/robfig/cron/v3"
-	"golang.org/x/exp/slices"
 )
 
 // internalJob stores the information needed by the scheduler
 // to manage scheduling, starting and stopping the job
 type internalJob struct {
-	ctx    context.Context
-	cancel context.CancelFunc
-	id     uuid.UUID
-	name   string
-	tags   []string
+	ctx       context.Context
+	parentCtx context.Context
+	cancel    context.CancelFunc
+	id        uuid.UUID
+	name      string
+	tags      []string
+	cron      Cron
 	jobSchedule
-	lastRun, nextRun   time.Time
+
+	// as some jobs may queue up, it's possible to
+	// have multiple nextScheduled times
+	nextScheduled []time.Time
+
+	lastRun            time.Time
 	function           any
 	parameters         []any
 	timer              clockwork.Timer
@@ -33,10 +40,17 @@ type internalJob struct {
 	limitRunsTo        *limitRunsTo
 	startTime          time.Time
 	startImmediately   bool
+	stopTime           time.Time
 	// event listeners
-	afterJobRuns          func(jobID uuid.UUID, jobName string)
-	beforeJobRuns         func(jobID uuid.UUID, jobName string)
-	afterJobRunsWithError func(jobID uuid.UUID, jobName string, err error)
+	afterJobRuns                        func(jobID uuid.UUID, jobName string)
+	beforeJobRuns                       func(jobID uuid.UUID, jobName string)
+	beforeJobRunsSkipIfBeforeFuncErrors func(jobID uuid.UUID, jobName string) error
+	afterJobRunsWithError               func(jobID uuid.UUID, jobName string, err error)
+	afterJobRunsWithPanic               func(jobID uuid.UUID, jobName string, recoverData any)
+	afterLockError                      func(jobID uuid.UUID, jobName string, err error)
+	disabledLocker                      bool
+
+	locker Locker
 }
 
 // stop is used to stop the job's timer and cancel the context
@@ -51,6 +65,13 @@ func (j *internalJob) stop() {
 	j.cancel()
 }
 
+func (j *internalJob) stopTimeReached(now time.Time) bool {
+	if j.stopTime.IsZero() {
+		return false
+	}
+	return j.stopTime.Before(now)
+}
+
 // task stores the function and parameters
 // that are actually run when the job is executed.
 type task struct {
@@ -63,6 +84,10 @@ type task struct {
 type Task func() task
 
 // NewTask provides the job's task function and parameters.
+// If you set the first argument of your Task func to be a context.Context,
+// gocron will pass in a context (either the default Job context, or one
+// provided via WithContext) to the job and will cancel the context on shutdown.
+// This allows you to listen for and handle cancellation within your job.
 func NewTask(function any, parameters ...any) Task {
 	return func() task {
 		return task{
@@ -80,6 +105,20 @@ type limitRunsTo struct {
 	runCount uint
 }
 
+// -----------------------------------------------
+// -----------------------------------------------
+// --------------- Custom Cron -------------------
+// -----------------------------------------------
+// -----------------------------------------------
+
+// Cron defines the interface that must be
+// implemented to provide a custom cron implementation for
+// the job. Pass in the implementation using the JobOption WithCronImplementation.
+type Cron interface {
+	IsValid(crontab string, location *time.Location, now time.Time) error
+	Next(lastRun time.Time) time.Time
+}
+
 // -----------------------------------------------
 // -----------------------------------------------
 // --------------- Job Variants ------------------
@@ -89,24 +128,32 @@ type limitRunsTo struct {
 // JobDefinition defines the interface that must be
 // implemented to create a job from the definition.
 type JobDefinition interface {
-	setup(*internalJob, *time.Location) error
+	setup(j *internalJob, l *time.Location, now time.Time) error
 }
 
-var _ JobDefinition = (*cronJobDefinition)(nil)
+// Default cron implementation
 
-type cronJobDefinition struct {
-	crontab     string
-	withSeconds bool
+func newDefaultCronImplementation(withSeconds bool) Cron {
+	return &defaultCron{
+		withSeconds: withSeconds,
+	}
 }
 
-func (c cronJobDefinition) setup(j *internalJob, location *time.Location) error {
+var _ Cron = (*defaultCron)(nil)
+
+type defaultCron struct {
+	cronSchedule cron.Schedule
+	withSeconds  bool
+}
+
+func (c *defaultCron) IsValid(crontab string, location *time.Location, now time.Time) error {
 	var withLocation string
-	if strings.HasPrefix(c.crontab, "TZ=") || strings.HasPrefix(c.crontab, "CRON_TZ=") {
-		withLocation = c.crontab
+	if strings.HasPrefix(crontab, "TZ=") || strings.HasPrefix(crontab, "CRON_TZ=") {
+		withLocation = crontab
 	} else {
 		// since the user didn't provide a timezone default to the location
 		// passed in by the scheduler. Default: time.Local
-		withLocation = fmt.Sprintf("CRON_TZ=%s %s", location.String(), c.crontab)
+		withLocation = fmt.Sprintf("CRON_TZ=%s %s", location.String(), crontab)
 	}
 
 	var (
@@ -115,7 +162,7 @@ func (c cronJobDefinition) setup(j *internalJob, location *time.Location) error
 	)
 
 	if c.withSeconds {
-		p := cron.NewParser(cron.Second | cron.Minute | cron.Hour | cron.Dom | cron.Month | cron.Dow | cron.Descriptor)
+		p := cron.NewParser(cron.SecondOptional | cron.Minute | cron.Hour | cron.Dom | cron.Month | cron.Dow | cron.Descriptor)
 		cronSchedule, err = p.Parse(withLocation)
 	} else {
 		cronSchedule, err = cron.ParseStandard(withLocation)
@@ -123,8 +170,35 @@ func (c cronJobDefinition) setup(j *internalJob, location *time.Location) error
 	if err != nil {
 		return errors.Join(ErrCronJobParse, err)
 	}
+	if cronSchedule.Next(now).IsZero() {
+		return ErrCronJobInvalid
+	}
+	c.cronSchedule = cronSchedule
+	return nil
+}
 
-	j.jobSchedule = &cronJob{cronSchedule: cronSchedule}
+func (c *defaultCron) Next(lastRun time.Time) time.Time {
+	return c.cronSchedule.Next(lastRun)
+}
+
+// default cron job implementation
+var _ JobDefinition = (*cronJobDefinition)(nil)
+
+type cronJobDefinition struct {
+	crontab string
+	cron    Cron
+}
+
+func (c cronJobDefinition) setup(j *internalJob, location *time.Location, now time.Time) error {
+	if j.cron != nil {
+		c.cron = j.cron
+	}
+
+	if err := c.cron.IsValid(c.crontab, location, now); err != nil {
+		return err
+	}
+
+	j.jobSchedule = &cronJob{crontab: c.crontab, cronSchedule: c.cron}
 	return nil
 }
 
@@ -136,8 +210,8 @@ func (c cronJobDefinition) setup(j *internalJob, location *time.Location) error
 // `CRON_TZ=America/Chicago * * * * *`
 func CronJob(crontab string, withSeconds bool) JobDefinition {
 	return cronJobDefinition{
-		crontab:     crontab,
-		withSeconds: withSeconds,
+		crontab: crontab,
+		cron:    newDefaultCronImplementation(withSeconds),
 	}
 }
 
@@ -147,7 +221,10 @@ type durationJobDefinition struct {
 	duration time.Duration
 }
 
-func (d durationJobDefinition) setup(j *internalJob, _ *time.Location) error {
+func (d durationJobDefinition) setup(j *internalJob, _ *time.Location, _ time.Time) error {
+	if d.duration == 0 {
+		return ErrDurationJobIntervalZero
+	}
 	j.jobSchedule = &durationJob{duration: d.duration}
 	return nil
 }
@@ -166,7 +243,7 @@ type durationRandomJobDefinition struct {
 	min, max time.Duration
 }
 
-func (d durationRandomJobDefinition) setup(j *internalJob, _ *time.Location) error {
+func (d durationRandomJobDefinition) setup(j *internalJob, _ *time.Location, _ time.Time) error {
 	if d.min >= d.max {
 		return ErrDurationRandomJobMinMax
 	}
@@ -216,7 +293,7 @@ type dailyJobDefinition struct {
 	atTimes  AtTimes
 }
 
-func (d dailyJobDefinition) setup(j *internalJob, location *time.Location) error {
+func (d dailyJobDefinition) setup(j *internalJob, location *time.Location, _ time.Time) error {
 	atTimesDate, err := convertAtTimesToDateTime(d.atTimes, location)
 	switch {
 	case errors.Is(err, errAtTimesNil):
@@ -229,6 +306,10 @@ func (d dailyJobDefinition) setup(j *internalJob, location *time.Location) error
 		return ErrDailyJobMinutesSeconds
 	}
 
+	if d.interval == 0 {
+		return ErrDailyJobZeroInterval
+	}
+
 	ds := dailyJob{
 		interval: d.interval,
 		atTimes:  atTimesDate,
@@ -245,8 +326,11 @@ type weeklyJobDefinition struct {
 	atTimes       AtTimes
 }
 
-func (w weeklyJobDefinition) setup(j *internalJob, location *time.Location) error {
+func (w weeklyJobDefinition) setup(j *internalJob, location *time.Location, _ time.Time) error {
 	var ws weeklyJob
+	if w.interval == 0 {
+		return ErrWeeklyJobZeroInterval
+	}
 	ws.interval = w.interval
 
 	if w.daysOfTheWeek == nil {
@@ -281,7 +365,7 @@ type Weekdays func() []time.Weekday
 // NewWeekdays provide the days of the week the job should run.
 func NewWeekdays(weekday time.Weekday, weekdays ...time.Weekday) Weekdays {
 	return func() []time.Weekday {
-		return append(weekdays, weekday)
+		return append([]time.Weekday{weekday}, weekdays...)
 	}
 }
 
@@ -309,8 +393,11 @@ type monthlyJobDefinition struct {
 	atTimes        AtTimes
 }
 
-func (m monthlyJobDefinition) setup(j *internalJob, location *time.Location) error {
+func (m monthlyJobDefinition) setup(j *internalJob, location *time.Location, _ time.Time) error {
 	var ms monthlyJob
+	if m.interval == 0 {
+		return ErrMonthlyJobZeroInterval
+	}
 	ms.interval = m.interval
 
 	if m.daysOfTheMonth == nil {
@@ -329,11 +416,9 @@ func (m monthlyJobDefinition) setup(j *internalJob, location *time.Location) err
 		}
 	}
 	daysStart = removeSliceDuplicatesInt(daysStart)
-	slices.Sort(daysStart)
 	ms.days = daysStart
 
 	daysEnd = removeSliceDuplicatesInt(daysEnd)
-	slices.Sort(daysEnd)
 	ms.daysFromEnd = daysEnd
 
 	atTimesDate, err := convertAtTimesToDateTime(m.atTimes, location)
@@ -366,8 +451,7 @@ type DaysOfTheMonth func() days
 //	-5 == 5 days before the end of the month.
 func NewDaysOfTheMonth(day int, moreDays ...int) DaysOfTheMonth {
 	return func() days {
-		moreDays = append(moreDays, day)
-		return moreDays
+		return append([]int{day}, moreDays...)
 	}
 }
 
@@ -379,6 +463,14 @@ func (a atTime) time(location *time.Location) time.Time {
 	return time.Date(0, 0, 0, int(a.hours), int(a.minutes), int(a.seconds), 0, location)
 }
 
+// TimeFromAtTime is a helper function to allow converting AtTime into a time.Time value
+// Note: the time.Time value will have zero values for all Time fields except Hours, Minutes, Seconds.
+//
+//	For example: time.Date(0, 0, 0, 1, 1, 1, 0, time.UTC)
+func TimeFromAtTime(at AtTime, loc *time.Location) time.Time {
+	return at().time(loc)
+}
+
 // AtTime defines a function that returns the internal atTime
 type AtTime func() atTime
 
@@ -397,8 +489,7 @@ type AtTimes func() []AtTime
 // the job should be run
 func NewAtTimes(atTime AtTime, atTimes ...AtTime) AtTimes {
 	return func() []AtTime {
-		atTimes = append(atTimes, atTime)
-		return atTimes
+		return append([]AtTime{atTime}, atTimes...)
 	}
 }
 
@@ -432,31 +523,58 @@ type oneTimeJobDefinition struct {
 	startAt OneTimeJobStartAtOption
 }
 
-func (o oneTimeJobDefinition) setup(j *internalJob, _ *time.Location) error {
-	j.jobSchedule = oneTimeJob{}
-	return o.startAt(j)
+func (o oneTimeJobDefinition) setup(j *internalJob, _ *time.Location, now time.Time) error {
+	sortedTimes := o.startAt(j)
+	slices.SortStableFunc(sortedTimes, ascendingTime)
+	// deduplicate the times
+	sortedTimes = removeSliceDuplicatesTimeOnSortedSlice(sortedTimes)
+	// keep only schedules that are in the future
+	idx, found := slices.BinarySearchFunc(sortedTimes, now, ascendingTime)
+	if found {
+		idx++
+	}
+	sortedTimes = sortedTimes[idx:]
+	if !j.startImmediately && len(sortedTimes) == 0 {
+		return ErrOneTimeJobStartDateTimePast
+	}
+	j.jobSchedule = oneTimeJob{sortedTimes: sortedTimes}
+	return nil
+}
+
+func removeSliceDuplicatesTimeOnSortedSlice(times []time.Time) []time.Time {
+	ret := make([]time.Time, 0, len(times))
+	for i, t := range times {
+		if i == 0 || t != times[i-1] {
+			ret = append(ret, t)
+		}
+	}
+	return ret
 }
 
 // OneTimeJobStartAtOption defines when the one time job is run
-type OneTimeJobStartAtOption func(*internalJob) error
+type OneTimeJobStartAtOption func(*internalJob) []time.Time
 
 // OneTimeJobStartImmediately tells the scheduler to run the one time job immediately.
 func OneTimeJobStartImmediately() OneTimeJobStartAtOption {
-	return func(j *internalJob) error {
+	return func(j *internalJob) []time.Time {
 		j.startImmediately = true
-		return nil
+		return []time.Time{}
 	}
 }
 
 // OneTimeJobStartDateTime sets the date & time at which the job should run.
-// This datetime must be in the future.
+// This datetime must be in the future (according to the scheduler clock).
 func OneTimeJobStartDateTime(start time.Time) OneTimeJobStartAtOption {
-	return func(j *internalJob) error {
-		if start.IsZero() || start.Before(time.Now()) {
-			return ErrOneTimeJobStartDateTimePast
-		}
-		j.startTime = start
-		return nil
+	return func(_ *internalJob) []time.Time {
+		return []time.Time{start}
+	}
+}
+
+// OneTimeJobStartDateTimes sets the date & times at which the job should run.
+// At least one of the date/times must be in the future (according to the scheduler clock).
+func OneTimeJobStartDateTimes(times ...time.Time) OneTimeJobStartAtOption {
+	return func(_ *internalJob) []time.Time {
+		return times
 	}
 }
 
@@ -475,12 +593,35 @@ func OneTimeJob(startAt OneTimeJobStartAtOption) JobDefinition {
 // -----------------------------------------------
 
 // JobOption defines the constructor for job options.
-type JobOption func(*internalJob) error
+type JobOption func(*internalJob, time.Time) error
+
+// WithDistributedJobLocker sets the locker to be used by multiple
+// Scheduler instances to ensure that only one instance of each
+// job is run.
+func WithDistributedJobLocker(locker Locker) JobOption {
+	return func(j *internalJob, _ time.Time) error {
+		if locker == nil {
+			return ErrWithDistributedJobLockerNil
+		}
+		j.locker = locker
+		return nil
+	}
+}
+
+// WithDisabledDistributedJobLocker disables the distributed job locker.
+// This is useful when a global distributed locker has been set on the scheduler
+// level using WithDistributedLocker and need to be disabled for specific jobs.
+func WithDisabledDistributedJobLocker(disabled bool) JobOption {
+	return func(j *internalJob, _ time.Time) error {
+		j.disabledLocker = disabled
+		return nil
+	}
+}
 
 // WithEventListeners sets the event listeners that should be
 // run for the job.
 func WithEventListeners(eventListeners ...EventListener) JobOption {
-	return func(j *internalJob) error {
+	return func(j *internalJob, _ time.Time) error {
 		for _, eventListener := range eventListeners {
 			if err := eventListener(j); err != nil {
 				return err
@@ -493,7 +634,7 @@ func WithEventListeners(eventListeners ...EventListener) JobOption {
 // WithLimitedRuns limits the number of executions of this job to n.
 // Upon reaching the limit, the job is removed from the scheduler.
 func WithLimitedRuns(limit uint) JobOption {
-	return func(j *internalJob) error {
+	return func(j *internalJob, _ time.Time) error {
 		j.limitRunsTo = &limitRunsTo{
 			limit:    limit,
 			runCount: 0,
@@ -505,8 +646,7 @@ func WithLimitedRuns(limit uint) JobOption {
 // WithName sets the name of the job. Name provides
 // a human-readable identifier for the job.
 func WithName(name string) JobOption {
-	// TODO use the name for metrics and future logging option
-	return func(j *internalJob) error {
+	return func(j *internalJob, _ time.Time) error {
 		if name == "" {
 			return ErrWithNameEmpty
 		}
@@ -515,11 +655,20 @@ func WithName(name string) JobOption {
 	}
 }
 
+// WithCronImplementation sets the custom Cron implementation for the job.
+// This is only utilized for the CronJob type.
+func WithCronImplementation(c Cron) JobOption {
+	return func(j *internalJob, _ time.Time) error {
+		j.cron = c
+		return nil
+	}
+}
+
 // WithSingletonMode keeps the job from running again if it is already running.
 // This is useful for jobs that should not overlap, and that occasionally
 // (but not consistently) run longer than the interval between job runs.
 func WithSingletonMode(mode LimitMode) JobOption {
-	return func(j *internalJob) error {
+	return func(j *internalJob, _ time.Time) error {
 		j.singletonMode = true
 		j.singletonLimitMode = mode
 		return nil
@@ -529,19 +678,19 @@ func WithSingletonMode(mode LimitMode) JobOption {
 // WithStartAt sets the option for starting the job at
 // a specific datetime.
 func WithStartAt(option StartAtOption) JobOption {
-	return func(j *internalJob) error {
-		return option(j)
+	return func(j *internalJob, now time.Time) error {
+		return option(j, now)
 	}
 }
 
 // StartAtOption defines options for starting the job
-type StartAtOption func(*internalJob) error
+type StartAtOption func(*internalJob, time.Time) error
 
 // WithStartImmediately tells the scheduler to run the job immediately
 // regardless of the type or schedule of job. After this immediate run
 // the job is scheduled from this time based on the job definition.
 func WithStartImmediately() StartAtOption {
-	return func(j *internalJob) error {
+	return func(j *internalJob, _ time.Time) error {
 		j.startImmediately = true
 		return nil
 	}
@@ -550,25 +699,85 @@ func WithStartImmediately() StartAtOption {
 // WithStartDateTime sets the first date & time at which the job should run.
 // This datetime must be in the future.
 func WithStartDateTime(start time.Time) StartAtOption {
-	return func(j *internalJob) error {
-		if start.IsZero() || start.Before(time.Now()) {
+	return func(j *internalJob, now time.Time) error {
+		if start.IsZero() || start.Before(now) {
 			return ErrWithStartDateTimePast
 		}
+		if !j.stopTime.IsZero() && j.stopTime.Before(start) {
+			return ErrStartTimeLaterThanEndTime
+		}
 		j.startTime = start
 		return nil
 	}
 }
 
+// WithStopAt sets the option for stopping the job from running
+// after the specified time.
+func WithStopAt(option StopAtOption) JobOption {
+	return func(j *internalJob, now time.Time) error {
+		return option(j, now)
+	}
+}
+
+// StopAtOption defines options for stopping the job
+type StopAtOption func(*internalJob, time.Time) error
+
+// WithStopDateTime sets the final date & time after which the job should stop.
+// This must be in the future and should be after the startTime (if specified).
+// The job's final run may be at the stop time, but not after.
+func WithStopDateTime(end time.Time) StopAtOption {
+	return func(j *internalJob, now time.Time) error {
+		if end.IsZero() || end.Before(now) {
+			return ErrWithStopDateTimePast
+		}
+		if end.Before(j.startTime) {
+			return ErrStopTimeEarlierThanStartTime
+		}
+		j.stopTime = end
+		return nil
+	}
+}
+
 // WithTags sets the tags for the job. Tags provide
 // a way to identify jobs by a set of tags and remove
 // multiple jobs by tag.
 func WithTags(tags ...string) JobOption {
-	return func(j *internalJob) error {
+	return func(j *internalJob, _ time.Time) error {
 		j.tags = tags
 		return nil
 	}
 }
 
+// WithIdentifier sets the identifier for the job. The identifier
+// is used to uniquely identify the job and is used for logging
+// and metrics.
+func WithIdentifier(id uuid.UUID) JobOption {
+	return func(j *internalJob, _ time.Time) error {
+		if id == uuid.Nil {
+			return ErrWithIdentifierNil
+		}
+
+		j.id = id
+		return nil
+	}
+}
+
+// WithContext sets the parent context for the job.
+// If you set the first argument of your Task func to be a context.Context,
+// gocron will pass in the provided context to the job and will cancel the
+// context on shutdown. If you cancel the context the job will no longer be
+// scheduled as well. This allows you to both control the job via a context
+// and listen for and handle cancellation within your job.
+func WithContext(ctx context.Context) JobOption {
+	return func(j *internalJob, _ time.Time) error {
+		if ctx == nil {
+			return ErrWithContextNil
+		}
+		j.parentCtx = ctx
+		return nil
+	}
+}
+
 // -----------------------------------------------
 // -----------------------------------------------
 // ------------- Job Event Listeners -------------
@@ -579,8 +788,33 @@ func WithTags(tags ...string) JobOption {
 // listeners that can be used to listen for job events.
 type EventListener func(*internalJob) error
 
-// AfterJobRuns is used to listen for when a job has run regardless
-// of any returned error value, and run the provided function.
+// BeforeJobRuns is used to listen for when a job is about to run and
+// then run the provided function.
+func BeforeJobRuns(eventListenerFunc func(jobID uuid.UUID, jobName string)) EventListener {
+	return func(j *internalJob) error {
+		if eventListenerFunc == nil {
+			return ErrEventListenerFuncNil
+		}
+		j.beforeJobRuns = eventListenerFunc
+		return nil
+	}
+}
+
+// BeforeJobRunsSkipIfBeforeFuncErrors is used to listen for when a job is about to run and
+// then runs the provided function. If the provided function returns an error, the job will be
+// rescheduled and the current run will be skipped.
+func BeforeJobRunsSkipIfBeforeFuncErrors(eventListenerFunc func(jobID uuid.UUID, jobName string) error) EventListener {
+	return func(j *internalJob) error {
+		if eventListenerFunc == nil {
+			return ErrEventListenerFuncNil
+		}
+		j.beforeJobRunsSkipIfBeforeFuncErrors = eventListenerFunc
+		return nil
+	}
+}
+
+// AfterJobRuns is used to listen for when a job has run
+// without an error, and then run the provided function.
 func AfterJobRuns(eventListenerFunc func(jobID uuid.UUID, jobName string)) EventListener {
 	return func(j *internalJob) error {
 		if eventListenerFunc == nil {
@@ -603,14 +837,26 @@ func AfterJobRunsWithError(eventListenerFunc func(jobID uuid.UUID, jobName strin
 	}
 }
 
-// BeforeJobRuns is used to listen for when a job is about to run and
-// then run the provided function.
-func BeforeJobRuns(eventListenerFunc func(jobID uuid.UUID, jobName string)) EventListener {
+// AfterJobRunsWithPanic is used to listen for when a job has run and
+// returned panicked recover data, and then run the provided function.
+func AfterJobRunsWithPanic(eventListenerFunc func(jobID uuid.UUID, jobName string, recoverData any)) EventListener {
 	return func(j *internalJob) error {
 		if eventListenerFunc == nil {
 			return ErrEventListenerFuncNil
 		}
-		j.beforeJobRuns = eventListenerFunc
+		j.afterJobRunsWithPanic = eventListenerFunc
+		return nil
+	}
+}
+
+// AfterLockError is used to when the distributed locker returns an error and
+// then run the provided function.
+func AfterLockError(eventListenerFunc func(jobID uuid.UUID, jobName string, err error)) EventListener {
+	return func(j *internalJob) error {
+		if eventListenerFunc == nil {
+			return ErrEventListenerFuncNil
+		}
+		j.afterLockError = eventListenerFunc
 		return nil
 	}
 }
@@ -628,7 +874,8 @@ type jobSchedule interface {
 var _ jobSchedule = (*cronJob)(nil)
 
 type cronJob struct {
-	cronSchedule cron.Schedule
+	crontab      string
+	cronSchedule Cron
 }
 
 func (j *cronJob) next(lastRun time.Time) time.Time {
@@ -672,24 +919,24 @@ func (d dailyJob) next(lastRun time.Time) time.Time {
 	}
 	firstPass = false
 
-	startNextDay := time.Date(lastRun.Year(), lastRun.Month(), lastRun.Day()+int(d.interval), 0, 0, 0, lastRun.Nanosecond(), lastRun.Location())
+	startNextDay := time.Date(lastRun.Year(), lastRun.Month(), lastRun.Day()+int(d.interval), 0, 0, 0, 0, lastRun.Location())
 	return d.nextDay(startNextDay, firstPass)
 }
 
 func (d dailyJob) nextDay(lastRun time.Time, firstPass bool) time.Time {
 	for _, at := range d.atTimes {
-		// sub the at time hour/min/sec onto the lastRun's values
+		// sub the at time hour/min/sec onto the lastScheduledRun's values
 		// to use in checks to see if we've got our next run time
-		atDate := time.Date(lastRun.Year(), lastRun.Month(), lastRun.Day(), at.Hour(), at.Minute(), at.Second(), lastRun.Nanosecond(), lastRun.Location())
+		atDate := time.Date(lastRun.Year(), lastRun.Month(), lastRun.Day(), at.Hour(), at.Minute(), at.Second(), 0, lastRun.Location())
 
 		if firstPass && atDate.After(lastRun) {
 			// checking to see if it is after i.e. greater than,
-			// and not greater or equal as our lastRun day/time
+			// and not greater or equal as our lastScheduledRun day/time
 			// will be in the loop, and we don't want to select it again
 			return atDate
 		} else if !firstPass && !atDate.Before(lastRun) {
 			// now that we're looking at the next day, it's ok to consider
-			// the same at time that was last run (as lastRun has been incremented)
+			// the same at time that was last run (as lastScheduledRun has been incremented)
 			return atDate
 		}
 	}
@@ -724,18 +971,18 @@ func (w weeklyJob) nextWeekDayAtTime(lastRun time.Time, firstPass bool) time.Tim
 			// weekDayDiff is used to add the correct amount to the atDate day below
 			weekDayDiff := wd - lastRun.Weekday()
 			for _, at := range w.atTimes {
-				// sub the at time hour/min/sec onto the lastRun's values
+				// sub the at time hour/min/sec onto the lastScheduledRun's values
 				// to use in checks to see if we've got our next run time
-				atDate := time.Date(lastRun.Year(), lastRun.Month(), lastRun.Day()+int(weekDayDiff), at.Hour(), at.Minute(), at.Second(), lastRun.Nanosecond(), lastRun.Location())
+				atDate := time.Date(lastRun.Year(), lastRun.Month(), lastRun.Day()+int(weekDayDiff), at.Hour(), at.Minute(), at.Second(), 0, lastRun.Location())
 
 				if firstPass && atDate.After(lastRun) {
 					// checking to see if it is after i.e. greater than,
-					// and not greater or equal as our lastRun day/time
+					// and not greater or equal as our lastScheduledRun day/time
 					// will be in the loop, and we don't want to select it again
 					return atDate
 				} else if !firstPass && !atDate.Before(lastRun) {
 					// now that we're looking at the next week, it's ok to consider
-					// the same at time that was last run (as lastRun has been incremented)
+					// the same at time that was last run (as lastScheduledRun has been incremented)
 					return atDate
 				}
 			}
@@ -756,40 +1003,45 @@ type monthlyJob struct {
 func (m monthlyJob) next(lastRun time.Time) time.Time {
 	daysList := make([]int, len(m.days))
 	copy(daysList, m.days)
-	firstDayNextMonth := time.Date(lastRun.Year(), lastRun.Month()+1, 1, 0, 0, 0, 0, lastRun.Location())
-	for _, daySub := range m.daysFromEnd {
-		// getting a combined list of all the daysList and the negative daysList
-		// which count backwards from the first day of the next month
-		// -1 == the last day of the month
-		day := firstDayNextMonth.AddDate(0, 0, daySub).Day()
-		daysList = append(daysList, day)
-	}
-	slices.Sort(daysList)
 
-	firstPass := true
-	next := m.nextMonthDayAtTime(lastRun, daysList, firstPass)
+	daysFromEnd := m.handleNegativeDays(lastRun, daysList, m.daysFromEnd)
+	next := m.nextMonthDayAtTime(lastRun, daysFromEnd, true)
 	if !next.IsZero() {
 		return next
 	}
-	firstPass = false
 
 	from := time.Date(lastRun.Year(), lastRun.Month()+time.Month(m.interval), 1, 0, 0, 0, 0, lastRun.Location())
 	for next.IsZero() {
-		next = m.nextMonthDayAtTime(from, daysList, firstPass)
+		daysFromEnd = m.handleNegativeDays(from, daysList, m.daysFromEnd)
+		next = m.nextMonthDayAtTime(from, daysFromEnd, false)
 		from = from.AddDate(0, int(m.interval), 0)
 	}
 
 	return next
 }
 
+func (m monthlyJob) handleNegativeDays(from time.Time, days, negativeDays []int) []int {
+	var out []int
+	// getting a list of the days from the end of the following month
+	// -1 == the last day of the month
+	firstDayNextMonth := time.Date(from.Year(), from.Month()+1, 1, 0, 0, 0, 0, from.Location())
+	for _, daySub := range negativeDays {
+		day := firstDayNextMonth.AddDate(0, 0, daySub).Day()
+		out = append(out, day)
+	}
+	out = append(out, days...)
+	slices.Sort(out)
+	return out
+}
+
 func (m monthlyJob) nextMonthDayAtTime(lastRun time.Time, days []int, firstPass bool) time.Time {
 	// find the next day in the month that should run and then check for an at time
 	for _, day := range days {
 		if day >= lastRun.Day() {
 			for _, at := range m.atTimes {
-				// sub the day, and the at time hour/min/sec onto the lastRun's values
+				// sub the day, and the at time hour/min/sec onto the lastScheduledRun's values
 				// to use in checks to see if we've got our next run time
-				atDate := time.Date(lastRun.Year(), lastRun.Month(), day, at.Hour(), at.Minute(), at.Second(), lastRun.Nanosecond(), lastRun.Location())
+				atDate := time.Date(lastRun.Year(), lastRun.Month(), day, at.Hour(), at.Minute(), at.Second(), 0, lastRun.Location())
 
 				if atDate.Month() != lastRun.Month() {
 					// this check handles if we're setting a day not in the current month
@@ -799,12 +1051,12 @@ func (m monthlyJob) nextMonthDayAtTime(lastRun time.Time, days []int, firstPass
 
 				if firstPass && atDate.After(lastRun) {
 					// checking to see if it is after i.e. greater than,
-					// and not greater or equal as our lastRun day/time
+					// and not greater or equal as our lastScheduledRun day/time
 					// will be in the loop, and we don't want to select it again
 					return atDate
 				} else if !firstPass && !atDate.Before(lastRun) {
 					// now that we're looking at the next month, it's ok to consider
-					// the same at time that was  lastRun (as lastRun has been incremented)
+					// the same at time that was  lastScheduledRun (as lastScheduledRun has been incremented)
 					return atDate
 				}
 			}
@@ -816,10 +1068,33 @@ func (m monthlyJob) nextMonthDayAtTime(lastRun time.Time, days []int, firstPass
 
 var _ jobSchedule = (*oneTimeJob)(nil)
 
-type oneTimeJob struct{}
+type oneTimeJob struct {
+	sortedTimes []time.Time
+}
 
-func (o oneTimeJob) next(_ time.Time) time.Time {
-	return time.Time{}
+// next finds the next item in a sorted list of times using binary-search.
+//
+// example: sortedTimes: [2, 4, 6, 8]
+//
+// lastRun: 1 => [idx=0,found=false] => next is 2 - sorted[idx] idx=0
+// lastRun: 2 => [idx=0,found=true] => next is 4 - sorted[idx+1] idx=1
+// lastRun: 3 => [idx=1,found=false] => next is 4 - sorted[idx] idx=1
+// lastRun: 4 => [idx=1,found=true] => next is 6 - sorted[idx+1] idx=2
+// lastRun: 7 => [idx=3,found=false] => next is 8 - sorted[idx] idx=3
+// lastRun: 8 => [idx=3,found=found] => next is none
+// lastRun: 9 => [idx=3,found=found] => next is none
+func (o oneTimeJob) next(lastRun time.Time) time.Time {
+	idx, found := slices.BinarySearchFunc(o.sortedTimes, lastRun, ascendingTime)
+	// if found, the next run is the following index
+	if found {
+		idx++
+	}
+	// exhausted runs
+	if idx >= len(o.sortedTimes) {
+		return time.Time{}
+	}
+
+	return o.sortedTimes[idx]
 }
 
 // -----------------------------------------------
@@ -839,9 +1114,13 @@ type Job interface {
 	Name() string
 	// NextRun returns the time of the job's next scheduled run.
 	NextRun() (time.Time, error)
+	// NextRuns returns the requested number of calculated next run values.
+	NextRuns(int) ([]time.Time, error)
 	// RunNow runs the job once, now. This does not alter
 	// the existing run schedule, and will respect all job
-	// and scheduler limits.
+	// and scheduler limits. This means that running a job now may
+	// cause the job's regular interval to be rescheduled due to
+	// the instance being run by RunNow blocking your run limit.
 	RunNow() error
 	// Tags returns the job's string tags.
 	Tags() []string
@@ -882,7 +1161,39 @@ func (j job) NextRun() (time.Time, error) {
 	if ij == nil || ij.id == uuid.Nil {
 		return time.Time{}, ErrJobNotFound
 	}
-	return ij.nextRun, nil
+	if len(ij.nextScheduled) == 0 {
+		return time.Time{}, nil
+	}
+	// the first element is the next scheduled run with subsequent
+	// runs following after in the slice
+	return ij.nextScheduled[0], nil
+}
+
+func (j job) NextRuns(count int) ([]time.Time, error) {
+	ij := requestJob(j.id, j.jobOutRequest)
+	if ij == nil || ij.id == uuid.Nil {
+		return nil, ErrJobNotFound
+	}
+
+	lengthNextScheduled := len(ij.nextScheduled)
+	if lengthNextScheduled == 0 {
+		return nil, nil
+	} else if count <= lengthNextScheduled {
+		return ij.nextScheduled[:count], nil
+	}
+
+	out := make([]time.Time, count)
+	for i := 0; i < count; i++ {
+		if i < lengthNextScheduled {
+			out[i] = ij.nextScheduled[i]
+			continue
+		}
+
+		from := out[i-1]
+		out[i] = ij.next(from)
+	}
+
+	return out, nil
 }
 
 func (j job) Tags() []string {
@@ -894,12 +1205,14 @@ func (j job) RunNow() error {
 	defer cancel()
 	resp := make(chan error, 1)
 
+	t := time.NewTimer(100 * time.Millisecond)
 	select {
 	case j.runJobRequest <- runJobRequest{
 		id:      j.id,
 		outChan: resp,
 	}:
-	case <-time.After(100 * time.Millisecond):
+		t.Stop()
+	case <-t.C:
 		return ErrJobRunNowFailed
 	}
 	var err error

vendor/github.com/go-co-op/gocron/v2/monitor.go

@@ -0,0 +1,36 @@
+package gocron
+
+import (
+	"time"
+
+	"github.com/google/uuid"
+)
+
+// JobStatus is the status of job run that should be collected with the metric.
+type JobStatus string
+
+// The different statuses of job that can be used.
+const (
+	Fail                 JobStatus = "fail"
+	Success              JobStatus = "success"
+	Skip                 JobStatus = "skip"
+	SingletonRescheduled JobStatus = "singleton_rescheduled"
+)
+
+// Monitor represents the interface to collect jobs metrics.
+type Monitor interface {
+	// IncrementJob will provide details about the job and expects the underlying implementation
+	// to handle instantiating and incrementing a value
+	IncrementJob(id uuid.UUID, name string, tags []string, status JobStatus)
+	// RecordJobTiming will provide details about the job and the timing and expects the underlying implementation
+	// to handle instantiating and recording the value
+	RecordJobTiming(startTime, endTime time.Time, id uuid.UUID, name string, tags []string)
+}
+
+// MonitorStatus extends RecordJobTiming with the job status.
+type MonitorStatus interface {
+	Monitor
+	// RecordJobTimingWithStatus will provide details about the job, its status, error and the timing and expects the underlying implementation
+	// to handle instantiating and recording the value
+	RecordJobTimingWithStatus(startTime, endTime time.Time, id uuid.UUID, name string, tags []string, status JobStatus, err error)
+}

vendor/github.com/go-co-op/gocron/v2/scheduler.go

@@ -5,11 +5,12 @@ import (
 	"context"
 	"reflect"
 	"runtime"
+	"slices"
+	"strings"
 	"time"
 
 	"github.com/google/uuid"
 	"github.com/jonboulle/clockwork"
-	"golang.org/x/exp/slices"
 )
 
 var _ Scheduler = (*scheduler)(nil)
@@ -21,6 +22,10 @@ type Scheduler interface {
 	// NewJob creates a new job in the Scheduler. The job is scheduled per the provided
 	// definition when the Scheduler is started. If the Scheduler is already running
 	// the job will be scheduled when the Scheduler is started.
+	// If you set the first argument of your Task func to be a context.Context,
+	// gocron will pass in a context (either the default Job context, or one
+	// provided via WithContext) to the job and will cancel the context on shutdown.
+	// This allows you to listen for and handle cancellation within your job.
 	NewJob(JobDefinition, Task, ...JobOption) (Job, error)
 	// RemoveByTags removes all jobs that have at least one of the provided tags.
 	RemoveByTags(...string)
@@ -44,6 +49,9 @@ type Scheduler interface {
 	// Update replaces the existing Job's JobDefinition with the provided
 	// JobDefinition. The Job's Job.ID() remains the same.
 	Update(uuid.UUID, JobDefinition, Task, ...JobOption) (Job, error)
+	// JobsWaitingInQueue number of jobs waiting in Queue in case of LimitModeWait
+	// In case of LimitModeReschedule or no limit it will be always zero
+	JobsWaitingInQueue() int
 }
 
 // -----------------------------------------------
@@ -53,28 +61,52 @@ type Scheduler interface {
 // -----------------------------------------------
 
 type scheduler struct {
-	shutdownCtx      context.Context
-	shutdownCancel   context.CancelFunc
-	exec             executor
-	jobs             map[uuid.UUID]internalJob
-	location         *time.Location
-	clock            clockwork.Clock
-	started          bool
+	// context used for shutting down
+	shutdownCtx context.Context
+	// cancel used to signal scheduler should shut down
+	shutdownCancel context.CancelFunc
+	// the executor, which actually runs the jobs sent to it via the scheduler
+	exec executor
+	// the map of jobs registered in the scheduler
+	jobs map[uuid.UUID]internalJob
+	// the location used by the scheduler for scheduling when relevant
+	location *time.Location
+	// whether the scheduler has been started or not
+	started bool
+	// globally applied JobOption's set on all jobs added to the scheduler
+	// note: individually set JobOption's take precedence.
 	globalJobOptions []JobOption
-	logger           Logger
+	// the scheduler's logger
+	logger Logger
 
-	startCh            chan struct{}
-	startedCh          chan struct{}
-	stopCh             chan struct{}
-	stopErrCh          chan error
-	allJobsOutRequest  chan allJobsOutRequest
-	jobOutRequestCh    chan jobOutRequest
-	runJobRequestCh    chan runJobRequest
-	newJobCh           chan internalJob
-	removeJobCh        chan uuid.UUID
+	// used to tell the scheduler to start
+	startCh chan struct{}
+	// used to report that the scheduler has started
+	startedCh chan struct{}
+	// used to tell the scheduler to stop
+	stopCh chan struct{}
+	// used to report that the scheduler has stopped
+	stopErrCh chan error
+	// used to send all the jobs out when a request is made by the client
+	allJobsOutRequest chan allJobsOutRequest
+	// used to send a jobs out when a request is made by the client
+	jobOutRequestCh chan jobOutRequest
+	// used to run a job on-demand when requested by the client
+	runJobRequestCh chan runJobRequest
+	// new jobs are received here
+	newJobCh chan newJobIn
+	// requests from the client to remove jobs by ID are received here
+	removeJobCh chan uuid.UUID
+	// requests from the client to remove jobs by tags are received here
 	removeJobsByTagsCh chan []string
 }
 
+type newJobIn struct {
+	ctx    context.Context
+	cancel context.CancelFunc
+	job    internalJob
+}
+
 type jobOutRequest struct {
 	id      uuid.UUID
 	outChan chan internalJob
@@ -100,13 +132,16 @@ func NewScheduler(options ...SchedulerOption) (Scheduler, error) {
 	exec := executor{
 		stopCh:           make(chan struct{}),
 		stopTimeout:      time.Second * 10,
-		singletonRunners: make(map[uuid.UUID]singletonRunner),
+		singletonRunners: nil,
 		logger:           &noOpLogger{},
+		clock:            clockwork.NewRealClock(),
 
-		jobsIn:        make(chan jobIn),
-		jobIDsOut:     make(chan uuid.UUID),
-		jobOutRequest: make(chan jobOutRequest, 1000),
-		done:          make(chan error),
+		jobsIn:                 make(chan jobIn),
+		jobsOutForRescheduling: make(chan uuid.UUID),
+		jobUpdateNextRuns:      make(chan uuid.UUID),
+		jobsOutCompleted:       make(chan uuid.UUID),
+		jobOutRequest:          make(chan jobOutRequest, 1000),
+		done:                   make(chan error, 1),
 	}
 
 	s := &scheduler{
@@ -115,10 +150,9 @@ func NewScheduler(options ...SchedulerOption) (Scheduler, error) {
 		exec:           exec,
 		jobs:           make(map[uuid.UUID]internalJob),
 		location:       time.Local,
-		clock:          clockwork.NewRealClock(),
 		logger:         &noOpLogger{},
 
-		newJobCh:           make(chan internalJob),
+		newJobCh:           make(chan newJobIn),
 		removeJobCh:        make(chan uuid.UUID),
 		removeJobsByTagsCh: make(chan []string),
 		startCh:            make(chan struct{}),
@@ -141,11 +175,15 @@ func NewScheduler(options ...SchedulerOption) (Scheduler, error) {
 		s.logger.Info("gocron: new scheduler created")
 		for {
 			select {
-			case id := <-s.exec.jobIDsOut:
-				s.selectExecJobIDsOut(id)
+			case id := <-s.exec.jobsOutForRescheduling:
+				s.selectExecJobsOutForRescheduling(id)
+			case id := <-s.exec.jobUpdateNextRuns:
+				s.updateNextScheduled(id)
+			case id := <-s.exec.jobsOutCompleted:
+				s.selectExecJobsOutCompleted(id)
 
-			case j := <-s.newJobCh:
-				s.selectNewJob(j)
+			case in := <-s.newJobCh:
+				s.selectNewJob(in)
 
 			case id := <-s.removeJobCh:
 				s.selectRemoveJob(id)
@@ -202,20 +240,34 @@ func (s *scheduler) stopScheduler() {
 	for _, j := range s.jobs {
 		j.stop()
 	}
-	for id, j := range s.jobs {
+	for _, j := range s.jobs {
 		<-j.ctx.Done()
-
-		j.ctx, j.cancel = context.WithCancel(s.shutdownCtx)
-		s.jobs[id] = j
 	}
 	var err error
 	if s.started {
+		t := time.NewTimer(s.exec.stopTimeout + 1*time.Second)
 		select {
 		case err = <-s.exec.done:
-		case <-time.After(s.exec.stopTimeout + 1*time.Second):
+			t.Stop()
+		case <-t.C:
 			err = ErrStopExecutorTimedOut
 		}
 	}
+	for id, j := range s.jobs {
+		oldCtx := j.ctx
+		if j.parentCtx == nil {
+			j.parentCtx = s.shutdownCtx
+		}
+		j.ctx, j.cancel = context.WithCancel(j.parentCtx)
+
+		// also replace the old context with the new one in the parameters
+		if len(j.parameters) > 0 && j.parameters[0] == oldCtx {
+			j.parameters[0] = j.ctx
+		}
+
+		s.jobs[id] = j
+	}
+
 	s.stopErrCh <- err
 	s.started = false
 	s.logger.Debug("gocron: scheduler stopped")
@@ -230,14 +282,7 @@ func (s *scheduler) selectAllJobsOutRequest(out allJobsOutRequest) {
 	}
 	slices.SortFunc(outJobs, func(a, b Job) int {
 		aID, bID := a.ID().String(), b.ID().String()
-		switch {
-		case aID < bID:
-			return -1
-		case aID > bID:
-			return 1
-		default:
-			return 0
-		}
+		return strings.Compare(aID, bID)
 	})
 	select {
 	case <-s.shutdownCtx.Done():
@@ -280,10 +325,120 @@ func (s *scheduler) selectRemoveJob(id uuid.UUID) {
 }
 
 // Jobs coming back from the executor to the scheduler that
-// need to evaluated for rescheduling.
-func (s *scheduler) selectExecJobIDsOut(id uuid.UUID) {
-	j := s.jobs[id]
-	j.lastRun = j.nextRun
+// need to be evaluated for rescheduling.
+func (s *scheduler) selectExecJobsOutForRescheduling(id uuid.UUID) {
+	select {
+	case <-s.shutdownCtx.Done():
+		return
+	default:
+	}
+	j, ok := s.jobs[id]
+	if !ok {
+		// the job was removed while it was running, and
+		// so we don't need to reschedule it.
+		return
+	}
+
+	if j.stopTimeReached(s.now()) {
+		return
+	}
+
+	var scheduleFrom time.Time
+	if len(j.nextScheduled) > 0 {
+		// always grab the last element in the slice as that is the furthest
+		// out in the future and the time from which we want to calculate
+		// the subsequent next run time.
+		slices.SortStableFunc(j.nextScheduled, ascendingTime)
+		scheduleFrom = j.nextScheduled[len(j.nextScheduled)-1]
+	}
+
+	if scheduleFrom.IsZero() {
+		scheduleFrom = j.startTime
+	}
+
+	next := j.next(scheduleFrom)
+	if next.IsZero() {
+		// the job's next function will return zero for OneTime jobs.
+		// since they are one time only, they do not need rescheduling.
+		return
+	}
+
+	if next.Before(s.now()) {
+		// in some cases the next run time can be in the past, for example:
+		// - the time on the machine was incorrect and has been synced with ntp
+		// - the machine went to sleep, and woke up some time later
+		// in those cases, we want to increment to the next run in the future
+		// and schedule the job for that time.
+		for next.Before(s.now()) {
+			next = j.next(next)
+		}
+	}
+
+	if slices.Contains(j.nextScheduled, next) {
+		// if the next value is a duplicate of what's already in the nextScheduled slice, for example:
+		// - the job is being rescheduled off the same next run value as before
+		// increment to the next, next value
+		for slices.Contains(j.nextScheduled, next) {
+			next = j.next(next)
+		}
+	}
+
+	// Clean up any existing timer to prevent leaks
+	if j.timer != nil {
+		j.timer.Stop()
+		j.timer = nil // Ensure timer is cleared for GC
+	}
+
+	j.nextScheduled = append(j.nextScheduled, next)
+	j.timer = s.exec.clock.AfterFunc(next.Sub(s.now()), func() {
+		// set the actual timer on the job here and listen for
+		// shut down events so that the job doesn't attempt to
+		// run if the scheduler has been shutdown.
+		select {
+		case <-s.shutdownCtx.Done():
+			return
+		case s.exec.jobsIn <- jobIn{
+			id:            j.id,
+			shouldSendOut: true,
+		}:
+		}
+	})
+	// update the job with its new next and last run times and timer.
+	s.jobs[id] = j
+}
+
+func (s *scheduler) updateNextScheduled(id uuid.UUID) {
+	j, ok := s.jobs[id]
+	if !ok {
+		return
+	}
+	var newNextScheduled []time.Time
+	for _, t := range j.nextScheduled {
+		if t.Before(s.now()) {
+			continue
+		}
+		newNextScheduled = append(newNextScheduled, t)
+	}
+	j.nextScheduled = newNextScheduled
+	s.jobs[id] = j
+}
+
+func (s *scheduler) selectExecJobsOutCompleted(id uuid.UUID) {
+	j, ok := s.jobs[id]
+	if !ok {
+		return
+	}
+
+	// if the job has nextScheduled time in the past,
+	// we need to remove any that are in the past.
+	var newNextScheduled []time.Time
+	for _, t := range j.nextScheduled {
+		if t.Before(s.now()) {
+			continue
+		}
+		newNextScheduled = append(newNextScheduled, t)
+	}
+	j.nextScheduled = newNextScheduled
 
 	// if the job has a limited number of runs set, we need to
 	// check how many runs have occurred and stop running this
@@ -302,37 +457,7 @@ func (s *scheduler) selectExecJobIDsOut(id uuid.UUID) {
 		}
 	}
 
-	next := j.next(j.lastRun)
-	if next.IsZero() {
-		// the job's next function will return zero for OneTime jobs.
-		// since they are one time only, they do not need rescheduling.
-		return
-	}
-	if next.Before(s.now()) {
-		// in some cases the next run time can be in the past, for example:
-		// - the time on the machine was incorrect and has been synced with ntp
-		// - the machine went to sleep, and woke up some time later
-		// in those cases, we want to increment to the next run in the future
-		// and schedule the job for that time.
-		for next.Before(s.now()) {
-			next = j.next(next)
-		}
-	}
-	j.nextRun = next
-	j.timer = s.clock.AfterFunc(next.Sub(s.now()), func() {
-		// set the actual timer on the job here and listen for
-		// shut down events so that the job doesn't attempt to
-		// run if the scheduler has been shutdown.
-		select {
-		case <-s.shutdownCtx.Done():
-			return
-		case s.exec.jobsIn <- jobIn{
-			id:            j.id,
-			shouldSendOut: true,
-		}:
-		}
-	})
-	// update the job with its new next and last run times and timer.
+	j.lastRun = s.now()
 	s.jobs[id] = j
 }
 
@@ -346,7 +471,8 @@ func (s *scheduler) selectJobOutRequest(out jobOutRequest) {
 	close(out.outChan)
 }
 
-func (s *scheduler) selectNewJob(j internalJob) {
+func (s *scheduler) selectNewJob(in newJobIn) {
+	j := in.job
 	if s.started {
 		next := j.startTime
 		if j.startImmediately {
@@ -364,7 +490,7 @@ func (s *scheduler) selectNewJob(j internalJob) {
 			}
 
 			id := j.id
-			j.timer = s.clock.AfterFunc(next.Sub(s.now()), func() {
+			j.timer = s.exec.clock.AfterFunc(next.Sub(s.now()), func() {
 				select {
 				case <-s.shutdownCtx.Done():
 				case s.exec.jobsIn <- jobIn{
@@ -374,10 +500,12 @@ func (s *scheduler) selectNewJob(j internalJob) {
 				}
 			})
 		}
-		j.nextRun = next
+		j.startTime = next
+		j.nextScheduled = append(j.nextScheduled, next)
 	}
 
 	s.jobs[j.id] = j
+	in.cancel()
 }
 
 func (s *scheduler) selectRemoveJobsByTags(tags []string) {
@@ -414,7 +542,7 @@ func (s *scheduler) selectStart() {
 			}
 
 			jobID := id
-			j.timer = s.clock.AfterFunc(next.Sub(s.now()), func() {
+			j.timer = s.exec.clock.AfterFunc(next.Sub(s.now()), func() {
 				select {
 				case <-s.shutdownCtx.Done():
 				case s.exec.jobsIn <- jobIn{
@@ -424,7 +552,8 @@ func (s *scheduler) selectStart() {
 				}
 			})
 		}
-		j.nextRun = next
+		j.startTime = next
+		j.nextScheduled = append(j.nextScheduled, next)
 		s.jobs[id] = j
 	}
 	select {
@@ -441,15 +570,16 @@ func (s *scheduler) selectStart() {
 // -----------------------------------------------
 
 func (s *scheduler) now() time.Time {
-	return s.clock.Now().In(s.location)
+	return s.exec.clock.Now().In(s.location)
 }
 
 func (s *scheduler) jobFromInternalJob(in internalJob) job {
 	return job{
-		id:            in.id,
-		name:          in.name,
-		tags:          slices.Clone(in.tags),
-		jobOutRequest: s.jobOutRequestCh,
+		in.id,
+		in.name,
+		slices.Clone(in.tags),
+		s.jobOutRequestCh,
+		s.runJobRequestCh,
 	}
 }
 
@@ -473,6 +603,70 @@ func (s *scheduler) NewJob(jobDefinition JobDefinition, task Task, options ...Jo
 	return s.addOrUpdateJob(uuid.Nil, jobDefinition, task, options)
 }
 
+func (s *scheduler) verifyInterfaceVariadic(taskFunc reflect.Value, tsk task, variadicStart int) error {
+	ifaceType := taskFunc.Type().In(variadicStart).Elem()
+	for i := variadicStart; i < len(tsk.parameters); i++ {
+		if !reflect.TypeOf(tsk.parameters[i]).Implements(ifaceType) {
+			return ErrNewJobWrongTypeOfParameters
+		}
+	}
+	return nil
+}
+
+func (s *scheduler) verifyVariadic(taskFunc reflect.Value, tsk task, variadicStart int) error {
+	if err := s.verifyNonVariadic(taskFunc, tsk, variadicStart); err != nil {
+		return err
+	}
+	parameterType := taskFunc.Type().In(variadicStart).Elem().Kind()
+	if parameterType == reflect.Interface {
+		return s.verifyInterfaceVariadic(taskFunc, tsk, variadicStart)
+	}
+	if parameterType == reflect.Pointer {
+		parameterType = reflect.Indirect(reflect.ValueOf(taskFunc.Type().In(variadicStart))).Kind()
+	}
+
+	for i := variadicStart; i < len(tsk.parameters); i++ {
+		argumentType := reflect.TypeOf(tsk.parameters[i]).Kind()
+		if argumentType == reflect.Interface || argumentType == reflect.Pointer {
+			argumentType = reflect.TypeOf(tsk.parameters[i]).Elem().Kind()
+		}
+		if argumentType != parameterType {
+			return ErrNewJobWrongTypeOfParameters
+		}
+	}
+	return nil
+}
+
+func (s *scheduler) verifyNonVariadic(taskFunc reflect.Value, tsk task, length int) error {
+	for i := 0; i < length; i++ {
+		t1 := reflect.TypeOf(tsk.parameters[i]).Kind()
+		if t1 == reflect.Interface || t1 == reflect.Pointer {
+			t1 = reflect.TypeOf(tsk.parameters[i]).Elem().Kind()
+		}
+		t2 := reflect.New(taskFunc.Type().In(i)).Elem().Kind()
+		if t2 == reflect.Interface || t2 == reflect.Pointer {
+			t2 = reflect.Indirect(reflect.ValueOf(taskFunc.Type().In(i))).Kind()
+		}
+		if t1 != t2 {
+			return ErrNewJobWrongTypeOfParameters
+		}
+	}
+	return nil
+}
+
+func (s *scheduler) verifyParameterType(taskFunc reflect.Value, tsk task) error {
+	isVariadic := taskFunc.Type().IsVariadic()
+	if isVariadic {
+		variadicStart := taskFunc.Type().NumIn() - 1
+		return s.verifyVariadic(taskFunc, tsk, variadicStart)
+	}
+	expectedParameterLength := taskFunc.Type().NumIn()
+	if len(tsk.parameters) != expectedParameterLength {
+		return ErrNewJobWrongNumberOfParameters
+	}
+	return s.verifyNonVariadic(taskFunc, tsk, expectedParameterLength)
+}
+
 func (s *scheduler) addOrUpdateJob(id uuid.UUID, definition JobDefinition, taskWrapper Task, options []JobOption) (Job, error) {
 	j := internalJob{}
 	if id == uuid.Nil {
@@ -491,8 +685,6 @@ func (s *scheduler) addOrUpdateJob(id uuid.UUID, definition JobDefinition, taskW
 		j.id = id
 	}
 
-	j.ctx, j.cancel = context.WithCancel(s.shutdownCtx)
-
 	if taskWrapper == nil {
 		return nil, ErrNewJobTaskNil
 	}
@@ -507,59 +699,67 @@ func (s *scheduler) addOrUpdateJob(id uuid.UUID, definition JobDefinition, taskW
 		return nil, ErrNewJobTaskNotFunc
 	}
 
-	expectedParameterLength := taskFunc.Type().NumIn()
-	if len(tsk.parameters) != expectedParameterLength {
-		return nil, ErrNewJobWrongNumberOfParameters
-	}
-
-	for i := 0; i < expectedParameterLength; i++ {
-		t1 := reflect.TypeOf(tsk.parameters[i]).Kind()
-		if t1 == reflect.Interface || t1 == reflect.Pointer {
-			t1 = reflect.TypeOf(tsk.parameters[i]).Elem().Kind()
-		}
-		t2 := reflect.New(taskFunc.Type().In(i)).Elem().Kind()
-		if t2 == reflect.Interface || t2 == reflect.Pointer {
-			t2 = reflect.Indirect(reflect.ValueOf(taskFunc.Type().In(i))).Kind()
-		}
-		if t1 != t2 {
-			return nil, ErrNewJobWrongTypeOfParameters
-		}
-	}
-
 	j.name = runtime.FuncForPC(taskFunc.Pointer()).Name()
 	j.function = tsk.function
 	j.parameters = tsk.parameters
 
 	// apply global job options
 	for _, option := range s.globalJobOptions {
-		if err := option(&j); err != nil {
+		if err := option(&j, s.now()); err != nil {
 			return nil, err
 		}
 	}
 
 	// apply job specific options, which take precedence
 	for _, option := range options {
-		if err := option(&j); err != nil {
+		if err := option(&j, s.now()); err != nil {
 			return nil, err
 		}
 	}
 
-	if err := definition.setup(&j, s.location); err != nil {
+	if j.parentCtx == nil {
+		j.parentCtx = s.shutdownCtx
+	}
+	j.ctx, j.cancel = context.WithCancel(j.parentCtx)
+
+	if !taskFunc.IsZero() && taskFunc.Type().NumIn() > 0 {
+		// if the first parameter is a context.Context and params have no context.Context, add current ctx to the params
+		if taskFunc.Type().In(0) == reflect.TypeOf((*context.Context)(nil)).Elem() {
+			if len(tsk.parameters) == 0 {
+				tsk.parameters = []any{j.ctx}
+				j.parameters = []any{j.ctx}
+			} else if _, ok := tsk.parameters[0].(context.Context); !ok {
+				tsk.parameters = append([]any{j.ctx}, tsk.parameters...)
+				j.parameters = append([]any{j.ctx}, j.parameters...)
+			}
+		}
+	}
+
+	if err := s.verifyParameterType(taskFunc, tsk); err != nil {
 		return nil, err
 	}
 
-	select {
-	case <-s.shutdownCtx.Done():
-	case s.newJobCh <- j:
+	if err := definition.setup(&j, s.location, s.exec.clock.Now()); err != nil {
+		return nil, err
 	}
 
-	return &job{
-		id:            j.id,
-		name:          j.name,
-		tags:          slices.Clone(j.tags),
-		jobOutRequest: s.jobOutRequestCh,
-		runJobRequest: s.runJobRequestCh,
-	}, nil
+	newJobCtx, newJobCancel := context.WithCancel(context.Background())
+	select {
+	case <-s.shutdownCtx.Done():
+	case s.newJobCh <- newJobIn{
+		ctx:    newJobCtx,
+		cancel: newJobCancel,
+		job:    j,
+	}:
+	}
+
+	select {
+	case <-newJobCtx.Done():
+	case <-s.shutdownCtx.Done():
+	}
+
+	out := s.jobFromInternalJob(j)
+	return &out, nil
 }
 
 func (s *scheduler) RemoveByTags(tags ...string) {
@@ -596,20 +796,27 @@ func (s *scheduler) StopJobs() error {
 		return nil
 	case s.stopCh <- struct{}{}:
 	}
+
+	t := time.NewTimer(s.exec.stopTimeout + 2*time.Second)
 	select {
 	case err := <-s.stopErrCh:
+		t.Stop()
 		return err
-	case <-time.After(s.exec.stopTimeout + 2*time.Second):
+	case <-t.C:
 		return ErrStopSchedulerTimedOut
 	}
 }
 
 func (s *scheduler) Shutdown() error {
 	s.shutdownCancel()
+
+	t := time.NewTimer(s.exec.stopTimeout + 2*time.Second)
 	select {
 	case err := <-s.stopErrCh:
+
+		t.Stop()
 		return err
-	case <-time.After(s.exec.stopTimeout + 2*time.Second):
+	case <-t.C:
 		return ErrStopSchedulerTimedOut
 	}
 }
@@ -618,6 +825,13 @@ func (s *scheduler) Update(id uuid.UUID, jobDefinition JobDefinition, task Task,
 	return s.addOrUpdateJob(id, jobDefinition, task, options)
 }
 
+func (s *scheduler) JobsWaitingInQueue() int {
+	if s.exec.limitMode != nil && s.exec.limitMode.mode == LimitModeWait {
+		return len(s.exec.limitMode.in)
+	}
+	return 0
+}
+
 // -----------------------------------------------
 // -----------------------------------------------
 // ------------- Scheduler Options ---------------
@@ -635,7 +849,7 @@ func WithClock(clock clockwork.Clock) SchedulerOption {
 		if clock == nil {
 			return ErrWithClockNil
 		}
-		s.clock = clock
+		s.exec.clock = clock
 		return nil
 	}
 }
@@ -657,6 +871,8 @@ func WithDistributedElector(elector Elector) SchedulerOption {
 // WithDistributedLocker sets the locker to be used by multiple
 // Scheduler instances to ensure that only one instance of each
 // job is run.
+// To disable this global locker for specific jobs, see
+// WithDisabledDistributedJobLocker.
 func WithDistributedLocker(locker Locker) SchedulerOption {
 	return func(s *scheduler) error {
 		if locker == nil {
@@ -718,6 +934,14 @@ const (
 // WithLimitConcurrentJobs sets the limit and mode to be used by the
 // Scheduler for limiting the number of jobs that may be running at
 // a given time.
+//
+// Note: the limit mode selected for WithLimitConcurrentJobs takes initial
+// precedence in the event you are also running a limit mode at the job level
+// using WithSingletonMode.
+//
+// Warning: a single time consuming job can dominate your limit in the event
+// you are running both the scheduler limit WithLimitConcurrentJobs(1, LimitModeWait)
+// and a job limit WithSingletonMode(LimitModeReschedule).
 func WithLimitConcurrentJobs(limit uint, mode LimitMode) SchedulerOption {
 	return func(s *scheduler) error {
 		if limit == 0 {
@@ -774,3 +998,25 @@ func WithStopTimeout(timeout time.Duration) SchedulerOption {
 		return nil
 	}
 }
+
+// WithMonitor sets the metrics provider to be used by the Scheduler.
+func WithMonitor(monitor Monitor) SchedulerOption {
+	return func(s *scheduler) error {
+		if monitor == nil {
+			return ErrWithMonitorNil
+		}
+		s.exec.monitor = monitor
+		return nil
+	}
+}
+
+// WithMonitorStatus sets the metrics provider to be used by the Scheduler.
+func WithMonitorStatus(monitor MonitorStatus) SchedulerOption {
+	return func(s *scheduler) error {
+		if monitor == nil {
+			return ErrWithMonitorNil
+		}
+		s.exec.monitorStatus = monitor
+		return nil
+	}
+}

vendor/github.com/go-co-op/gocron/v2/util.go

@@ -3,12 +3,11 @@ package gocron
 import (
 	"context"
 	"reflect"
+	"slices"
 	"sync"
 	"time"
 
 	"github.com/google/uuid"
-	"golang.org/x/exp/maps"
-	"golang.org/x/exp/slices"
 )
 
 func callJobFuncWithParams(jobFunc any, params ...any) error {
@@ -44,18 +43,12 @@ func requestJob(id uuid.UUID, ch chan jobOutRequest) *internalJob {
 
 func requestJobCtx(ctx context.Context, id uuid.UUID, ch chan jobOutRequest) *internalJob {
 	resp := make(chan internalJob, 1)
-	select {
-	case <-ctx.Done():
-		return nil
-	default:
-	}
-
 	select {
 	case ch <- jobOutRequest{
 		id:      id,
 		outChan: resp,
 	}:
-	default:
+	case <-ctx.Done():
 		return nil
 	}
 	var j internalJob
@@ -69,12 +62,8 @@ func requestJobCtx(ctx context.Context, id uuid.UUID, ch chan jobOutRequest) *in
 }
 
 func removeSliceDuplicatesInt(in []int) []int {
-	m := make(map[int]struct{})
-
-	for _, i := range in {
-		m[i] = struct{}{}
-	}
-	return maps.Keys(m)
+	slices.Sort(in)
+	return slices.Compact(in)
 }
 
 func convertAtTimesToDateTime(atTimes AtTimes, location *time.Location) ([]time.Time, error) {
@@ -94,12 +83,14 @@ func convertAtTimesToDateTime(atTimes AtTimes, location *time.Location) ([]time.
 		}
 		atTimesDate = append(atTimesDate, at.time(location))
 	}
-	slices.SortStableFunc(atTimesDate, func(a, b time.Time) int {
-		return a.Compare(b)
-	})
+	slices.SortStableFunc(atTimesDate, ascendingTime)
 	return atTimesDate, nil
 }
 
+func ascendingTime(a, b time.Time) int {
+	return a.Compare(b)
+}
+
 type waitGroupWithMutex struct {
 	wg sync.WaitGroup
 	mu sync.Mutex

vendor/github.com/google/uuid/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## [1.6.0](https://github.com/google/uuid/compare/v1.5.0...v1.6.0) (2024-01-16)
+
+
+### Features
+
+* add Max UUID constant ([#149](https://github.com/google/uuid/issues/149)) ([c58770e](https://github.com/google/uuid/commit/c58770eb495f55fe2ced6284f93c5158a62e53e3))
+
+
+### Bug Fixes
+
+* fix typo in version 7 uuid documentation ([#153](https://github.com/google/uuid/issues/153)) ([016b199](https://github.com/google/uuid/commit/016b199544692f745ffc8867b914129ecb47ef06))
+* Monotonicity in UUIDv7 ([#150](https://github.com/google/uuid/issues/150)) ([a2b2b32](https://github.com/google/uuid/commit/a2b2b32373ff0b1a312b7fdf6d38a977099698a6))
+
 ## [1.5.0](https://github.com/google/uuid/compare/v1.4.0...v1.5.0) (2023-12-12)
 
 

vendor/github.com/google/uuid/hash.go

@@ -17,6 +17,12 @@ var (
 	NameSpaceOID  = Must(Parse("6ba7b812-9dad-11d1-80b4-00c04fd430c8"))
 	NameSpaceX500 = Must(Parse("6ba7b814-9dad-11d1-80b4-00c04fd430c8"))
 	Nil           UUID // empty UUID, all zeros
+
+	// The Max UUID is special form of UUID that is specified to have all 128 bits set to 1.
+	Max = UUID{
+		0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+		0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+	}
 )
 
 // NewHash returns a new UUID derived from the hash of space concatenated with

vendor/github.com/google/uuid/version7.go

@@ -44,7 +44,7 @@ func NewV7FromReader(r io.Reader) (UUID, error) {
 
 // makeV7 fill 48 bits time (uuid[0] - uuid[5]), set version b0111 (uuid[6])
 // uuid[8] already has the right version number (Variant is 10)
-// see function  NewV7 and NewV7FromReader
+// see function NewV7 and NewV7FromReader
 func makeV7(uuid []byte) {
 	/*
 		 0                   1                   2                   3
@@ -52,7 +52,7 @@ func makeV7(uuid []byte) {
 		+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 		|                           unix_ts_ms                          |
 		+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-		|          unix_ts_ms           |  ver  |       rand_a          |
+		|          unix_ts_ms           |  ver  |  rand_a (12 bit seq)  |
 		+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 		|var|                        rand_b                             |
 		+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
@@ -61,7 +61,7 @@ func makeV7(uuid []byte) {
 	*/
 	_ = uuid[15] // bounds check
 
-	t := timeNow().UnixMilli()
+	t, s := getV7Time()
 
 	uuid[0] = byte(t >> 40)
 	uuid[1] = byte(t >> 32)
@@ -70,6 +70,35 @@ func makeV7(uuid []byte) {
 	uuid[4] = byte(t >> 8)
 	uuid[5] = byte(t)
 
-	uuid[6] = 0x70 | (uuid[6] & 0x0F)
-	// uuid[8] has already has right version
+	uuid[6] = 0x70 | (0x0F & byte(s>>8))
+	uuid[7] = byte(s)
+}
+
+// lastV7time is the last time we returned stored as:
+//
+//	52 bits of time in milliseconds since epoch
+//	12 bits of (fractional nanoseconds) >> 8
+var lastV7time int64
+
+const nanoPerMilli = 1000000
+
+// getV7Time returns the time in milliseconds and nanoseconds / 256.
+// The returned (milli << 12 + seq) is guarenteed to be greater than
+// (milli << 12 + seq) returned by any previous call to getV7Time.
+func getV7Time() (milli, seq int64) {
+	timeMu.Lock()
+	defer timeMu.Unlock()
+
+	nano := timeNow().UnixNano()
+	milli = nano / nanoPerMilli
+	// Sequence number is between 0 and 3906 (nanoPerMilli>>8)
+	seq = (nano - milli*nanoPerMilli) >> 8
+	now := milli<<12 + seq
+	if now <= lastV7time {
+		now = lastV7time + 1
+		milli = now >> 12
+		seq = now & 0xfff
+	}
+	lastV7time = now
+	return milli, seq
 }

vendor/github.com/jonboulle/clockwork/README.md

@@ -36,6 +36,7 @@ Now you can easily test `myFunc` with a `FakeClock`:
 
 ```go
 func TestMyFunc(t *testing.T) {
+	ctx := context.Background()
 	c := clockwork.NewFakeClock()
 
 	// Start our sleepy function
@@ -46,8 +47,12 @@ func TestMyFunc(t *testing.T) {
 		wg.Done()
 	}()
 
-	// Ensure we wait until myFunc is sleeping
-	c.BlockUntil(1)
+	// Ensure we wait until myFunc is waiting on the clock.
+	// Use a context to avoid blocking forever if something
+	// goes wrong.
+	ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
+	defer cancel()
+	c.BlockUntilContext(ctx, 1)
 
 	assertState()
 

vendor/github.com/jonboulle/clockwork/SECURITY.md

@@ -0,0 +1,19 @@
+# Security Policy
+
+If you have discovered a security vulnerability in this project, please report it
+privately. **Do not disclose it as a public issue.** This gives me time to work with you
+to fix the issue before public exposure, reducing the chance that the exploit will be
+used before a patch is released.
+
+You may submit the report in the following ways:
+
+- send an email to ???@???; and/or
+- send a [private vulnerability report](https://github.com/jonboulle/clockwork/security/advisories/new)
+
+Please provide the following information in your report:
+
+- A description of the vulnerability and its impact
+- How to reproduce the issue
+
+This project is maintained by a single maintainer on a reasonable-effort basis. As such,
+please give me 90 days to work on a fix before public exposure.

vendor/github.com/jonboulle/clockwork/clockwork.go

@@ -1,8 +1,10 @@
+// Package clockwork contains a simple fake clock for Go.
 package clockwork
 
 import (
 	"context"
-	"sort"
+	"errors"
+	"slices"
 	"sync"
 	"time"
 )
@@ -14,49 +16,18 @@ type Clock interface {
 	Sleep(d time.Duration)
 	Now() time.Time
 	Since(t time.Time) time.Duration
+	Until(t time.Time) time.Duration
 	NewTicker(d time.Duration) Ticker
 	NewTimer(d time.Duration) Timer
 	AfterFunc(d time.Duration, f func()) Timer
 }
 
-// FakeClock provides an interface for a clock which can be manually advanced
-// through time.
-//
-// FakeClock maintains a list of "waiters," which consists of all callers
-// waiting on the underlying clock (i.e. Tickers and Timers including callers of
-// Sleep or After). Users can call BlockUntil to block until the clock has an
-// expected number of waiters.
-type FakeClock interface {
-	Clock
-	// Advance advances the FakeClock to a new point in time, ensuring any existing
-	// waiters are notified appropriately before returning.
-	Advance(d time.Duration)
-	// BlockUntil blocks until the FakeClock has the given number of waiters.
-	BlockUntil(waiters int)
-}
-
 // NewRealClock returns a Clock which simply delegates calls to the actual time
 // package; it should be used by packages in production.
 func NewRealClock() Clock {
 	return &realClock{}
 }
 
-// NewFakeClock returns a FakeClock implementation which can be
-// manually advanced through time for testing. The initial time of the
-// FakeClock will be the current system time.
-//
-// Tests that require a deterministic time must use NewFakeClockAt.
-func NewFakeClock() FakeClock {
-	return NewFakeClockAt(time.Now())
-}
-
-// NewFakeClockAt returns a FakeClock initialised at the given time.Time.
-func NewFakeClockAt(t time.Time) FakeClock {
-	return &fakeClock{
-		time: t,
-	}
-}
-
 type realClock struct{}
 
 func (rc *realClock) After(d time.Duration) <-chan time.Time {
@@ -75,6 +46,10 @@ func (rc *realClock) Since(t time.Time) time.Duration {
 	return rc.Now().Sub(t)
 }
 
+func (rc *realClock) Until(t time.Time) time.Duration {
+	return t.Sub(rc.Now())
+}
+
 func (rc *realClock) NewTicker(d time.Duration) Ticker {
 	return realTicker{time.NewTicker(d)}
 }
@@ -87,7 +62,14 @@ func (rc *realClock) AfterFunc(d time.Duration, f func()) Timer {
 	return realTimer{time.AfterFunc(d, f)}
 }
 
-type fakeClock struct {
+// FakeClock provides an interface for a clock which can be manually advanced
+// through time.
+//
+// FakeClock maintains a list of "waiters," which consists of all callers
+// waiting on the underlying clock (i.e. Tickers and Timers including callers of
+// Sleep or After). Users can call BlockUntil to block until the clock has an
+// expected number of waiters.
+type FakeClock struct {
 	// l protects all attributes of the clock, including all attributes of all
 	// waiters and blockers.
 	l        sync.RWMutex
@@ -96,11 +78,27 @@ type fakeClock struct {
 	time     time.Time
 }
 
+// NewFakeClock returns a FakeClock implementation which can be
+// manually advanced through time for testing. The initial time of the
+// FakeClock will be the current system time.
+//
+// Tests that require a deterministic time must use NewFakeClockAt.
+func NewFakeClock() *FakeClock {
+	return NewFakeClockAt(time.Now())
+}
+
+// NewFakeClockAt returns a FakeClock initialised at the given time.Time.
+func NewFakeClockAt(t time.Time) *FakeClock {
+	return &FakeClock{
+		time: t,
+	}
+}
+
 // blocker is a caller of BlockUntil.
 type blocker struct {
 	count int
 
-	// ch is closed when the underlying clock has the specificed number of blockers.
+	// ch is closed when the underlying clock has the specified number of blockers.
 	ch chan struct{}
 }
 
@@ -111,23 +109,23 @@ type expirer interface {
 	expire(now time.Time) (next *time.Duration)
 
 	// Get and set the expiration time.
-	expiry() time.Time
-	setExpiry(time.Time)
+	expiration() time.Time
+	setExpiration(time.Time)
 }
 
 // After mimics [time.After]; it waits for the given duration to elapse on the
 // fakeClock, then sends the current time on the returned channel.
-func (fc *fakeClock) After(d time.Duration) <-chan time.Time {
+func (fc *FakeClock) After(d time.Duration) <-chan time.Time {
 	return fc.NewTimer(d).Chan()
 }
 
 // Sleep blocks until the given duration has passed on the fakeClock.
-func (fc *fakeClock) Sleep(d time.Duration) {
+func (fc *FakeClock) Sleep(d time.Duration) {
 	<-fc.After(d)
 }
 
 // Now returns the current time of the fakeClock
-func (fc *fakeClock) Now() time.Time {
+func (fc *FakeClock) Now() time.Time {
 	fc.l.RLock()
 	defer fc.l.RUnlock()
 	return fc.time
@@ -135,61 +133,73 @@ func (fc *fakeClock) Now() time.Time {
 
 // Since returns the duration that has passed since the given time on the
 // fakeClock.
-func (fc *fakeClock) Since(t time.Time) time.Duration {
+func (fc *FakeClock) Since(t time.Time) time.Duration {
 	return fc.Now().Sub(t)
 }
 
+// Until returns the duration that has to pass from the given time on the fakeClock
+// to reach the given time.
+func (fc *FakeClock) Until(t time.Time) time.Duration {
+	return t.Sub(fc.Now())
+}
+
 // NewTicker returns a Ticker that will expire only after calls to
-// fakeClock.Advance() have moved the clock past the given duration.
-func (fc *fakeClock) NewTicker(d time.Duration) Ticker {
-	var ft *fakeTicker
-	ft = &fakeTicker{
-		firer: newFirer(),
-		d:     d,
-		reset: func(d time.Duration) { fc.set(ft, d) },
-		stop:  func() { fc.stop(ft) },
+// FakeClock.Advance() have moved the clock past the given duration.
+//
+// The duration d must be greater than zero; if not, NewTicker will panic.
+func (fc *FakeClock) NewTicker(d time.Duration) Ticker {
+	// Maintain parity with
+	// https://cs.opensource.google/go/go/+/refs/tags/go1.20.3:src/time/tick.go;l=23-25
+	if d <= 0 {
+		panic(errors.New("non-positive interval for NewTicker"))
 	}
-	fc.set(ft, d)
+	ft := newFakeTicker(fc, d)
+	fc.l.Lock()
+	defer fc.l.Unlock()
+	fc.setExpirer(ft, d)
 	return ft
 }
 
 // NewTimer returns a Timer that will fire only after calls to
 // fakeClock.Advance() have moved the clock past the given duration.
-func (fc *fakeClock) NewTimer(d time.Duration) Timer {
-	return fc.newTimer(d, nil)
+func (fc *FakeClock) NewTimer(d time.Duration) Timer {
+	t, _ := fc.newTimer(d, nil)
+	return t
 }
 
 // AfterFunc mimics [time.AfterFunc]; it returns a Timer that will invoke the
 // given function only after calls to fakeClock.Advance() have moved the clock
 // past the given duration.
-func (fc *fakeClock) AfterFunc(d time.Duration, f func()) Timer {
-	return fc.newTimer(d, f)
+func (fc *FakeClock) AfterFunc(d time.Duration, f func()) Timer {
+	t, _ := fc.newTimer(d, f)
+	return t
 }
 
-// newTimer returns a new timer, using an optional afterFunc.
-func (fc *fakeClock) newTimer(d time.Duration, afterfunc func()) *fakeTimer {
-	var ft *fakeTimer
-	ft = &fakeTimer{
-		firer: newFirer(),
-		reset: func(d time.Duration) bool {
-			fc.l.Lock()
-			defer fc.l.Unlock()
-			// fc.l must be held across the calls to stopExpirer & setExpirer.
-			stopped := fc.stopExpirer(ft)
-			fc.setExpirer(ft, d)
-			return stopped
-		},
-		stop: func() bool { return fc.stop(ft) },
+// newTimer returns a new timer using an optional afterFunc and the time that
+// timer expires.
+func (fc *FakeClock) newTimer(d time.Duration, afterfunc func()) (*fakeTimer, time.Time) {
+	ft := newFakeTimer(fc, afterfunc)
+	fc.l.Lock()
+	defer fc.l.Unlock()
+	fc.setExpirer(ft, d)
+	return ft, ft.expiration()
+}
 
-		afterFunc: afterfunc,
-	}
-	fc.set(ft, d)
+// newTimerAtTime is like newTimer, but uses a time instead of a duration.
+//
+// It is used to ensure FakeClock's lock is held constant through calling
+// fc.After(t.Sub(fc.Now())). It should not be exposed externally.
+func (fc *FakeClock) newTimerAtTime(t time.Time, afterfunc func()) *fakeTimer {
+	ft := newFakeTimer(fc, afterfunc)
+	fc.l.Lock()
+	defer fc.l.Unlock()
+	fc.setExpirer(ft, t.Sub(fc.time))
 	return ft
 }
 
 // Advance advances fakeClock to a new point in time, ensuring waiters and
 // blockers are notified appropriately before returning.
-func (fc *fakeClock) Advance(d time.Duration) {
+func (fc *FakeClock) Advance(d time.Duration) {
 	fc.l.Lock()
 	defer fc.l.Unlock()
 	end := fc.time.Add(d)
@@ -198,38 +208,34 @@ func (fc *fakeClock) Advance(d time.Duration) {
 	//
 	// We don't iterate because the callback of the waiter might register a new
 	// waiter, so the list of waiters might change as we execute this.
-	for len(fc.waiters) > 0 && !end.Before(fc.waiters[0].expiry()) {
+	for len(fc.waiters) > 0 && !end.Before(fc.waiters[0].expiration()) {
 		w := fc.waiters[0]
 		fc.waiters = fc.waiters[1:]
 
-		// Use the waiter's expriation as the current time for this expiration.
-		now := w.expiry()
+		// Use the waiter's expiration as the current time for this expiration.
+		now := w.expiration()
 		fc.time = now
 		if d := w.expire(now); d != nil {
-			// Set the new exipration if needed.
+			// Set the new expiration if needed.
 			fc.setExpirer(w, *d)
 		}
 	}
 	fc.time = end
 }
 
-// BlockUntil blocks until the fakeClock has the given number of waiters.
+// BlockUntil blocks until the FakeClock has the given number of waiters.
 //
-// Prefer BlockUntilContext, which offers context cancellation to prevent
-// deadlock.
+// Prefer BlockUntilContext in new code, which offers context cancellation to
+// prevent deadlock.
 //
-// Deprecation warning: This function might be deprecated in later versions.
-func (fc *fakeClock) BlockUntil(n int) {
-	b := fc.newBlocker(n)
-	if b == nil {
-		return
-	}
-	<-b.ch
+// Deprecated: New code should prefer BlockUntilContext.
+func (fc *FakeClock) BlockUntil(n int) {
+	fc.BlockUntilContext(context.TODO(), n)
 }
 
 // BlockUntilContext blocks until the fakeClock has the given number of waiters
 // or the context is cancelled.
-func (fc *fakeClock) BlockUntilContext(ctx context.Context, n int) error {
+func (fc *FakeClock) BlockUntilContext(ctx context.Context, n int) error {
 	b := fc.newBlocker(n)
 	if b == nil {
 		return nil
@@ -243,7 +249,7 @@ func (fc *fakeClock) BlockUntilContext(ctx context.Context, n int) error {
 	}
 }
 
-func (fc *fakeClock) newBlocker(n int) *blocker {
+func (fc *FakeClock) newBlocker(n int) *blocker {
 	fc.l.Lock()
 	defer fc.l.Unlock()
 	// Fast path: we already have >= n waiters.
@@ -260,7 +266,7 @@ func (fc *fakeClock) newBlocker(n int) *blocker {
 }
 
 // stop stops an expirer, returning true if the expirer was stopped.
-func (fc *fakeClock) stop(e expirer) bool {
+func (fc *FakeClock) stop(e expirer) bool {
 	fc.l.Lock()
 	defer fc.l.Unlock()
 	return fc.stopExpirer(e)
@@ -269,81 +275,45 @@ func (fc *fakeClock) stop(e expirer) bool {
 // stopExpirer stops an expirer, returning true if the expirer was stopped.
 //
 // The caller must hold fc.l.
-func (fc *fakeClock) stopExpirer(e expirer) bool {
-	for i, t := range fc.waiters {
-		if t == e {
-			// Remove element, maintaining order.
-			copy(fc.waiters[i:], fc.waiters[i+1:])
-			fc.waiters[len(fc.waiters)-1] = nil
-			fc.waiters = fc.waiters[:len(fc.waiters)-1]
-			return true
-		}
+func (fc *FakeClock) stopExpirer(e expirer) bool {
+	idx := slices.Index(fc.waiters, e)
+	if idx == -1 {
+		return false
 	}
-	return false
-}
-
-// set sets an expirer to expire at a future point in time.
-func (fc *fakeClock) set(e expirer, d time.Duration) {
-	fc.l.Lock()
-	defer fc.l.Unlock()
-	fc.setExpirer(e, d)
+	// Remove element, maintaining order, setting inaccessible elements to nil so
+	// they can be garbage collected.
+	copy(fc.waiters[idx:], fc.waiters[idx+1:])
+	fc.waiters[len(fc.waiters)-1] = nil
+	fc.waiters = fc.waiters[:len(fc.waiters)-1]
+	return true
 }
 
 // setExpirer sets an expirer to expire at a future point in time.
 //
 // The caller must hold fc.l.
-func (fc *fakeClock) setExpirer(e expirer, d time.Duration) {
+func (fc *FakeClock) setExpirer(e expirer, d time.Duration) {
 	if d.Nanoseconds() <= 0 {
-		// special case - trigger immediately, never reset.
+		// Special case for timers with duration <= 0: trigger immediately, never
+		// reset.
 		//
-		// TODO: Explain what cases this covers.
+		// Tickers never get here, they panic if d is < 0.
 		e.expire(fc.time)
 		return
 	}
 	// Add the expirer to the set of waiters and notify any blockers.
-	e.setExpiry(fc.time.Add(d))
+	e.setExpiration(fc.time.Add(d))
 	fc.waiters = append(fc.waiters, e)
-	sort.Slice(fc.waiters, func(i int, j int) bool {
-		return fc.waiters[i].expiry().Before(fc.waiters[j].expiry())
+	slices.SortFunc(fc.waiters, func(a, b expirer) int {
+		return a.expiration().Compare(b.expiration())
 	})
 
-    // Notify blockers of our new waiter.
-	var blocked []*blocker
+	// Notify blockers of our new waiter.
 	count := len(fc.waiters)
-	for _, b := range fc.blockers {
+	fc.blockers = slices.DeleteFunc(fc.blockers, func(b *blocker) bool {
 		if b.count <= count {
 			close(b.ch)
-			continue
+			return true
 		}
-		blocked = append(blocked, b)
-	}
-	fc.blockers = blocked
-}
-
-// firer is used by fakeTimer and fakeTicker used to help implement expirer.
-type firer struct {
-	// The channel associated with the firer, used to send expriation times.
-	c chan time.Time
-
-	// The time when the firer expires. Only meaningful if the firer is currently
-	// one of a fakeClock's waiters.
-	exp time.Time
-}
-
-func newFirer() firer {
-	return firer{c: make(chan time.Time, 1)}
-}
-
-func (f *firer) Chan() <-chan time.Time {
-	return f.c
-}
-
-// expiry implements expirer.
-func (f *firer) expiry() time.Time {
-	return f.exp
-}
-
-// setExpiry implements expirer.
-func (f *firer) setExpiry(t time.Time) {
-	f.exp = t
+		return false
+	})
 }

vendor/github.com/jonboulle/clockwork/context.go

@@ -2,24 +2,168 @@ package clockwork
 
 import (
 	"context"
+	"fmt"
+	"sync"
+	"time"
 )
 
 // contextKey is private to this package so we can ensure uniqueness here. This
 // type identifies context values provided by this package.
 type contextKey string
 
-// keyClock provides a clock for injecting during tests. If absent, a real clock should be used.
+// keyClock provides a clock for injecting during tests. If absent, a real clock
+// should be used.
 var keyClock = contextKey("clock") // clockwork.Clock
 
 // AddToContext creates a derived context that references the specified clock.
+//
+// Be aware this doesn't change the behavior of standard library functions, such
+// as [context.WithTimeout] or [context.WithDeadline]. For this reason, users
+// should prefer passing explicit [clockwork.Clock] variables rather can passing
+// the clock via the context.
 func AddToContext(ctx context.Context, clock Clock) context.Context {
 	return context.WithValue(ctx, keyClock, clock)
 }
 
-// FromContext extracts a clock from the context. If not present, a real clock is returned.
+// FromContext extracts a clock from the context. If not present, a real clock
+// is returned.
 func FromContext(ctx context.Context) Clock {
 	if clock, ok := ctx.Value(keyClock).(Clock); ok {
 		return clock
 	}
 	return NewRealClock()
 }
+
+// ErrFakeClockDeadlineExceeded is the error returned by [context.Context] when
+// the deadline passes on a context which uses a [FakeClock].
+//
+// It wraps a [context.DeadlineExceeded] error, i.e.:
+//
+//	// The following is true for any Context whose deadline has been exceeded,
+//	// including contexts made with clockwork.WithDeadline or clockwork.WithTimeout.
+//
+//	errors.Is(ctx.Err(), context.DeadlineExceeded)
+//
+//	// The following can only be true for contexts made
+//	// with clockwork.WithDeadline or clockwork.WithTimeout.
+//
+//	errors.Is(ctx.Err(), clockwork.ErrFakeClockDeadlineExceeded)
+var ErrFakeClockDeadlineExceeded error = fmt.Errorf("clockwork.FakeClock: %w", context.DeadlineExceeded)
+
+// WithDeadline returns a context with a deadline based on a [FakeClock].
+//
+// The returned context ignores parent cancelation if the parent was cancelled
+// with a [context.DeadlineExceeded] error. Any other error returned by the
+// parent is treated normally, cancelling the returned context.
+//
+// If the parent is cancelled with a [context.DeadlineExceeded] error, the only
+// way to then cancel the returned context is by calling the returned
+// context.CancelFunc.
+func WithDeadline(parent context.Context, clock Clock, t time.Time) (context.Context, context.CancelFunc) {
+	if fc, ok := clock.(*FakeClock); ok {
+		return newFakeClockContext(parent, t, fc.newTimerAtTime(t, nil).Chan())
+	}
+	return context.WithDeadline(parent, t)
+}
+
+// WithTimeout returns a context with a timeout based on a [FakeClock].
+//
+// The returned context follows the same behaviors as [WithDeadline].
+func WithTimeout(parent context.Context, clock Clock, d time.Duration) (context.Context, context.CancelFunc) {
+	if fc, ok := clock.(*FakeClock); ok {
+		t, deadline := fc.newTimer(d, nil)
+		return newFakeClockContext(parent, deadline, t.Chan())
+	}
+	return context.WithTimeout(parent, d)
+}
+
+// fakeClockContext implements context.Context, using a fake clock for its
+// deadline.
+//
+// It ignores parent cancellation if the parent is cancelled with
+// context.DeadlineExceeded.
+type fakeClockContext struct {
+	parent   context.Context
+	deadline time.Time // The user-facing deadline based on the fake clock's time.
+
+	// Tracks timeout/deadline cancellation.
+	timerDone <-chan time.Time
+
+	// Tracks manual calls to the cancel function.
+	cancel       func() // Closes cancelCalled wrapped in a sync.Once.
+	cancelCalled chan struct{}
+
+	// The user-facing data from the context.Context interface.
+	ctxDone chan struct{} // Returned by Done().
+	err     error         // nil until ctxDone is ready to be closed.
+}
+
+func newFakeClockContext(parent context.Context, deadline time.Time, timer <-chan time.Time) (context.Context, context.CancelFunc) {
+	cancelCalled := make(chan struct{})
+	ctx := &fakeClockContext{
+		parent:       parent,
+		deadline:     deadline,
+		timerDone:    timer,
+		cancelCalled: cancelCalled,
+		ctxDone:      make(chan struct{}),
+		cancel: sync.OnceFunc(func() {
+			close(cancelCalled)
+		}),
+	}
+	ready := make(chan struct{}, 1)
+	go ctx.runCancel(ready)
+	<-ready // Wait until the cancellation goroutine is running.
+	return ctx, ctx.cancel
+}
+
+func (c *fakeClockContext) Deadline() (time.Time, bool) {
+	return c.deadline, true
+}
+
+func (c *fakeClockContext) Done() <-chan struct{} {
+	return c.ctxDone
+}
+
+func (c *fakeClockContext) Err() error {
+	<-c.Done() // Don't return the error before it is ready.
+	return c.err
+}
+
+func (c *fakeClockContext) Value(key any) any {
+	return c.parent.Value(key)
+}
+
+// runCancel runs the fakeClockContext's cancel goroutine and returns the
+// fakeClockContext's cancel function.
+//
+// fakeClockContext is then cancelled when any of the following occur:
+//
+//   - The fakeClockContext.done channel is closed by its timer.
+//   - The returned CancelFunc is executed.
+//   - The fakeClockContext's parent context is cancelled with an error other
+//     than context.DeadlineExceeded.
+func (c *fakeClockContext) runCancel(ready chan struct{}) {
+	parentDone := c.parent.Done()
+
+	// Close ready when done, just in case the ready signal races with other
+	// branches of our select statement below.
+	defer close(ready)
+
+	for c.err == nil {
+		select {
+		case <-c.timerDone:
+			c.err = ErrFakeClockDeadlineExceeded
+		case <-c.cancelCalled:
+			c.err = context.Canceled
+		case <-parentDone:
+			c.err = c.parent.Err()
+
+		case ready <- struct{}{}:
+			// Signals the cancellation goroutine has begun, in an attempt to minimize
+			// race conditions related to goroutine startup time.
+			ready = nil // This case statement can only fire once.
+		}
+	}
+	close(c.ctxDone)
+	return
+}

vendor/github.com/jonboulle/clockwork/ticker.go

@@ -19,7 +19,12 @@ func (r realTicker) Chan() <-chan time.Time {
 }
 
 type fakeTicker struct {
-	firer
+	// The channel associated with the firer, used to send expiration times.
+	c chan time.Time
+
+	// The time when the ticker expires. Only meaningful if the ticker is currently
+	// one of a FakeClock's waiters.
+	exp time.Time
 
 	// reset and stop provide the implementation of the respective exported
 	// functions.
@@ -30,13 +35,27 @@ type fakeTicker struct {
 	d time.Duration
 }
 
-func (f *fakeTicker) Reset(d time.Duration) {
-	f.reset(d)
+func newFakeTicker(fc *FakeClock, d time.Duration) *fakeTicker {
+	var ft *fakeTicker
+	ft = &fakeTicker{
+		c: make(chan time.Time, 1),
+		d: d,
+		reset: func(d time.Duration) {
+			fc.l.Lock()
+			defer fc.l.Unlock()
+			ft.d = d
+			fc.setExpirer(ft, d)
+		},
+		stop: func() { fc.stop(ft) },
+	}
+	return ft
 }
 
-func (f *fakeTicker) Stop() {
-	f.stop()
-}
+func (f *fakeTicker) Chan() <-chan time.Time { return f.c }
+
+func (f *fakeTicker) Reset(d time.Duration) { f.reset(d) }
+
+func (f *fakeTicker) Stop() { f.stop() }
 
 func (f *fakeTicker) expire(now time.Time) *time.Duration {
 	// Never block on expiration.
@@ -46,3 +65,7 @@ func (f *fakeTicker) expire(now time.Time) *time.Duration {
 	}
 	return &f.d
 }
+
+func (f *fakeTicker) expiration() time.Time { return f.exp }
+
+func (f *fakeTicker) setExpiration(t time.Time) { f.exp = t }

vendor/github.com/jonboulle/clockwork/timer.go

@@ -18,9 +18,14 @@ func (r realTimer) Chan() <-chan time.Time {
 }
 
 type fakeTimer struct {
-	firer
+	// The channel associated with the firer, used to send expiration times.
+	c chan time.Time
 
-	// reset and stop provide the implmenetation of the respective exported
+	// The time when the firer expires. Only meaningful if the firer is currently
+	// one of a FakeClock's waiters.
+	exp time.Time
+
+	// reset and stop provide the implementation of the respective exported
 	// functions.
 	reset func(d time.Duration) bool
 	stop  func() bool
@@ -30,13 +35,30 @@ type fakeTimer struct {
 	afterFunc func()
 }
 
-func (f *fakeTimer) Reset(d time.Duration) bool {
-	return f.reset(d)
+func newFakeTimer(fc *FakeClock, afterfunc func()) *fakeTimer {
+	var ft *fakeTimer
+	ft = &fakeTimer{
+		c: make(chan time.Time, 1),
+		reset: func(d time.Duration) bool {
+			fc.l.Lock()
+			defer fc.l.Unlock()
+			// fc.l must be held across the calls to stopExpirer & setExpirer.
+			stopped := fc.stopExpirer(ft)
+			fc.setExpirer(ft, d)
+			return stopped
+		},
+		stop: func() bool { return fc.stop(ft) },
+
+		afterFunc: afterfunc,
+	}
+	return ft
 }
 
-func (f *fakeTimer) Stop() bool {
-	return f.stop()
-}
+func (f *fakeTimer) Chan() <-chan time.Time { return f.c }
+
+func (f *fakeTimer) Reset(d time.Duration) bool { return f.reset(d) }
+
+func (f *fakeTimer) Stop() bool { return f.stop() }
 
 func (f *fakeTimer) expire(now time.Time) *time.Duration {
 	if f.afterFunc != nil {
@@ -51,3 +73,7 @@ func (f *fakeTimer) expire(now time.Time) *time.Duration {
 	}
 	return nil
 }
+
+func (f *fakeTimer) expiration() time.Time { return f.exp }
+
+func (f *fakeTimer) setExpiration(t time.Time) { f.exp = t }

vendor/github.com/mafik/pulseaudio/client.go

@@ -35,8 +35,6 @@ import (
 
 const version = 32
 
-var defaultAddr = fmt.Sprintf("/run/user/%d/pulse/native", os.Getuid())
-
 type packetResponse struct {
 	buff *bytes.Buffer
 	err  error
@@ -67,7 +65,11 @@ type Client struct {
 // NewClient establishes a connection to the PulseAudio server.
 func NewClient(addressArr ...string) (*Client, error) {
 	if len(addressArr) < 1 {
-		addressArr = []string{defaultAddr}
+		xdgRuntimeDir, ok := os.LookupEnv("XDG_RUNTIME_DIR")
+		if !ok {
+			xdgRuntimeDir = fmt.Sprintf("/run/user/%d", os.Getuid())
+		}
+		addressArr = []string{fmt.Sprintf("%s/pulse/native", xdgRuntimeDir)}
 	}
 
 	conn, err := net.Dial("unix", addressArr[0])

vendor/github.com/yusufpapurcu/wmi/wmi.go

@@ -456,6 +456,18 @@ func (c *Client) loadEntity(dst interface{}, src *ole.IDispatch) (errFieldMismat
 					Reason:     "not a Float32",
 				}
 			}
+		case float64:
+			switch f.Kind() {
+			case reflect.Float32, reflect.Float64:
+				f.SetFloat(val)
+			default:
+				return &ErrFieldMismatch{
+					StructType: of.Type(),
+					FieldName:  n,
+					Reason:     "not a Float64",
+				}
+			}
+		
 		default:
 			if f.Kind() == reflect.Slice {
 				switch f.Type().Elem().Kind() {

vendor/golang.org/x/exp/LICENSE

@@ -1,27 +0,0 @@
-Copyright (c) 2009 The Go Authors. All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-   * Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-   * Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the following disclaimer
-in the documentation and/or other materials provided with the
-distribution.
-   * Neither the name of Google Inc. nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

vendor/golang.org/x/exp/PATENTS

@@ -1,22 +0,0 @@
-Additional IP Rights Grant (Patents)
-
-"This implementation" means the copyrightable works distributed by
-Google as part of the Go project.
-
-Google hereby grants to You a perpetual, worldwide, non-exclusive,
-no-charge, royalty-free, irrevocable (except as stated in this section)
-patent license to make, have made, use, offer to sell, sell, import,
-transfer and otherwise run, modify and propagate the contents of this
-implementation of Go, where such license applies only to those patent
-claims, both currently owned or controlled by Google and acquired in
-the future, licensable by Google that are necessarily infringed by this
-implementation of Go.  This grant does not include claims that would be
-infringed only as a consequence of further modification of this
-implementation.  If you or your agent or exclusive licensee institute or
-order or agree to the institution of patent litigation against any
-entity (including a cross-claim or counterclaim in a lawsuit) alleging
-that this implementation of Go or any code incorporated within this
-implementation of Go constitutes direct or contributory patent
-infringement, or inducement of patent infringement, then any patent
-rights granted to you under this License for this implementation of Go
-shall terminate as of the date such litigation is filed.

vendor/golang.org/x/exp/constraints/constraints.go

@@ -1,50 +0,0 @@
-// Copyright 2021 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package constraints defines a set of useful constraints to be used
-// with type parameters.
-package constraints
-
-// Signed is a constraint that permits any signed integer type.
-// If future releases of Go add new predeclared signed integer types,
-// this constraint will be modified to include them.
-type Signed interface {
-	~int | ~int8 | ~int16 | ~int32 | ~int64
-}
-
-// Unsigned is a constraint that permits any unsigned integer type.
-// If future releases of Go add new predeclared unsigned integer types,
-// this constraint will be modified to include them.
-type Unsigned interface {
-	~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr
-}
-
-// Integer is a constraint that permits any integer type.
-// If future releases of Go add new predeclared integer types,
-// this constraint will be modified to include them.
-type Integer interface {
-	Signed | Unsigned
-}
-
-// Float is a constraint that permits any floating-point type.
-// If future releases of Go add new predeclared floating-point types,
-// this constraint will be modified to include them.
-type Float interface {
-	~float32 | ~float64
-}
-
-// Complex is a constraint that permits any complex numeric type.
-// If future releases of Go add new predeclared complex numeric types,
-// this constraint will be modified to include them.
-type Complex interface {
-	~complex64 | ~complex128
-}
-
-// Ordered is a constraint that permits any ordered type: any type
-// that supports the operators < <= >= >.
-// If future releases of Go add new ordered types,
-// this constraint will be modified to include them.
-type Ordered interface {
-	Integer | Float | ~string
-}

vendor/golang.org/x/exp/maps/maps.go

@@ -1,94 +0,0 @@
-// Copyright 2021 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package maps defines various functions useful with maps of any type.
-package maps
-
-// Keys returns the keys of the map m.
-// The keys will be in an indeterminate order.
-func Keys[M ~map[K]V, K comparable, V any](m M) []K {
-	r := make([]K, 0, len(m))
-	for k := range m {
-		r = append(r, k)
-	}
-	return r
-}
-
-// Values returns the values of the map m.
-// The values will be in an indeterminate order.
-func Values[M ~map[K]V, K comparable, V any](m M) []V {
-	r := make([]V, 0, len(m))
-	for _, v := range m {
-		r = append(r, v)
-	}
-	return r
-}
-
-// Equal reports whether two maps contain the same key/value pairs.
-// Values are compared using ==.
-func Equal[M1, M2 ~map[K]V, K, V comparable](m1 M1, m2 M2) bool {
-	if len(m1) != len(m2) {
-		return false
-	}
-	for k, v1 := range m1 {
-		if v2, ok := m2[k]; !ok || v1 != v2 {
-			return false
-		}
-	}
-	return true
-}
-
-// EqualFunc is like Equal, but compares values using eq.
-// Keys are still compared with ==.
-func EqualFunc[M1 ~map[K]V1, M2 ~map[K]V2, K comparable, V1, V2 any](m1 M1, m2 M2, eq func(V1, V2) bool) bool {
-	if len(m1) != len(m2) {
-		return false
-	}
-	for k, v1 := range m1 {
-		if v2, ok := m2[k]; !ok || !eq(v1, v2) {
-			return false
-		}
-	}
-	return true
-}
-
-// Clear removes all entries from m, leaving it empty.
-func Clear[M ~map[K]V, K comparable, V any](m M) {
-	for k := range m {
-		delete(m, k)
-	}
-}
-
-// Clone returns a copy of m.  This is a shallow clone:
-// the new keys and values are set using ordinary assignment.
-func Clone[M ~map[K]V, K comparable, V any](m M) M {
-	// Preserve nil in case it matters.
-	if m == nil {
-		return nil
-	}
-	r := make(M, len(m))
-	for k, v := range m {
-		r[k] = v
-	}
-	return r
-}
-
-// Copy copies all key/value pairs in src adding them to dst.
-// When a key in src is already present in dst,
-// the value in dst will be overwritten by the value associated
-// with the key in src.
-func Copy[M1 ~map[K]V, M2 ~map[K]V, K comparable, V any](dst M1, src M2) {
-	for k, v := range src {
-		dst[k] = v
-	}
-}
-
-// DeleteFunc deletes any key/value pairs from m for which del returns true.
-func DeleteFunc[M ~map[K]V, K comparable, V any](m M, del func(K, V) bool) {
-	for k, v := range m {
-		if del(k, v) {
-			delete(m, k)
-		}
-	}
-}

vendor/golang.org/x/exp/slices/cmp.go

@@ -1,44 +0,0 @@
-// Copyright 2023 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package slices
-
-import "golang.org/x/exp/constraints"
-
-// min is a version of the predeclared function from the Go 1.21 release.
-func min[T constraints.Ordered](a, b T) T {
-	if a < b || isNaN(a) {
-		return a
-	}
-	return b
-}
-
-// max is a version of the predeclared function from the Go 1.21 release.
-func max[T constraints.Ordered](a, b T) T {
-	if a > b || isNaN(a) {
-		return a
-	}
-	return b
-}
-
-// cmpLess is a copy of cmp.Less from the Go 1.21 release.
-func cmpLess[T constraints.Ordered](x, y T) bool {
-	return (isNaN(x) && !isNaN(y)) || x < y
-}
-
-// cmpCompare is a copy of cmp.Compare from the Go 1.21 release.
-func cmpCompare[T constraints.Ordered](x, y T) int {
-	xNaN := isNaN(x)
-	yNaN := isNaN(y)
-	if xNaN && yNaN {
-		return 0
-	}
-	if xNaN || x < y {
-		return -1
-	}
-	if yNaN || x > y {
-		return +1
-	}
-	return 0
-}

vendor/golang.org/x/exp/slices/slices.go

@@ -1,499 +0,0 @@
-// Copyright 2021 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package slices defines various functions useful with slices of any type.
-package slices
-
-import (
-	"unsafe"
-
-	"golang.org/x/exp/constraints"
-)
-
-// Equal reports whether two slices are equal: the same length and all
-// elements equal. If the lengths are different, Equal returns false.
-// Otherwise, the elements are compared in increasing index order, and the
-// comparison stops at the first unequal pair.
-// Floating point NaNs are not considered equal.
-func Equal[S ~[]E, E comparable](s1, s2 S) bool {
-	if len(s1) != len(s2) {
-		return false
-	}
-	for i := range s1 {
-		if s1[i] != s2[i] {
-			return false
-		}
-	}
-	return true
-}
-
-// EqualFunc reports whether two slices are equal using an equality
-// function on each pair of elements. If the lengths are different,
-// EqualFunc returns false. Otherwise, the elements are compared in
-// increasing index order, and the comparison stops at the first index
-// for which eq returns false.
-func EqualFunc[S1 ~[]E1, S2 ~[]E2, E1, E2 any](s1 S1, s2 S2, eq func(E1, E2) bool) bool {
-	if len(s1) != len(s2) {
-		return false
-	}
-	for i, v1 := range s1 {
-		v2 := s2[i]
-		if !eq(v1, v2) {
-			return false
-		}
-	}
-	return true
-}
-
-// Compare compares the elements of s1 and s2, using [cmp.Compare] on each pair
-// of elements. The elements are compared sequentially, starting at index 0,
-// until one element is not equal to the other.
-// The result of comparing the first non-matching elements is returned.
-// If both slices are equal until one of them ends, the shorter slice is
-// considered less than the longer one.
-// The result is 0 if s1 == s2, -1 if s1 < s2, and +1 if s1 > s2.
-func Compare[S ~[]E, E constraints.Ordered](s1, s2 S) int {
-	for i, v1 := range s1 {
-		if i >= len(s2) {
-			return +1
-		}
-		v2 := s2[i]
-		if c := cmpCompare(v1, v2); c != 0 {
-			return c
-		}
-	}
-	if len(s1) < len(s2) {
-		return -1
-	}
-	return 0
-}
-
-// CompareFunc is like [Compare] but uses a custom comparison function on each
-// pair of elements.
-// The result is the first non-zero result of cmp; if cmp always
-// returns 0 the result is 0 if len(s1) == len(s2), -1 if len(s1) < len(s2),
-// and +1 if len(s1) > len(s2).
-func CompareFunc[S1 ~[]E1, S2 ~[]E2, E1, E2 any](s1 S1, s2 S2, cmp func(E1, E2) int) int {
-	for i, v1 := range s1 {
-		if i >= len(s2) {
-			return +1
-		}
-		v2 := s2[i]
-		if c := cmp(v1, v2); c != 0 {
-			return c
-		}
-	}
-	if len(s1) < len(s2) {
-		return -1
-	}
-	return 0
-}
-
-// Index returns the index of the first occurrence of v in s,
-// or -1 if not present.
-func Index[S ~[]E, E comparable](s S, v E) int {
-	for i := range s {
-		if v == s[i] {
-			return i
-		}
-	}
-	return -1
-}
-
-// IndexFunc returns the first index i satisfying f(s[i]),
-// or -1 if none do.
-func IndexFunc[S ~[]E, E any](s S, f func(E) bool) int {
-	for i := range s {
-		if f(s[i]) {
-			return i
-		}
-	}
-	return -1
-}
-
-// Contains reports whether v is present in s.
-func Contains[S ~[]E, E comparable](s S, v E) bool {
-	return Index(s, v) >= 0
-}
-
-// ContainsFunc reports whether at least one
-// element e of s satisfies f(e).
-func ContainsFunc[S ~[]E, E any](s S, f func(E) bool) bool {
-	return IndexFunc(s, f) >= 0
-}
-
-// Insert inserts the values v... into s at index i,
-// returning the modified slice.
-// The elements at s[i:] are shifted up to make room.
-// In the returned slice r, r[i] == v[0],
-// and r[i+len(v)] == value originally at r[i].
-// Insert panics if i is out of range.
-// This function is O(len(s) + len(v)).
-func Insert[S ~[]E, E any](s S, i int, v ...E) S {
-	m := len(v)
-	if m == 0 {
-		return s
-	}
-	n := len(s)
-	if i == n {
-		return append(s, v...)
-	}
-	if n+m > cap(s) {
-		// Use append rather than make so that we bump the size of
-		// the slice up to the next storage class.
-		// This is what Grow does but we don't call Grow because
-		// that might copy the values twice.
-		s2 := append(s[:i], make(S, n+m-i)...)
-		copy(s2[i:], v)
-		copy(s2[i+m:], s[i:])
-		return s2
-	}
-	s = s[:n+m]
-
-	// before:
-	// s: aaaaaaaabbbbccccccccdddd
-	//            ^   ^       ^   ^
-	//            i  i+m      n  n+m
-	// after:
-	// s: aaaaaaaavvvvbbbbcccccccc
-	//            ^   ^       ^   ^
-	//            i  i+m      n  n+m
-	//
-	// a are the values that don't move in s.
-	// v are the values copied in from v.
-	// b and c are the values from s that are shifted up in index.
-	// d are the values that get overwritten, never to be seen again.
-
-	if !overlaps(v, s[i+m:]) {
-		// Easy case - v does not overlap either the c or d regions.
-		// (It might be in some of a or b, or elsewhere entirely.)
-		// The data we copy up doesn't write to v at all, so just do it.
-
-		copy(s[i+m:], s[i:])
-
-		// Now we have
-		// s: aaaaaaaabbbbbbbbcccccccc
-		//            ^   ^       ^   ^
-		//            i  i+m      n  n+m
-		// Note the b values are duplicated.
-
-		copy(s[i:], v)
-
-		// Now we have
-		// s: aaaaaaaavvvvbbbbcccccccc
-		//            ^   ^       ^   ^
-		//            i  i+m      n  n+m
-		// That's the result we want.
-		return s
-	}
-
-	// The hard case - v overlaps c or d. We can't just shift up
-	// the data because we'd move or clobber the values we're trying
-	// to insert.
-	// So instead, write v on top of d, then rotate.
-	copy(s[n:], v)
-
-	// Now we have
-	// s: aaaaaaaabbbbccccccccvvvv
-	//            ^   ^       ^   ^
-	//            i  i+m      n  n+m
-
-	rotateRight(s[i:], m)
-
-	// Now we have
-	// s: aaaaaaaavvvvbbbbcccccccc
-	//            ^   ^       ^   ^
-	//            i  i+m      n  n+m
-	// That's the result we want.
-	return s
-}
-
-// Delete removes the elements s[i:j] from s, returning the modified slice.
-// Delete panics if s[i:j] is not a valid slice of s.
-// Delete is O(len(s)-j), so if many items must be deleted, it is better to
-// make a single call deleting them all together than to delete one at a time.
-// Delete might not modify the elements s[len(s)-(j-i):len(s)]. If those
-// elements contain pointers you might consider zeroing those elements so that
-// objects they reference can be garbage collected.
-func Delete[S ~[]E, E any](s S, i, j int) S {
-	_ = s[i:j] // bounds check
-
-	return append(s[:i], s[j:]...)
-}
-
-// DeleteFunc removes any elements from s for which del returns true,
-// returning the modified slice.
-// When DeleteFunc removes m elements, it might not modify the elements
-// s[len(s)-m:len(s)]. If those elements contain pointers you might consider
-// zeroing those elements so that objects they reference can be garbage
-// collected.
-func DeleteFunc[S ~[]E, E any](s S, del func(E) bool) S {
-	i := IndexFunc(s, del)
-	if i == -1 {
-		return s
-	}
-	// Don't start copying elements until we find one to delete.
-	for j := i + 1; j < len(s); j++ {
-		if v := s[j]; !del(v) {
-			s[i] = v
-			i++
-		}
-	}
-	return s[:i]
-}
-
-// Replace replaces the elements s[i:j] by the given v, and returns the
-// modified slice. Replace panics if s[i:j] is not a valid slice of s.
-func Replace[S ~[]E, E any](s S, i, j int, v ...E) S {
-	_ = s[i:j] // verify that i:j is a valid subslice
-
-	if i == j {
-		return Insert(s, i, v...)
-	}
-	if j == len(s) {
-		return append(s[:i], v...)
-	}
-
-	tot := len(s[:i]) + len(v) + len(s[j:])
-	if tot > cap(s) {
-		// Too big to fit, allocate and copy over.
-		s2 := append(s[:i], make(S, tot-i)...) // See Insert
-		copy(s2[i:], v)
-		copy(s2[i+len(v):], s[j:])
-		return s2
-	}
-
-	r := s[:tot]
-
-	if i+len(v) <= j {
-		// Easy, as v fits in the deleted portion.
-		copy(r[i:], v)
-		if i+len(v) != j {
-			copy(r[i+len(v):], s[j:])
-		}
-		return r
-	}
-
-	// We are expanding (v is bigger than j-i).
-	// The situation is something like this:
-	// (example has i=4,j=8,len(s)=16,len(v)=6)
-	// s: aaaaxxxxbbbbbbbbyy
-	//        ^   ^       ^ ^
-	//        i   j  len(s) tot
-	// a: prefix of s
-	// x: deleted range
-	// b: more of s
-	// y: area to expand into
-
-	if !overlaps(r[i+len(v):], v) {
-		// Easy, as v is not clobbered by the first copy.
-		copy(r[i+len(v):], s[j:])
-		copy(r[i:], v)
-		return r
-	}
-
-	// This is a situation where we don't have a single place to which
-	// we can copy v. Parts of it need to go to two different places.
-	// We want to copy the prefix of v into y and the suffix into x, then
-	// rotate |y| spots to the right.
-	//
-	//        v[2:]      v[:2]
-	//         |           |
-	// s: aaaavvvvbbbbbbbbvv
-	//        ^   ^       ^ ^
-	//        i   j  len(s) tot
-	//
-	// If either of those two destinations don't alias v, then we're good.
-	y := len(v) - (j - i) // length of y portion
-
-	if !overlaps(r[i:j], v) {
-		copy(r[i:j], v[y:])
-		copy(r[len(s):], v[:y])
-		rotateRight(r[i:], y)
-		return r
-	}
-	if !overlaps(r[len(s):], v) {
-		copy(r[len(s):], v[:y])
-		copy(r[i:j], v[y:])
-		rotateRight(r[i:], y)
-		return r
-	}
-
-	// Now we know that v overlaps both x and y.
-	// That means that the entirety of b is *inside* v.
-	// So we don't need to preserve b at all; instead we
-	// can copy v first, then copy the b part of v out of
-	// v to the right destination.
-	k := startIdx(v, s[j:])
-	copy(r[i:], v)
-	copy(r[i+len(v):], r[i+k:])
-	return r
-}
-
-// Clone returns a copy of the slice.
-// The elements are copied using assignment, so this is a shallow clone.
-func Clone[S ~[]E, E any](s S) S {
-	// Preserve nil in case it matters.
-	if s == nil {
-		return nil
-	}
-	return append(S([]E{}), s...)
-}
-
-// Compact replaces consecutive runs of equal elements with a single copy.
-// This is like the uniq command found on Unix.
-// Compact modifies the contents of the slice s and returns the modified slice,
-// which may have a smaller length.
-// When Compact discards m elements in total, it might not modify the elements
-// s[len(s)-m:len(s)]. If those elements contain pointers you might consider
-// zeroing those elements so that objects they reference can be garbage collected.
-func Compact[S ~[]E, E comparable](s S) S {
-	if len(s) < 2 {
-		return s
-	}
-	i := 1
-	for k := 1; k < len(s); k++ {
-		if s[k] != s[k-1] {
-			if i != k {
-				s[i] = s[k]
-			}
-			i++
-		}
-	}
-	return s[:i]
-}
-
-// CompactFunc is like [Compact] but uses an equality function to compare elements.
-// For runs of elements that compare equal, CompactFunc keeps the first one.
-func CompactFunc[S ~[]E, E any](s S, eq func(E, E) bool) S {
-	if len(s) < 2 {
-		return s
-	}
-	i := 1
-	for k := 1; k < len(s); k++ {
-		if !eq(s[k], s[k-1]) {
-			if i != k {
-				s[i] = s[k]
-			}
-			i++
-		}
-	}
-	return s[:i]
-}
-
-// Grow increases the slice's capacity, if necessary, to guarantee space for
-// another n elements. After Grow(n), at least n elements can be appended
-// to the slice without another allocation. If n is negative or too large to
-// allocate the memory, Grow panics.
-func Grow[S ~[]E, E any](s S, n int) S {
-	if n < 0 {
-		panic("cannot be negative")
-	}
-	if n -= cap(s) - len(s); n > 0 {
-		// TODO(https://go.dev/issue/53888): Make using []E instead of S
-		// to workaround a compiler bug where the runtime.growslice optimization
-		// does not take effect. Revert when the compiler is fixed.
-		s = append([]E(s)[:cap(s)], make([]E, n)...)[:len(s)]
-	}
-	return s
-}
-
-// Clip removes unused capacity from the slice, returning s[:len(s):len(s)].
-func Clip[S ~[]E, E any](s S) S {
-	return s[:len(s):len(s)]
-}
-
-// Rotation algorithm explanation:
-//
-// rotate left by 2
-// start with
-//   0123456789
-// split up like this
-//   01 234567 89
-// swap first 2 and last 2
-//   89 234567 01
-// join first parts
-//   89234567 01
-// recursively rotate first left part by 2
-//   23456789 01
-// join at the end
-//   2345678901
-//
-// rotate left by 8
-// start with
-//   0123456789
-// split up like this
-//   01 234567 89
-// swap first 2 and last 2
-//   89 234567 01
-// join last parts
-//   89 23456701
-// recursively rotate second part left by 6
-//   89 01234567
-// join at the end
-//   8901234567
-
-// TODO: There are other rotate algorithms.
-// This algorithm has the desirable property that it moves each element exactly twice.
-// The triple-reverse algorithm is simpler and more cache friendly, but takes more writes.
-// The follow-cycles algorithm can be 1-write but it is not very cache friendly.
-
-// rotateLeft rotates b left by n spaces.
-// s_final[i] = s_orig[i+r], wrapping around.
-func rotateLeft[E any](s []E, r int) {
-	for r != 0 && r != len(s) {
-		if r*2 <= len(s) {
-			swap(s[:r], s[len(s)-r:])
-			s = s[:len(s)-r]
-		} else {
-			swap(s[:len(s)-r], s[r:])
-			s, r = s[len(s)-r:], r*2-len(s)
-		}
-	}
-}
-func rotateRight[E any](s []E, r int) {
-	rotateLeft(s, len(s)-r)
-}
-
-// swap swaps the contents of x and y. x and y must be equal length and disjoint.
-func swap[E any](x, y []E) {
-	for i := 0; i < len(x); i++ {
-		x[i], y[i] = y[i], x[i]
-	}
-}
-
-// overlaps reports whether the memory ranges a[0:len(a)] and b[0:len(b)] overlap.
-func overlaps[E any](a, b []E) bool {
-	if len(a) == 0 || len(b) == 0 {
-		return false
-	}
-	elemSize := unsafe.Sizeof(a[0])
-	if elemSize == 0 {
-		return false
-	}
-	// TODO: use a runtime/unsafe facility once one becomes available. See issue 12445.
-	// Also see crypto/internal/alias/alias.go:AnyOverlap
-	return uintptr(unsafe.Pointer(&a[0])) <= uintptr(unsafe.Pointer(&b[len(b)-1]))+(elemSize-1) &&
-		uintptr(unsafe.Pointer(&b[0])) <= uintptr(unsafe.Pointer(&a[len(a)-1]))+(elemSize-1)
-}
-
-// startIdx returns the index in haystack where the needle starts.
-// prerequisite: the needle must be aliased entirely inside the haystack.
-func startIdx[E any](haystack, needle []E) int {
-	p := &needle[0]
-	for i := range haystack {
-		if p == &haystack[i] {
-			return i
-		}
-	}
-	// TODO: what if the overlap is by a non-integral number of Es?
-	panic("needle not found")
-}
-
-// Reverse reverses the elements of the slice in place.
-func Reverse[S ~[]E, E any](s S) {
-	for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 {
-		s[i], s[j] = s[j], s[i]
-	}
-}

vendor/golang.org/x/exp/slices/sort.go

@@ -1,195 +0,0 @@
-// Copyright 2022 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-//go:generate go run $GOROOT/src/sort/gen_sort_variants.go -exp
-
-package slices
-
-import (
-	"math/bits"
-
-	"golang.org/x/exp/constraints"
-)
-
-// Sort sorts a slice of any ordered type in ascending order.
-// When sorting floating-point numbers, NaNs are ordered before other values.
-func Sort[S ~[]E, E constraints.Ordered](x S) {
-	n := len(x)
-	pdqsortOrdered(x, 0, n, bits.Len(uint(n)))
-}
-
-// SortFunc sorts the slice x in ascending order as determined by the cmp
-// function. This sort is not guaranteed to be stable.
-// cmp(a, b) should return a negative number when a < b, a positive number when
-// a > b and zero when a == b.
-//
-// SortFunc requires that cmp is a strict weak ordering.
-// See https://en.wikipedia.org/wiki/Weak_ordering#Strict_weak_orderings.
-func SortFunc[S ~[]E, E any](x S, cmp func(a, b E) int) {
-	n := len(x)
-	pdqsortCmpFunc(x, 0, n, bits.Len(uint(n)), cmp)
-}
-
-// SortStableFunc sorts the slice x while keeping the original order of equal
-// elements, using cmp to compare elements in the same way as [SortFunc].
-func SortStableFunc[S ~[]E, E any](x S, cmp func(a, b E) int) {
-	stableCmpFunc(x, len(x), cmp)
-}
-
-// IsSorted reports whether x is sorted in ascending order.
-func IsSorted[S ~[]E, E constraints.Ordered](x S) bool {
-	for i := len(x) - 1; i > 0; i-- {
-		if cmpLess(x[i], x[i-1]) {
-			return false
-		}
-	}
-	return true
-}
-
-// IsSortedFunc reports whether x is sorted in ascending order, with cmp as the
-// comparison function as defined by [SortFunc].
-func IsSortedFunc[S ~[]E, E any](x S, cmp func(a, b E) int) bool {
-	for i := len(x) - 1; i > 0; i-- {
-		if cmp(x[i], x[i-1]) < 0 {
-			return false
-		}
-	}
-	return true
-}
-
-// Min returns the minimal value in x. It panics if x is empty.
-// For floating-point numbers, Min propagates NaNs (any NaN value in x
-// forces the output to be NaN).
-func Min[S ~[]E, E constraints.Ordered](x S) E {
-	if len(x) < 1 {
-		panic("slices.Min: empty list")
-	}
-	m := x[0]
-	for i := 1; i < len(x); i++ {
-		m = min(m, x[i])
-	}
-	return m
-}
-
-// MinFunc returns the minimal value in x, using cmp to compare elements.
-// It panics if x is empty. If there is more than one minimal element
-// according to the cmp function, MinFunc returns the first one.
-func MinFunc[S ~[]E, E any](x S, cmp func(a, b E) int) E {
-	if len(x) < 1 {
-		panic("slices.MinFunc: empty list")
-	}
-	m := x[0]
-	for i := 1; i < len(x); i++ {
-		if cmp(x[i], m) < 0 {
-			m = x[i]
-		}
-	}
-	return m
-}
-
-// Max returns the maximal value in x. It panics if x is empty.
-// For floating-point E, Max propagates NaNs (any NaN value in x
-// forces the output to be NaN).
-func Max[S ~[]E, E constraints.Ordered](x S) E {
-	if len(x) < 1 {
-		panic("slices.Max: empty list")
-	}
-	m := x[0]
-	for i := 1; i < len(x); i++ {
-		m = max(m, x[i])
-	}
-	return m
-}
-
-// MaxFunc returns the maximal value in x, using cmp to compare elements.
-// It panics if x is empty. If there is more than one maximal element
-// according to the cmp function, MaxFunc returns the first one.
-func MaxFunc[S ~[]E, E any](x S, cmp func(a, b E) int) E {
-	if len(x) < 1 {
-		panic("slices.MaxFunc: empty list")
-	}
-	m := x[0]
-	for i := 1; i < len(x); i++ {
-		if cmp(x[i], m) > 0 {
-			m = x[i]
-		}
-	}
-	return m
-}
-
-// BinarySearch searches for target in a sorted slice and returns the position
-// where target is found, or the position where target would appear in the
-// sort order; it also returns a bool saying whether the target is really found
-// in the slice. The slice must be sorted in increasing order.
-func BinarySearch[S ~[]E, E constraints.Ordered](x S, target E) (int, bool) {
-	// Inlining is faster than calling BinarySearchFunc with a lambda.
-	n := len(x)
-	// Define x[-1] < target and x[n] >= target.
-	// Invariant: x[i-1] < target, x[j] >= target.
-	i, j := 0, n
-	for i < j {
-		h := int(uint(i+j) >> 1) // avoid overflow when computing h
-		// i ≤ h < j
-		if cmpLess(x[h], target) {
-			i = h + 1 // preserves x[i-1] < target
-		} else {
-			j = h // preserves x[j] >= target
-		}
-	}
-	// i == j, x[i-1] < target, and x[j] (= x[i]) >= target  =>  answer is i.
-	return i, i < n && (x[i] == target || (isNaN(x[i]) && isNaN(target)))
-}
-
-// BinarySearchFunc works like [BinarySearch], but uses a custom comparison
-// function. The slice must be sorted in increasing order, where "increasing"
-// is defined by cmp. cmp should return 0 if the slice element matches
-// the target, a negative number if the slice element precedes the target,
-// or a positive number if the slice element follows the target.
-// cmp must implement the same ordering as the slice, such that if
-// cmp(a, t) < 0 and cmp(b, t) >= 0, then a must precede b in the slice.
-func BinarySearchFunc[S ~[]E, E, T any](x S, target T, cmp func(E, T) int) (int, bool) {
-	n := len(x)
-	// Define cmp(x[-1], target) < 0 and cmp(x[n], target) >= 0 .
-	// Invariant: cmp(x[i - 1], target) < 0, cmp(x[j], target) >= 0.
-	i, j := 0, n
-	for i < j {
-		h := int(uint(i+j) >> 1) // avoid overflow when computing h
-		// i ≤ h < j
-		if cmp(x[h], target) < 0 {
-			i = h + 1 // preserves cmp(x[i - 1], target) < 0
-		} else {
-			j = h // preserves cmp(x[j], target) >= 0
-		}
-	}
-	// i == j, cmp(x[i-1], target) < 0, and cmp(x[j], target) (= cmp(x[i], target)) >= 0  =>  answer is i.
-	return i, i < n && cmp(x[i], target) == 0
-}
-
-type sortedHint int // hint for pdqsort when choosing the pivot
-
-const (
-	unknownHint sortedHint = iota
-	increasingHint
-	decreasingHint
-)
-
-// xorshift paper: https://www.jstatsoft.org/article/view/v008i14/xorshift.pdf
-type xorshift uint64
-
-func (r *xorshift) Next() uint64 {
-	*r ^= *r << 13
-	*r ^= *r >> 17
-	*r ^= *r << 5
-	return uint64(*r)
-}
-
-func nextPowerOfTwo(length int) uint {
-	return 1 << bits.Len(uint(length))
-}
-
-// isNaN reports whether x is a NaN without requiring the math package.
-// This will always return false if T is not floating-point.
-func isNaN[T constraints.Ordered](x T) bool {
-	return x != x
-}

vendor/golang.org/x/exp/slices/zsortanyfunc.go

@@ -1,479 +0,0 @@
-// Code generated by gen_sort_variants.go; DO NOT EDIT.
-
-// Copyright 2022 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package slices
-
-// insertionSortCmpFunc sorts data[a:b] using insertion sort.
-func insertionSortCmpFunc[E any](data []E, a, b int, cmp func(a, b E) int) {
-	for i := a + 1; i < b; i++ {
-		for j := i; j > a && (cmp(data[j], data[j-1]) < 0); j-- {
-			data[j], data[j-1] = data[j-1], data[j]
-		}
-	}
-}
-
-// siftDownCmpFunc implements the heap property on data[lo:hi].
-// first is an offset into the array where the root of the heap lies.
-func siftDownCmpFunc[E any](data []E, lo, hi, first int, cmp func(a, b E) int) {
-	root := lo
-	for {
-		child := 2*root + 1
-		if child >= hi {
-			break
-		}
-		if child+1 < hi && (cmp(data[first+child], data[first+child+1]) < 0) {
-			child++
-		}
-		if !(cmp(data[first+root], data[first+child]) < 0) {
-			return
-		}
-		data[first+root], data[first+child] = data[first+child], data[first+root]
-		root = child
-	}
-}
-
-func heapSortCmpFunc[E any](data []E, a, b int, cmp func(a, b E) int) {
-	first := a
-	lo := 0
-	hi := b - a
-
-	// Build heap with greatest element at top.
-	for i := (hi - 1) / 2; i >= 0; i-- {
-		siftDownCmpFunc(data, i, hi, first, cmp)
-	}
-
-	// Pop elements, largest first, into end of data.
-	for i := hi - 1; i >= 0; i-- {
-		data[first], data[first+i] = data[first+i], data[first]
-		siftDownCmpFunc(data, lo, i, first, cmp)
-	}
-}
-
-// pdqsortCmpFunc sorts data[a:b].
-// The algorithm based on pattern-defeating quicksort(pdqsort), but without the optimizations from BlockQuicksort.
-// pdqsort paper: https://arxiv.org/pdf/2106.05123.pdf
-// C++ implementation: https://github.com/orlp/pdqsort
-// Rust implementation: https://docs.rs/pdqsort/latest/pdqsort/
-// limit is the number of allowed bad (very unbalanced) pivots before falling back to heapsort.
-func pdqsortCmpFunc[E any](data []E, a, b, limit int, cmp func(a, b E) int) {
-	const maxInsertion = 12
-
-	var (
-		wasBalanced    = true // whether the last partitioning was reasonably balanced
-		wasPartitioned = true // whether the slice was already partitioned
-	)
-
-	for {
-		length := b - a
-
-		if length <= maxInsertion {
-			insertionSortCmpFunc(data, a, b, cmp)
-			return
-		}
-
-		// Fall back to heapsort if too many bad choices were made.
-		if limit == 0 {
-			heapSortCmpFunc(data, a, b, cmp)
-			return
-		}
-
-		// If the last partitioning was imbalanced, we need to breaking patterns.
-		if !wasBalanced {
-			breakPatternsCmpFunc(data, a, b, cmp)
-			limit--
-		}
-
-		pivot, hint := choosePivotCmpFunc(data, a, b, cmp)
-		if hint == decreasingHint {
-			reverseRangeCmpFunc(data, a, b, cmp)
-			// The chosen pivot was pivot-a elements after the start of the array.
-			// After reversing it is pivot-a elements before the end of the array.
-			// The idea came from Rust's implementation.
-			pivot = (b - 1) - (pivot - a)
-			hint = increasingHint
-		}
-
-		// The slice is likely already sorted.
-		if wasBalanced && wasPartitioned && hint == increasingHint {
-			if partialInsertionSortCmpFunc(data, a, b, cmp) {
-				return
-			}
-		}
-
-		// Probably the slice contains many duplicate elements, partition the slice into
-		// elements equal to and elements greater than the pivot.
-		if a > 0 && !(cmp(data[a-1], data[pivot]) < 0) {
-			mid := partitionEqualCmpFunc(data, a, b, pivot, cmp)
-			a = mid
-			continue
-		}
-
-		mid, alreadyPartitioned := partitionCmpFunc(data, a, b, pivot, cmp)
-		wasPartitioned = alreadyPartitioned
-
-		leftLen, rightLen := mid-a, b-mid
-		balanceThreshold := length / 8
-		if leftLen < rightLen {
-			wasBalanced = leftLen >= balanceThreshold
-			pdqsortCmpFunc(data, a, mid, limit, cmp)
-			a = mid + 1
-		} else {
-			wasBalanced = rightLen >= balanceThreshold
-			pdqsortCmpFunc(data, mid+1, b, limit, cmp)
-			b = mid
-		}
-	}
-}
-
-// partitionCmpFunc does one quicksort partition.
-// Let p = data[pivot]
-// Moves elements in data[a:b] around, so that data[i]<p and data[j]>=p for i<newpivot and j>newpivot.
-// On return, data[newpivot] = p
-func partitionCmpFunc[E any](data []E, a, b, pivot int, cmp func(a, b E) int) (newpivot int, alreadyPartitioned bool) {
-	data[a], data[pivot] = data[pivot], data[a]
-	i, j := a+1, b-1 // i and j are inclusive of the elements remaining to be partitioned
-
-	for i <= j && (cmp(data[i], data[a]) < 0) {
-		i++
-	}
-	for i <= j && !(cmp(data[j], data[a]) < 0) {
-		j--
-	}
-	if i > j {
-		data[j], data[a] = data[a], data[j]
-		return j, true
-	}
-	data[i], data[j] = data[j], data[i]
-	i++
-	j--
-
-	for {
-		for i <= j && (cmp(data[i], data[a]) < 0) {
-			i++
-		}
-		for i <= j && !(cmp(data[j], data[a]) < 0) {
-			j--
-		}
-		if i > j {
-			break
-		}
-		data[i], data[j] = data[j], data[i]
-		i++
-		j--
-	}
-	data[j], data[a] = data[a], data[j]
-	return j, false
-}
-
-// partitionEqualCmpFunc partitions data[a:b] into elements equal to data[pivot] followed by elements greater than data[pivot].
-// It assumed that data[a:b] does not contain elements smaller than the data[pivot].
-func partitionEqualCmpFunc[E any](data []E, a, b, pivot int, cmp func(a, b E) int) (newpivot int) {
-	data[a], data[pivot] = data[pivot], data[a]
-	i, j := a+1, b-1 // i and j are inclusive of the elements remaining to be partitioned
-
-	for {
-		for i <= j && !(cmp(data[a], data[i]) < 0) {
-			i++
-		}
-		for i <= j && (cmp(data[a], data[j]) < 0) {
-			j--
-		}
-		if i > j {
-			break
-		}
-		data[i], data[j] = data[j], data[i]
-		i++
-		j--
-	}
-	return i
-}
-
-// partialInsertionSortCmpFunc partially sorts a slice, returns true if the slice is sorted at the end.
-func partialInsertionSortCmpFunc[E any](data []E, a, b int, cmp func(a, b E) int) bool {
-	const (
-		maxSteps         = 5  // maximum number of adjacent out-of-order pairs that will get shifted
-		shortestShifting = 50 // don't shift any elements on short arrays
-	)
-	i := a + 1
-	for j := 0; j < maxSteps; j++ {
-		for i < b && !(cmp(data[i], data[i-1]) < 0) {
-			i++
-		}
-
-		if i == b {
-			return true
-		}
-
-		if b-a < shortestShifting {
-			return false
-		}
-
-		data[i], data[i-1] = data[i-1], data[i]
-
-		// Shift the smaller one to the left.
-		if i-a >= 2 {
-			for j := i - 1; j >= 1; j-- {
-				if !(cmp(data[j], data[j-1]) < 0) {
-					break
-				}
-				data[j], data[j-1] = data[j-1], data[j]
-			}
-		}
-		// Shift the greater one to the right.
-		if b-i >= 2 {
-			for j := i + 1; j < b; j++ {
-				if !(cmp(data[j], data[j-1]) < 0) {
-					break
-				}
-				data[j], data[j-1] = data[j-1], data[j]
-			}
-		}
-	}
-	return false
-}
-
-// breakPatternsCmpFunc scatters some elements around in an attempt to break some patterns
-// that might cause imbalanced partitions in quicksort.
-func breakPatternsCmpFunc[E any](data []E, a, b int, cmp func(a, b E) int) {
-	length := b - a
-	if length >= 8 {
-		random := xorshift(length)
-		modulus := nextPowerOfTwo(length)
-
-		for idx := a + (length/4)*2 - 1; idx <= a+(length/4)*2+1; idx++ {
-			other := int(uint(random.Next()) & (modulus - 1))
-			if other >= length {
-				other -= length
-			}
-			data[idx], data[a+other] = data[a+other], data[idx]
-		}
-	}
-}
-
-// choosePivotCmpFunc chooses a pivot in data[a:b].
-//
-// [0,8): chooses a static pivot.
-// [8,shortestNinther): uses the simple median-of-three method.
-// [shortestNinther,∞): uses the Tukey ninther method.
-func choosePivotCmpFunc[E any](data []E, a, b int, cmp func(a, b E) int) (pivot int, hint sortedHint) {
-	const (
-		shortestNinther = 50
-		maxSwaps        = 4 * 3
-	)
-
-	l := b - a
-
-	var (
-		swaps int
-		i     = a + l/4*1
-		j     = a + l/4*2
-		k     = a + l/4*3
-	)
-
-	if l >= 8 {
-		if l >= shortestNinther {
-			// Tukey ninther method, the idea came from Rust's implementation.
-			i = medianAdjacentCmpFunc(data, i, &swaps, cmp)
-			j = medianAdjacentCmpFunc(data, j, &swaps, cmp)
-			k = medianAdjacentCmpFunc(data, k, &swaps, cmp)
-		}
-		// Find the median among i, j, k and stores it into j.
-		j = medianCmpFunc(data, i, j, k, &swaps, cmp)
-	}
-
-	switch swaps {
-	case 0:
-		return j, increasingHint
-	case maxSwaps:
-		return j, decreasingHint
-	default:
-		return j, unknownHint
-	}
-}
-
-// order2CmpFunc returns x,y where data[x] <= data[y], where x,y=a,b or x,y=b,a.
-func order2CmpFunc[E any](data []E, a, b int, swaps *int, cmp func(a, b E) int) (int, int) {
-	if cmp(data[b], data[a]) < 0 {
-		*swaps++
-		return b, a
-	}
-	return a, b
-}
-
-// medianCmpFunc returns x where data[x] is the median of data[a],data[b],data[c], where x is a, b, or c.
-func medianCmpFunc[E any](data []E, a, b, c int, swaps *int, cmp func(a, b E) int) int {
-	a, b = order2CmpFunc(data, a, b, swaps, cmp)
-	b, c = order2CmpFunc(data, b, c, swaps, cmp)
-	a, b = order2CmpFunc(data, a, b, swaps, cmp)
-	return b
-}
-
-// medianAdjacentCmpFunc finds the median of data[a - 1], data[a], data[a + 1] and stores the index into a.
-func medianAdjacentCmpFunc[E any](data []E, a int, swaps *int, cmp func(a, b E) int) int {
-	return medianCmpFunc(data, a-1, a, a+1, swaps, cmp)
-}
-
-func reverseRangeCmpFunc[E any](data []E, a, b int, cmp func(a, b E) int) {
-	i := a
-	j := b - 1
-	for i < j {
-		data[i], data[j] = data[j], data[i]
-		i++
-		j--
-	}
-}
-
-func swapRangeCmpFunc[E any](data []E, a, b, n int, cmp func(a, b E) int) {
-	for i := 0; i < n; i++ {
-		data[a+i], data[b+i] = data[b+i], data[a+i]
-	}
-}
-
-func stableCmpFunc[E any](data []E, n int, cmp func(a, b E) int) {
-	blockSize := 20 // must be > 0
-	a, b := 0, blockSize
-	for b <= n {
-		insertionSortCmpFunc(data, a, b, cmp)
-		a = b
-		b += blockSize
-	}
-	insertionSortCmpFunc(data, a, n, cmp)
-
-	for blockSize < n {
-		a, b = 0, 2*blockSize
-		for b <= n {
-			symMergeCmpFunc(data, a, a+blockSize, b, cmp)
-			a = b
-			b += 2 * blockSize
-		}
-		if m := a + blockSize; m < n {
-			symMergeCmpFunc(data, a, m, n, cmp)
-		}
-		blockSize *= 2
-	}
-}
-
-// symMergeCmpFunc merges the two sorted subsequences data[a:m] and data[m:b] using
-// the SymMerge algorithm from Pok-Son Kim and Arne Kutzner, "Stable Minimum
-// Storage Merging by Symmetric Comparisons", in Susanne Albers and Tomasz
-// Radzik, editors, Algorithms - ESA 2004, volume 3221 of Lecture Notes in
-// Computer Science, pages 714-723. Springer, 2004.
-//
-// Let M = m-a and N = b-n. Wolog M < N.
-// The recursion depth is bound by ceil(log(N+M)).
-// The algorithm needs O(M*log(N/M + 1)) calls to data.Less.
-// The algorithm needs O((M+N)*log(M)) calls to data.Swap.
-//
-// The paper gives O((M+N)*log(M)) as the number of assignments assuming a
-// rotation algorithm which uses O(M+N+gcd(M+N)) assignments. The argumentation
-// in the paper carries through for Swap operations, especially as the block
-// swapping rotate uses only O(M+N) Swaps.
-//
-// symMerge assumes non-degenerate arguments: a < m && m < b.
-// Having the caller check this condition eliminates many leaf recursion calls,
-// which improves performance.
-func symMergeCmpFunc[E any](data []E, a, m, b int, cmp func(a, b E) int) {
-	// Avoid unnecessary recursions of symMerge
-	// by direct insertion of data[a] into data[m:b]
-	// if data[a:m] only contains one element.
-	if m-a == 1 {
-		// Use binary search to find the lowest index i
-		// such that data[i] >= data[a] for m <= i < b.
-		// Exit the search loop with i == b in case no such index exists.
-		i := m
-		j := b
-		for i < j {
-			h := int(uint(i+j) >> 1)
-			if cmp(data[h], data[a]) < 0 {
-				i = h + 1
-			} else {
-				j = h
-			}
-		}
-		// Swap values until data[a] reaches the position before i.
-		for k := a; k < i-1; k++ {
-			data[k], data[k+1] = data[k+1], data[k]
-		}
-		return
-	}
-
-	// Avoid unnecessary recursions of symMerge
-	// by direct insertion of data[m] into data[a:m]
-	// if data[m:b] only contains one element.
-	if b-m == 1 {
-		// Use binary search to find the lowest index i
-		// such that data[i] > data[m] for a <= i < m.
-		// Exit the search loop with i == m in case no such index exists.
-		i := a
-		j := m
-		for i < j {
-			h := int(uint(i+j) >> 1)
-			if !(cmp(data[m], data[h]) < 0) {
-				i = h + 1
-			} else {
-				j = h
-			}
-		}
-		// Swap values until data[m] reaches the position i.
-		for k := m; k > i; k-- {
-			data[k], data[k-1] = data[k-1], data[k]
-		}
-		return
-	}
-
-	mid := int(uint(a+b) >> 1)
-	n := mid + m
-	var start, r int
-	if m > mid {
-		start = n - b
-		r = mid
-	} else {
-		start = a
-		r = m
-	}
-	p := n - 1
-
-	for start < r {
-		c := int(uint(start+r) >> 1)
-		if !(cmp(data[p-c], data[c]) < 0) {
-			start = c + 1
-		} else {
-			r = c
-		}
-	}
-
-	end := n - start
-	if start < m && m < end {
-		rotateCmpFunc(data, start, m, end, cmp)
-	}
-	if a < start && start < mid {
-		symMergeCmpFunc(data, a, start, mid, cmp)
-	}
-	if mid < end && end < b {
-		symMergeCmpFunc(data, mid, end, b, cmp)
-	}
-}
-
-// rotateCmpFunc rotates two consecutive blocks u = data[a:m] and v = data[m:b] in data:
-// Data of the form 'x u v y' is changed to 'x v u y'.
-// rotate performs at most b-a many calls to data.Swap,
-// and it assumes non-degenerate arguments: a < m && m < b.
-func rotateCmpFunc[E any](data []E, a, m, b int, cmp func(a, b E) int) {
-	i := m - a
-	j := b - m
-
-	for i != j {
-		if i > j {
-			swapRangeCmpFunc(data, m-i, m, j, cmp)
-			i -= j
-		} else {
-			swapRangeCmpFunc(data, m-i, m+j-i, i, cmp)
-			j -= i
-		}
-	}
-	// i == j
-	swapRangeCmpFunc(data, m-i, m, i, cmp)
-}

vendor/golang.org/x/exp/slices/zsortordered.go

@@ -1,481 +0,0 @@
-// Code generated by gen_sort_variants.go; DO NOT EDIT.
-
-// Copyright 2022 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package slices
-
-import "golang.org/x/exp/constraints"
-
-// insertionSortOrdered sorts data[a:b] using insertion sort.
-func insertionSortOrdered[E constraints.Ordered](data []E, a, b int) {
-	for i := a + 1; i < b; i++ {
-		for j := i; j > a && cmpLess(data[j], data[j-1]); j-- {
-			data[j], data[j-1] = data[j-1], data[j]
-		}
-	}
-}
-
-// siftDownOrdered implements the heap property on data[lo:hi].
-// first is an offset into the array where the root of the heap lies.
-func siftDownOrdered[E constraints.Ordered](data []E, lo, hi, first int) {
-	root := lo
-	for {
-		child := 2*root + 1
-		if child >= hi {
-			break
-		}
-		if child+1 < hi && cmpLess(data[first+child], data[first+child+1]) {
-			child++
-		}
-		if !cmpLess(data[first+root], data[first+child]) {
-			return
-		}
-		data[first+root], data[first+child] = data[first+child], data[first+root]
-		root = child
-	}
-}
-
-func heapSortOrdered[E constraints.Ordered](data []E, a, b int) {
-	first := a
-	lo := 0
-	hi := b - a
-
-	// Build heap with greatest element at top.
-	for i := (hi - 1) / 2; i >= 0; i-- {
-		siftDownOrdered(data, i, hi, first)
-	}
-
-	// Pop elements, largest first, into end of data.
-	for i := hi - 1; i >= 0; i-- {
-		data[first], data[first+i] = data[first+i], data[first]
-		siftDownOrdered(data, lo, i, first)
-	}
-}
-
-// pdqsortOrdered sorts data[a:b].
-// The algorithm based on pattern-defeating quicksort(pdqsort), but without the optimizations from BlockQuicksort.
-// pdqsort paper: https://arxiv.org/pdf/2106.05123.pdf
-// C++ implementation: https://github.com/orlp/pdqsort
-// Rust implementation: https://docs.rs/pdqsort/latest/pdqsort/
-// limit is the number of allowed bad (very unbalanced) pivots before falling back to heapsort.
-func pdqsortOrdered[E constraints.Ordered](data []E, a, b, limit int) {
-	const maxInsertion = 12
-
-	var (
-		wasBalanced    = true // whether the last partitioning was reasonably balanced
-		wasPartitioned = true // whether the slice was already partitioned
-	)
-
-	for {
-		length := b - a
-
-		if length <= maxInsertion {
-			insertionSortOrdered(data, a, b)
-			return
-		}
-
-		// Fall back to heapsort if too many bad choices were made.
-		if limit == 0 {
-			heapSortOrdered(data, a, b)
-			return
-		}
-
-		// If the last partitioning was imbalanced, we need to breaking patterns.
-		if !wasBalanced {
-			breakPatternsOrdered(data, a, b)
-			limit--
-		}
-
-		pivot, hint := choosePivotOrdered(data, a, b)
-		if hint == decreasingHint {
-			reverseRangeOrdered(data, a, b)
-			// The chosen pivot was pivot-a elements after the start of the array.
-			// After reversing it is pivot-a elements before the end of the array.
-			// The idea came from Rust's implementation.
-			pivot = (b - 1) - (pivot - a)
-			hint = increasingHint
-		}
-
-		// The slice is likely already sorted.
-		if wasBalanced && wasPartitioned && hint == increasingHint {
-			if partialInsertionSortOrdered(data, a, b) {
-				return
-			}
-		}
-
-		// Probably the slice contains many duplicate elements, partition the slice into
-		// elements equal to and elements greater than the pivot.
-		if a > 0 && !cmpLess(data[a-1], data[pivot]) {
-			mid := partitionEqualOrdered(data, a, b, pivot)
-			a = mid
-			continue
-		}
-
-		mid, alreadyPartitioned := partitionOrdered(data, a, b, pivot)
-		wasPartitioned = alreadyPartitioned
-
-		leftLen, rightLen := mid-a, b-mid
-		balanceThreshold := length / 8
-		if leftLen < rightLen {
-			wasBalanced = leftLen >= balanceThreshold
-			pdqsortOrdered(data, a, mid, limit)
-			a = mid + 1
-		} else {
-			wasBalanced = rightLen >= balanceThreshold
-			pdqsortOrdered(data, mid+1, b, limit)
-			b = mid
-		}
-	}
-}
-
-// partitionOrdered does one quicksort partition.
-// Let p = data[pivot]
-// Moves elements in data[a:b] around, so that data[i]<p and data[j]>=p for i<newpivot and j>newpivot.
-// On return, data[newpivot] = p
-func partitionOrdered[E constraints.Ordered](data []E, a, b, pivot int) (newpivot int, alreadyPartitioned bool) {
-	data[a], data[pivot] = data[pivot], data[a]
-	i, j := a+1, b-1 // i and j are inclusive of the elements remaining to be partitioned
-
-	for i <= j && cmpLess(data[i], data[a]) {
-		i++
-	}
-	for i <= j && !cmpLess(data[j], data[a]) {
-		j--
-	}
-	if i > j {
-		data[j], data[a] = data[a], data[j]
-		return j, true
-	}
-	data[i], data[j] = data[j], data[i]
-	i++
-	j--
-
-	for {
-		for i <= j && cmpLess(data[i], data[a]) {
-			i++
-		}
-		for i <= j && !cmpLess(data[j], data[a]) {
-			j--
-		}
-		if i > j {
-			break
-		}
-		data[i], data[j] = data[j], data[i]
-		i++
-		j--
-	}
-	data[j], data[a] = data[a], data[j]
-	return j, false
-}
-
-// partitionEqualOrdered partitions data[a:b] into elements equal to data[pivot] followed by elements greater than data[pivot].
-// It assumed that data[a:b] does not contain elements smaller than the data[pivot].
-func partitionEqualOrdered[E constraints.Ordered](data []E, a, b, pivot int) (newpivot int) {
-	data[a], data[pivot] = data[pivot], data[a]
-	i, j := a+1, b-1 // i and j are inclusive of the elements remaining to be partitioned
-
-	for {
-		for i <= j && !cmpLess(data[a], data[i]) {
-			i++
-		}
-		for i <= j && cmpLess(data[a], data[j]) {
-			j--
-		}
-		if i > j {
-			break
-		}
-		data[i], data[j] = data[j], data[i]
-		i++
-		j--
-	}
-	return i
-}
-
-// partialInsertionSortOrdered partially sorts a slice, returns true if the slice is sorted at the end.
-func partialInsertionSortOrdered[E constraints.Ordered](data []E, a, b int) bool {
-	const (
-		maxSteps         = 5  // maximum number of adjacent out-of-order pairs that will get shifted
-		shortestShifting = 50 // don't shift any elements on short arrays
-	)
-	i := a + 1
-	for j := 0; j < maxSteps; j++ {
-		for i < b && !cmpLess(data[i], data[i-1]) {
-			i++
-		}
-
-		if i == b {
-			return true
-		}
-
-		if b-a < shortestShifting {
-			return false
-		}
-
-		data[i], data[i-1] = data[i-1], data[i]
-
-		// Shift the smaller one to the left.
-		if i-a >= 2 {
-			for j := i - 1; j >= 1; j-- {
-				if !cmpLess(data[j], data[j-1]) {
-					break
-				}
-				data[j], data[j-1] = data[j-1], data[j]
-			}
-		}
-		// Shift the greater one to the right.
-		if b-i >= 2 {
-			for j := i + 1; j < b; j++ {
-				if !cmpLess(data[j], data[j-1]) {
-					break
-				}
-				data[j], data[j-1] = data[j-1], data[j]
-			}
-		}
-	}
-	return false
-}
-
-// breakPatternsOrdered scatters some elements around in an attempt to break some patterns
-// that might cause imbalanced partitions in quicksort.
-func breakPatternsOrdered[E constraints.Ordered](data []E, a, b int) {
-	length := b - a
-	if length >= 8 {
-		random := xorshift(length)
-		modulus := nextPowerOfTwo(length)
-
-		for idx := a + (length/4)*2 - 1; idx <= a+(length/4)*2+1; idx++ {
-			other := int(uint(random.Next()) & (modulus - 1))
-			if other >= length {
-				other -= length
-			}
-			data[idx], data[a+other] = data[a+other], data[idx]
-		}
-	}
-}
-
-// choosePivotOrdered chooses a pivot in data[a:b].
-//
-// [0,8): chooses a static pivot.
-// [8,shortestNinther): uses the simple median-of-three method.
-// [shortestNinther,∞): uses the Tukey ninther method.
-func choosePivotOrdered[E constraints.Ordered](data []E, a, b int) (pivot int, hint sortedHint) {
-	const (
-		shortestNinther = 50
-		maxSwaps        = 4 * 3
-	)
-
-	l := b - a
-
-	var (
-		swaps int
-		i     = a + l/4*1
-		j     = a + l/4*2
-		k     = a + l/4*3
-	)
-
-	if l >= 8 {
-		if l >= shortestNinther {
-			// Tukey ninther method, the idea came from Rust's implementation.
-			i = medianAdjacentOrdered(data, i, &swaps)
-			j = medianAdjacentOrdered(data, j, &swaps)
-			k = medianAdjacentOrdered(data, k, &swaps)
-		}
-		// Find the median among i, j, k and stores it into j.
-		j = medianOrdered(data, i, j, k, &swaps)
-	}
-
-	switch swaps {
-	case 0:
-		return j, increasingHint
-	case maxSwaps:
-		return j, decreasingHint
-	default:
-		return j, unknownHint
-	}
-}
-
-// order2Ordered returns x,y where data[x] <= data[y], where x,y=a,b or x,y=b,a.
-func order2Ordered[E constraints.Ordered](data []E, a, b int, swaps *int) (int, int) {
-	if cmpLess(data[b], data[a]) {
-		*swaps++
-		return b, a
-	}
-	return a, b
-}
-
-// medianOrdered returns x where data[x] is the median of data[a],data[b],data[c], where x is a, b, or c.
-func medianOrdered[E constraints.Ordered](data []E, a, b, c int, swaps *int) int {
-	a, b = order2Ordered(data, a, b, swaps)
-	b, c = order2Ordered(data, b, c, swaps)
-	a, b = order2Ordered(data, a, b, swaps)
-	return b
-}
-
-// medianAdjacentOrdered finds the median of data[a - 1], data[a], data[a + 1] and stores the index into a.
-func medianAdjacentOrdered[E constraints.Ordered](data []E, a int, swaps *int) int {
-	return medianOrdered(data, a-1, a, a+1, swaps)
-}
-
-func reverseRangeOrdered[E constraints.Ordered](data []E, a, b int) {
-	i := a
-	j := b - 1
-	for i < j {
-		data[i], data[j] = data[j], data[i]
-		i++
-		j--
-	}
-}
-
-func swapRangeOrdered[E constraints.Ordered](data []E, a, b, n int) {
-	for i := 0; i < n; i++ {
-		data[a+i], data[b+i] = data[b+i], data[a+i]
-	}
-}
-
-func stableOrdered[E constraints.Ordered](data []E, n int) {
-	blockSize := 20 // must be > 0
-	a, b := 0, blockSize
-	for b <= n {
-		insertionSortOrdered(data, a, b)
-		a = b
-		b += blockSize
-	}
-	insertionSortOrdered(data, a, n)
-
-	for blockSize < n {
-		a, b = 0, 2*blockSize
-		for b <= n {
-			symMergeOrdered(data, a, a+blockSize, b)
-			a = b
-			b += 2 * blockSize
-		}
-		if m := a + blockSize; m < n {
-			symMergeOrdered(data, a, m, n)
-		}
-		blockSize *= 2
-	}
-}
-
-// symMergeOrdered merges the two sorted subsequences data[a:m] and data[m:b] using
-// the SymMerge algorithm from Pok-Son Kim and Arne Kutzner, "Stable Minimum
-// Storage Merging by Symmetric Comparisons", in Susanne Albers and Tomasz
-// Radzik, editors, Algorithms - ESA 2004, volume 3221 of Lecture Notes in
-// Computer Science, pages 714-723. Springer, 2004.
-//
-// Let M = m-a and N = b-n. Wolog M < N.
-// The recursion depth is bound by ceil(log(N+M)).
-// The algorithm needs O(M*log(N/M + 1)) calls to data.Less.
-// The algorithm needs O((M+N)*log(M)) calls to data.Swap.
-//
-// The paper gives O((M+N)*log(M)) as the number of assignments assuming a
-// rotation algorithm which uses O(M+N+gcd(M+N)) assignments. The argumentation
-// in the paper carries through for Swap operations, especially as the block
-// swapping rotate uses only O(M+N) Swaps.
-//
-// symMerge assumes non-degenerate arguments: a < m && m < b.
-// Having the caller check this condition eliminates many leaf recursion calls,
-// which improves performance.
-func symMergeOrdered[E constraints.Ordered](data []E, a, m, b int) {
-	// Avoid unnecessary recursions of symMerge
-	// by direct insertion of data[a] into data[m:b]
-	// if data[a:m] only contains one element.
-	if m-a == 1 {
-		// Use binary search to find the lowest index i
-		// such that data[i] >= data[a] for m <= i < b.
-		// Exit the search loop with i == b in case no such index exists.
-		i := m
-		j := b
-		for i < j {
-			h := int(uint(i+j) >> 1)
-			if cmpLess(data[h], data[a]) {
-				i = h + 1
-			} else {
-				j = h
-			}
-		}
-		// Swap values until data[a] reaches the position before i.
-		for k := a; k < i-1; k++ {
-			data[k], data[k+1] = data[k+1], data[k]
-		}
-		return
-	}
-
-	// Avoid unnecessary recursions of symMerge
-	// by direct insertion of data[m] into data[a:m]
-	// if data[m:b] only contains one element.
-	if b-m == 1 {
-		// Use binary search to find the lowest index i
-		// such that data[i] > data[m] for a <= i < m.
-		// Exit the search loop with i == m in case no such index exists.
-		i := a
-		j := m
-		for i < j {
-			h := int(uint(i+j) >> 1)
-			if !cmpLess(data[m], data[h]) {
-				i = h + 1
-			} else {
-				j = h
-			}
-		}
-		// Swap values until data[m] reaches the position i.
-		for k := m; k > i; k-- {
-			data[k], data[k-1] = data[k-1], data[k]
-		}
-		return
-	}
-
-	mid := int(uint(a+b) >> 1)
-	n := mid + m
-	var start, r int
-	if m > mid {
-		start = n - b
-		r = mid
-	} else {
-		start = a
-		r = m
-	}
-	p := n - 1
-
-	for start < r {
-		c := int(uint(start+r) >> 1)
-		if !cmpLess(data[p-c], data[c]) {
-			start = c + 1
-		} else {
-			r = c
-		}
-	}
-
-	end := n - start
-	if start < m && m < end {
-		rotateOrdered(data, start, m, end)
-	}
-	if a < start && start < mid {
-		symMergeOrdered(data, a, start, mid)
-	}
-	if mid < end && end < b {
-		symMergeOrdered(data, mid, end, b)
-	}
-}
-
-// rotateOrdered rotates two consecutive blocks u = data[a:m] and v = data[m:b] in data:
-// Data of the form 'x u v y' is changed to 'x v u y'.
-// rotate performs at most b-a many calls to data.Swap,
-// and it assumes non-degenerate arguments: a < m && m < b.
-func rotateOrdered[E constraints.Ordered](data []E, a, m, b int) {
-	i := m - a
-	j := b - m
-
-	for i != j {
-		if i > j {
-			swapRangeOrdered(data, m-i, m, j)
-			i -= j
-		} else {
-			swapRangeOrdered(data, m-i, m+j-i, i)
-			j -= i
-		}
-	}
-	// i == j
-	swapRangeOrdered(data, m-i, m, i)
-}

vendor/golang.org/x/sys/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2009 The Go Authors. All rights reserved.
+Copyright 2009 The Go Authors.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are
@@ -10,7 +10,7 @@ notice, this list of conditions and the following disclaimer.
 copyright notice, this list of conditions and the following disclaimer
 in the documentation and/or other materials provided with the
 distribution.
-   * Neither the name of Google Inc. nor the names of its
+   * Neither the name of Google LLC nor the names of its
 contributors may be used to endorse or promote products derived from
 this software without specific prior written permission.
 

vendor/golang.org/x/sys/unix/README.md

@@ -156,7 +156,7 @@ from the generated architecture-specific files listed below, and merge these
 into a common file for each OS.
 
 The merge is performed in the following steps:
-1. Construct the set of common code that is idential in all architecture-specific files.
+1. Construct the set of common code that is identical in all architecture-specific files.
 2. Write this common code to the merged file.
 3. Remove the common code from all architecture-specific files.
 

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

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build (aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos) && go1.9
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos
 
 package unix
 

vendor/golang.org/x/sys/unix/asm_zos_s390x.s

@@ -9,9 +9,11 @@
 #define PSALAA            1208(R0)
 #define GTAB64(x)           80(x)
 #define LCA64(x)            88(x)
+#define SAVSTACK_ASYNC(x)  336(x) // in the LCA
 #define CAA(x)               8(x)
-#define EDCHPXV(x)        1016(x)       // in the CAA
-#define SAVSTACK_ASYNC(x)  336(x)       // in the LCA
+#define CEECAATHDID(x)     976(x) // in the CAA
+#define EDCHPXV(x)        1016(x) // in the CAA
+#define GOCB(x)           1104(x) // in the CAA
 
 // SS_*, where x=SAVSTACK_ASYNC
 #define SS_LE(x)             0(x)
@@ -19,394 +21,125 @@
 #define SS_ERRNO(x)         16(x)
 #define SS_ERRNOJR(x)       20(x)
 
-#define LE_CALL BYTE $0x0D; BYTE $0x76; // BL R7, R6
+// Function Descriptor Offsets
+#define __errno  0x156*16
+#define __err2ad 0x16C*16
 
-TEXT ·clearErrno(SB),NOSPLIT,$0-0
-	BL	addrerrno<>(SB)
-	MOVD	$0, 0(R3)
+// Call Instructions
+#define LE_CALL    BYTE $0x0D; BYTE $0x76 // BL R7, R6
+#define SVC_LOAD   BYTE $0x0A; BYTE $0x08 // SVC 08 LOAD
+#define SVC_DELETE BYTE $0x0A; BYTE $0x09 // SVC 09 DELETE
+
+DATA zosLibVec<>(SB)/8, $0
+GLOBL zosLibVec<>(SB), NOPTR, $8
+
+TEXT ·initZosLibVec(SB), NOSPLIT|NOFRAME, $0-0
+	MOVW PSALAA, R8
+	MOVD LCA64(R8), R8
+	MOVD CAA(R8), R8
+	MOVD EDCHPXV(R8), R8
+	MOVD R8, zosLibVec<>(SB)
+	RET
+
+TEXT ·GetZosLibVec(SB), NOSPLIT|NOFRAME, $0-0
+	MOVD zosLibVec<>(SB), R8
+	MOVD R8, ret+0(FP)
+	RET
+
+TEXT ·clearErrno(SB), NOSPLIT, $0-0
+	BL   addrerrno<>(SB)
+	MOVD $0, 0(R3)
 	RET
 
 // Returns the address of errno in R3.
-TEXT addrerrno<>(SB),NOSPLIT|NOFRAME,$0-0
+TEXT addrerrno<>(SB), NOSPLIT|NOFRAME, $0-0
 	// Get library control area (LCA).
-	MOVW	PSALAA, R8
-	MOVD	LCA64(R8), R8
+	MOVW PSALAA, R8
+	MOVD LCA64(R8), R8
 
 	// Get __errno FuncDesc.
-	MOVD	CAA(R8), R9
-	MOVD	EDCHPXV(R9), R9
-	ADD	$(0x156*16), R9
-	LMG	0(R9), R5, R6
+	MOVD CAA(R8), R9
+	MOVD EDCHPXV(R9), R9
+	ADD  $(__errno), R9
+	LMG  0(R9), R5, R6
 
 	// Switch to saved LE stack.
-	MOVD	SAVSTACK_ASYNC(R8), R9
-	MOVD	0(R9), R4
-	MOVD	$0, 0(R9)
+	MOVD SAVSTACK_ASYNC(R8), R9
+	MOVD 0(R9), R4
+	MOVD $0, 0(R9)
 
 	// Call __errno function.
 	LE_CALL
 	NOPH
 
 	// Switch back to Go stack.
-	XOR	R0, R0      // Restore R0 to $0.
-	MOVD	R4, 0(R9)   // Save stack pointer.
-	RET
-
-TEXT ·syscall_syscall(SB),NOSPLIT,$0-56
-	BL	runtime·entersyscall(SB)
-	MOVD	a1+8(FP), R1
-	MOVD	a2+16(FP), R2
-	MOVD	a3+24(FP), R3
-
-	// Get library control area (LCA).
-	MOVW	PSALAA, R8
-	MOVD	LCA64(R8), R8
-
-	// Get function.
-	MOVD	CAA(R8), R9
-	MOVD	EDCHPXV(R9), R9
-	MOVD	trap+0(FP), R5
-	SLD	$4, R5
-	ADD	R5, R9
-	LMG	0(R9), R5, R6
-
-	// Restore LE stack.
-	MOVD	SAVSTACK_ASYNC(R8), R9
-	MOVD	0(R9), R4
-	MOVD	$0, 0(R9)
-
-	// Call function.
-	LE_CALL
-	NOPH
-	XOR	R0, R0      // Restore R0 to $0.
-	MOVD	R4, 0(R9)   // Save stack pointer.
-
-	MOVD	R3, r1+32(FP)
-	MOVD	R0, r2+40(FP)
-	MOVD	R0, err+48(FP)
-	MOVW	R3, R4
-	CMP	R4, $-1
-	BNE	done
-	BL	addrerrno<>(SB)
-	MOVWZ	0(R3), R3
-	MOVD	R3, err+48(FP)
-done:
-	BL	runtime·exitsyscall(SB)
-	RET
-
-TEXT ·syscall_rawsyscall(SB),NOSPLIT,$0-56
-	MOVD	a1+8(FP), R1
-	MOVD	a2+16(FP), R2
-	MOVD	a3+24(FP), R3
-
-	// Get library control area (LCA).
-	MOVW	PSALAA, R8
-	MOVD	LCA64(R8), R8
-
-	// Get function.
-	MOVD	CAA(R8), R9
-	MOVD	EDCHPXV(R9), R9
-	MOVD	trap+0(FP), R5
-	SLD	$4, R5
-	ADD	R5, R9
-	LMG	0(R9), R5, R6
-
-	// Restore LE stack.
-	MOVD	SAVSTACK_ASYNC(R8), R9
-	MOVD	0(R9), R4
-	MOVD	$0, 0(R9)
-
-	// Call function.
-	LE_CALL
-	NOPH
-	XOR	R0, R0      // Restore R0 to $0.
-	MOVD	R4, 0(R9)   // Save stack pointer.
-
-	MOVD	R3, r1+32(FP)
-	MOVD	R0, r2+40(FP)
-	MOVD	R0, err+48(FP)
-	MOVW	R3, R4
-	CMP	R4, $-1
-	BNE	done
-	BL	addrerrno<>(SB)
-	MOVWZ	0(R3), R3
-	MOVD	R3, err+48(FP)
-done:
-	RET
-
-TEXT ·syscall_syscall6(SB),NOSPLIT,$0-80
-	BL	runtime·entersyscall(SB)
-	MOVD	a1+8(FP), R1
-	MOVD	a2+16(FP), R2
-	MOVD	a3+24(FP), R3
-
-	// Get library control area (LCA).
-	MOVW	PSALAA, R8
-	MOVD	LCA64(R8), R8
-
-	// Get function.
-	MOVD	CAA(R8), R9
-	MOVD	EDCHPXV(R9), R9
-	MOVD	trap+0(FP), R5
-	SLD	$4, R5
-	ADD	R5, R9
-	LMG	0(R9), R5, R6
-
-	// Restore LE stack.
-	MOVD	SAVSTACK_ASYNC(R8), R9
-	MOVD	0(R9), R4
-	MOVD	$0, 0(R9)
-
-	// Fill in parameter list.
-	MOVD	a4+32(FP), R12
-	MOVD	R12, (2176+24)(R4)
-	MOVD	a5+40(FP), R12
-	MOVD	R12, (2176+32)(R4)
-	MOVD	a6+48(FP), R12
-	MOVD	R12, (2176+40)(R4)
-
-	// Call function.
-	LE_CALL
-	NOPH
-	XOR	R0, R0      // Restore R0 to $0.
-	MOVD	R4, 0(R9)   // Save stack pointer.
-
-	MOVD	R3, r1+56(FP)
-	MOVD	R0, r2+64(FP)
-	MOVD	R0, err+72(FP)
-	MOVW	R3, R4
-	CMP	R4, $-1
-	BNE	done
-	BL	addrerrno<>(SB)
-	MOVWZ	0(R3), R3
-	MOVD	R3, err+72(FP)
-done:
-	BL	runtime·exitsyscall(SB)
-	RET
-
-TEXT ·syscall_rawsyscall6(SB),NOSPLIT,$0-80
-	MOVD	a1+8(FP), R1
-	MOVD	a2+16(FP), R2
-	MOVD	a3+24(FP), R3
-
-	// Get library control area (LCA).
-	MOVW	PSALAA, R8
-	MOVD	LCA64(R8), R8
-
-	// Get function.
-	MOVD	CAA(R8), R9
-	MOVD	EDCHPXV(R9), R9
-	MOVD	trap+0(FP), R5
-	SLD	$4, R5
-	ADD	R5, R9
-	LMG	0(R9), R5, R6
-
-	// Restore LE stack.
-	MOVD	SAVSTACK_ASYNC(R8), R9
-	MOVD	0(R9), R4
-	MOVD	$0, 0(R9)
-
-	// Fill in parameter list.
-	MOVD	a4+32(FP), R12
-	MOVD	R12, (2176+24)(R4)
-	MOVD	a5+40(FP), R12
-	MOVD	R12, (2176+32)(R4)
-	MOVD	a6+48(FP), R12
-	MOVD	R12, (2176+40)(R4)
-
-	// Call function.
-	LE_CALL
-	NOPH
-	XOR	R0, R0      // Restore R0 to $0.
-	MOVD	R4, 0(R9)   // Save stack pointer.
-
-	MOVD	R3, r1+56(FP)
-	MOVD	R0, r2+64(FP)
-	MOVD	R0, err+72(FP)
-	MOVW	R3, R4
-	CMP	R4, $-1
-	BNE	done
-	BL	·rrno<>(SB)
-	MOVWZ	0(R3), R3
-	MOVD	R3, err+72(FP)
-done:
-	RET
-
-TEXT ·syscall_syscall9(SB),NOSPLIT,$0
-	BL	runtime·entersyscall(SB)
-	MOVD	a1+8(FP), R1
-	MOVD	a2+16(FP), R2
-	MOVD	a3+24(FP), R3
-
-	// Get library control area (LCA).
-	MOVW	PSALAA, R8
-	MOVD	LCA64(R8), R8
-
-	// Get function.
-	MOVD	CAA(R8), R9
-	MOVD	EDCHPXV(R9), R9
-	MOVD	trap+0(FP), R5
-	SLD	$4, R5
-	ADD	R5, R9
-	LMG	0(R9), R5, R6
-
-	// Restore LE stack.
-	MOVD	SAVSTACK_ASYNC(R8), R9
-	MOVD	0(R9), R4
-	MOVD	$0, 0(R9)
-
-	// Fill in parameter list.
-	MOVD	a4+32(FP), R12
-	MOVD	R12, (2176+24)(R4)
-	MOVD	a5+40(FP), R12
-	MOVD	R12, (2176+32)(R4)
-	MOVD	a6+48(FP), R12
-	MOVD	R12, (2176+40)(R4)
-	MOVD	a7+56(FP), R12
-	MOVD	R12, (2176+48)(R4)
-	MOVD	a8+64(FP), R12
-	MOVD	R12, (2176+56)(R4)
-	MOVD	a9+72(FP), R12
-	MOVD	R12, (2176+64)(R4)
-
-	// Call function.
-	LE_CALL
-	NOPH
-	XOR	R0, R0      // Restore R0 to $0.
-	MOVD	R4, 0(R9)   // Save stack pointer.
-
-	MOVD	R3, r1+80(FP)
-	MOVD	R0, r2+88(FP)
-	MOVD	R0, err+96(FP)
-	MOVW	R3, R4
-	CMP	R4, $-1
-	BNE	done
-	BL	addrerrno<>(SB)
-	MOVWZ	0(R3), R3
-	MOVD	R3, err+96(FP)
-done:
-        BL	runtime·exitsyscall(SB)
-        RET
-
-TEXT ·syscall_rawsyscall9(SB),NOSPLIT,$0
-	MOVD	a1+8(FP), R1
-	MOVD	a2+16(FP), R2
-	MOVD	a3+24(FP), R3
-
-	// Get library control area (LCA).
-	MOVW	PSALAA, R8
-	MOVD	LCA64(R8), R8
-
-	// Get function.
-	MOVD	CAA(R8), R9
-	MOVD	EDCHPXV(R9), R9
-	MOVD	trap+0(FP), R5
-	SLD	$4, R5
-	ADD	R5, R9
-	LMG	0(R9), R5, R6
-
-	// Restore LE stack.
-	MOVD	SAVSTACK_ASYNC(R8), R9
-	MOVD	0(R9), R4
-	MOVD	$0, 0(R9)
-
-	// Fill in parameter list.
-	MOVD	a4+32(FP), R12
-	MOVD	R12, (2176+24)(R4)
-	MOVD	a5+40(FP), R12
-	MOVD	R12, (2176+32)(R4)
-	MOVD	a6+48(FP), R12
-	MOVD	R12, (2176+40)(R4)
-	MOVD	a7+56(FP), R12
-	MOVD	R12, (2176+48)(R4)
-	MOVD	a8+64(FP), R12
-	MOVD	R12, (2176+56)(R4)
-	MOVD	a9+72(FP), R12
-	MOVD	R12, (2176+64)(R4)
-
-	// Call function.
-	LE_CALL
-	NOPH
-	XOR	R0, R0      // Restore R0 to $0.
-	MOVD	R4, 0(R9)   // Save stack pointer.
-
-	MOVD	R3, r1+80(FP)
-	MOVD	R0, r2+88(FP)
-	MOVD	R0, err+96(FP)
-	MOVW	R3, R4
-	CMP	R4, $-1
-	BNE	done
-	BL	addrerrno<>(SB)
-	MOVWZ	0(R3), R3
-	MOVD	R3, err+96(FP)
-done:
+	XOR  R0, R0    // Restore R0 to $0.
+	MOVD R4, 0(R9) // Save stack pointer.
 	RET
 
 // func svcCall(fnptr unsafe.Pointer, argv *unsafe.Pointer, dsa *uint64)
-TEXT ·svcCall(SB),NOSPLIT,$0
-	BL	runtime·save_g(SB)   // Save g and stack pointer
-	MOVW	PSALAA, R8
-	MOVD	LCA64(R8), R8
-	MOVD	SAVSTACK_ASYNC(R8), R9
-	MOVD	R15, 0(R9)
+TEXT ·svcCall(SB), NOSPLIT, $0
+	BL   runtime·save_g(SB)     // Save g and stack pointer
+	MOVW PSALAA, R8
+	MOVD LCA64(R8), R8
+	MOVD SAVSTACK_ASYNC(R8), R9
+	MOVD R15, 0(R9)
 
-	MOVD	argv+8(FP), R1       // Move function arguments into registers
-	MOVD	dsa+16(FP), g
-	MOVD	fnptr+0(FP), R15
+	MOVD argv+8(FP), R1   // Move function arguments into registers
+	MOVD dsa+16(FP), g
+	MOVD fnptr+0(FP), R15
 
-	BYTE	$0x0D                // Branch to function
-	BYTE	$0xEF
+	BYTE $0x0D // Branch to function
+	BYTE $0xEF
 
-	BL	runtime·load_g(SB)   // Restore g and stack pointer
-	MOVW	PSALAA, R8
-	MOVD	LCA64(R8), R8
-	MOVD	SAVSTACK_ASYNC(R8), R9
-	MOVD	0(R9), R15
+	BL   runtime·load_g(SB)     // Restore g and stack pointer
+	MOVW PSALAA, R8
+	MOVD LCA64(R8), R8
+	MOVD SAVSTACK_ASYNC(R8), R9
+	MOVD 0(R9), R15
 
 	RET
 
 // func svcLoad(name *byte) unsafe.Pointer
-TEXT ·svcLoad(SB),NOSPLIT,$0
-	MOVD	R15, R2          // Save go stack pointer
-	MOVD	name+0(FP), R0   // Move SVC args into registers
-	MOVD	$0x80000000, R1
-	MOVD	$0, R15
-	BYTE	$0x0A            // SVC 08 LOAD
-	BYTE	$0x08
-	MOVW	R15, R3          // Save return code from SVC
-	MOVD	R2, R15          // Restore go stack pointer
-	CMP	R3, $0           // Check SVC return code
-	BNE	error
+TEXT ·svcLoad(SB), NOSPLIT, $0
+	MOVD R15, R2         // Save go stack pointer
+	MOVD name+0(FP), R0  // Move SVC args into registers
+	MOVD $0x80000000, R1
+	MOVD $0, R15
+	SVC_LOAD
+	MOVW R15, R3         // Save return code from SVC
+	MOVD R2, R15         // Restore go stack pointer
+	CMP  R3, $0          // Check SVC return code
+	BNE  error
 
-	MOVD	$-2, R3          // Reset last bit of entry point to zero
-	AND	R0, R3
-	MOVD	R3, addr+8(FP)   // Return entry point returned by SVC
-	CMP	R0, R3           // Check if last bit of entry point was set
-	BNE	done
+	MOVD $-2, R3       // Reset last bit of entry point to zero
+	AND  R0, R3
+	MOVD R3, ret+8(FP) // Return entry point returned by SVC
+	CMP  R0, R3        // Check if last bit of entry point was set
+	BNE  done
 
-	MOVD	R15, R2          // Save go stack pointer
-	MOVD	$0, R15          // Move SVC args into registers (entry point still in r0 from SVC 08)
-	BYTE	$0x0A            // SVC 09 DELETE
-	BYTE	$0x09
-	MOVD	R2, R15          // Restore go stack pointer
+	MOVD R15, R2 // Save go stack pointer
+	MOVD $0, R15 // Move SVC args into registers (entry point still in r0 from SVC 08)
+	SVC_DELETE
+	MOVD R2, R15 // Restore go stack pointer
 
 error:
-	MOVD	$0, addr+8(FP)   // Return 0 on failure
+	MOVD $0, ret+8(FP) // Return 0 on failure
+
 done:
-	XOR	R0, R0           // Reset r0 to 0
+	XOR R0, R0 // Reset r0 to 0
 	RET
 
 // func svcUnload(name *byte, fnptr unsafe.Pointer) int64
-TEXT ·svcUnload(SB),NOSPLIT,$0
-	MOVD	R15, R2          // Save go stack pointer
-	MOVD	name+0(FP), R0   // Move SVC args into registers
-	MOVD	addr+8(FP), R15
-	BYTE	$0x0A            // SVC 09
-	BYTE	$0x09
-	XOR	R0, R0           // Reset r0 to 0
-	MOVD	R15, R1          // Save SVC return code
-	MOVD	R2, R15          // Restore go stack pointer
-	MOVD	R1, rc+0(FP)     // Return SVC return code
+TEXT ·svcUnload(SB), NOSPLIT, $0
+	MOVD R15, R2          // Save go stack pointer
+	MOVD name+0(FP), R0   // Move SVC args into registers
+	MOVD fnptr+8(FP), R15
+	SVC_DELETE
+	XOR  R0, R0           // Reset r0 to 0
+	MOVD R15, R1          // Save SVC return code
+	MOVD R2, R15          // Restore go stack pointer
+	MOVD R1, ret+16(FP)   // Return SVC return code
 	RET
 
 // func gettid() uint64
@@ -417,7 +150,233 @@ TEXT ·gettid(SB), NOSPLIT, $0
 
 	// Get CEECAATHDID
 	MOVD CAA(R8), R9
-	MOVD 0x3D0(R9), R9
+	MOVD CEECAATHDID(R9), R9
 	MOVD R9, ret+0(FP)
 
 	RET
+
+//
+// Call LE function, if the return is -1
+// errno and errno2 is retrieved
+//
+TEXT ·CallLeFuncWithErr(SB), NOSPLIT, $0
+	MOVW PSALAA, R8
+	MOVD LCA64(R8), R8
+	MOVD CAA(R8), R9
+	MOVD g, GOCB(R9)
+
+	// Restore LE stack.
+	MOVD SAVSTACK_ASYNC(R8), R9 // R9-> LE stack frame saving address
+	MOVD 0(R9), R4              // R4-> restore previously saved stack frame pointer
+
+	MOVD parms_base+8(FP), R7 // R7 -> argument array
+	MOVD parms_len+16(FP), R8 // R8 number of arguments
+
+	//  arg 1 ---> R1
+	CMP  R8, $0
+	BEQ  docall
+	SUB  $1, R8
+	MOVD 0(R7), R1
+
+	//  arg 2 ---> R2
+	CMP  R8, $0
+	BEQ  docall
+	SUB  $1, R8
+	ADD  $8, R7
+	MOVD 0(R7), R2
+
+	//  arg 3 --> R3
+	CMP  R8, $0
+	BEQ  docall
+	SUB  $1, R8
+	ADD  $8, R7
+	MOVD 0(R7), R3
+
+	CMP  R8, $0
+	BEQ  docall
+	MOVD $2176+16, R6 // starting LE stack address-8 to store 4th argument
+
+repeat:
+	ADD  $8, R7
+	MOVD 0(R7), R0      // advance arg pointer by 8 byte
+	ADD  $8, R6         // advance LE argument address by 8 byte
+	MOVD R0, (R4)(R6*1) // copy argument from go-slice to le-frame
+	SUB  $1, R8
+	CMP  R8, $0
+	BNE  repeat
+
+docall:
+	MOVD funcdesc+0(FP), R8 // R8-> function descriptor
+	LMG  0(R8), R5, R6
+	MOVD $0, 0(R9)          // R9 address of SAVSTACK_ASYNC
+	LE_CALL                 // balr R7, R6 (return #1)
+	NOPH
+	MOVD R3, ret+32(FP)
+	CMP  R3, $-1            // compare result to -1
+	BNE  done
+
+	// retrieve errno and errno2
+	MOVD  zosLibVec<>(SB), R8
+	ADD   $(__errno), R8
+	LMG   0(R8), R5, R6
+	LE_CALL                   // balr R7, R6 __errno (return #3)
+	NOPH
+	MOVWZ 0(R3), R3
+	MOVD  R3, err+48(FP)
+	MOVD  zosLibVec<>(SB), R8
+	ADD   $(__err2ad), R8
+	LMG   0(R8), R5, R6
+	LE_CALL                   // balr R7, R6 __err2ad (return #2)
+	NOPH
+	MOVW  (R3), R2            // retrieve errno2
+	MOVD  R2, errno2+40(FP)   // store in return area
+
+done:
+	MOVD R4, 0(R9)            // Save stack pointer.
+	RET
+
+//
+// Call LE function, if the return is 0
+// errno and errno2 is retrieved
+//
+TEXT ·CallLeFuncWithPtrReturn(SB), NOSPLIT, $0
+	MOVW PSALAA, R8
+	MOVD LCA64(R8), R8
+	MOVD CAA(R8), R9
+	MOVD g, GOCB(R9)
+
+	// Restore LE stack.
+	MOVD SAVSTACK_ASYNC(R8), R9 // R9-> LE stack frame saving address
+	MOVD 0(R9), R4              // R4-> restore previously saved stack frame pointer
+
+	MOVD parms_base+8(FP), R7 // R7 -> argument array
+	MOVD parms_len+16(FP), R8 // R8 number of arguments
+
+	//  arg 1 ---> R1
+	CMP  R8, $0
+	BEQ  docall
+	SUB  $1, R8
+	MOVD 0(R7), R1
+
+	//  arg 2 ---> R2
+	CMP  R8, $0
+	BEQ  docall
+	SUB  $1, R8
+	ADD  $8, R7
+	MOVD 0(R7), R2
+
+	//  arg 3 --> R3
+	CMP  R8, $0
+	BEQ  docall
+	SUB  $1, R8
+	ADD  $8, R7
+	MOVD 0(R7), R3
+
+	CMP  R8, $0
+	BEQ  docall
+	MOVD $2176+16, R6 // starting LE stack address-8 to store 4th argument
+
+repeat:
+	ADD  $8, R7
+	MOVD 0(R7), R0      // advance arg pointer by 8 byte
+	ADD  $8, R6         // advance LE argument address by 8 byte
+	MOVD R0, (R4)(R6*1) // copy argument from go-slice to le-frame
+	SUB  $1, R8
+	CMP  R8, $0
+	BNE  repeat
+
+docall:
+	MOVD funcdesc+0(FP), R8 // R8-> function descriptor
+	LMG  0(R8), R5, R6
+	MOVD $0, 0(R9)          // R9 address of SAVSTACK_ASYNC
+	LE_CALL                 // balr R7, R6 (return #1)
+	NOPH
+	MOVD R3, ret+32(FP)
+	CMP  R3, $0             // compare result to 0
+	BNE  done
+
+	// retrieve errno and errno2
+	MOVD  zosLibVec<>(SB), R8
+	ADD   $(__errno), R8
+	LMG   0(R8), R5, R6
+	LE_CALL                   // balr R7, R6 __errno (return #3)
+	NOPH
+	MOVWZ 0(R3), R3
+	MOVD  R3, err+48(FP)
+	MOVD  zosLibVec<>(SB), R8
+	ADD   $(__err2ad), R8
+	LMG   0(R8), R5, R6
+	LE_CALL                   // balr R7, R6 __err2ad (return #2)
+	NOPH
+	MOVW  (R3), R2            // retrieve errno2
+	MOVD  R2, errno2+40(FP)   // store in return area
+	XOR   R2, R2
+	MOVWZ R2, (R3)            // clear errno2
+
+done:
+	MOVD R4, 0(R9)            // Save stack pointer.
+	RET
+
+//
+// function to test if a pointer can be safely dereferenced (content read)
+// return 0 for succces
+//
+TEXT ·ptrtest(SB), NOSPLIT, $0-16
+	MOVD arg+0(FP), R10 // test pointer in R10
+
+	// set up R2 to point to CEECAADMC
+	BYTE $0xE3; BYTE $0x20; BYTE $0x04; BYTE $0xB8; BYTE $0x00; BYTE $0x17 // llgt  2,1208
+	BYTE $0xB9; BYTE $0x17; BYTE $0x00; BYTE $0x22                         // llgtr 2,2
+	BYTE $0xA5; BYTE $0x26; BYTE $0x7F; BYTE $0xFF                         // nilh  2,32767
+	BYTE $0xE3; BYTE $0x22; BYTE $0x00; BYTE $0x58; BYTE $0x00; BYTE $0x04 // lg    2,88(2)
+	BYTE $0xE3; BYTE $0x22; BYTE $0x00; BYTE $0x08; BYTE $0x00; BYTE $0x04 // lg    2,8(2)
+	BYTE $0x41; BYTE $0x22; BYTE $0x03; BYTE $0x68                         // la    2,872(2)
+
+	// set up R5 to point to the "shunt" path which set 1 to R3 (failure)
+	BYTE $0xB9; BYTE $0x82; BYTE $0x00; BYTE $0x33 // xgr   3,3
+	BYTE $0xA7; BYTE $0x55; BYTE $0x00; BYTE $0x04 // bras  5,lbl1
+	BYTE $0xA7; BYTE $0x39; BYTE $0x00; BYTE $0x01 // lghi  3,1
+
+	// if r3 is not zero (failed) then branch to finish
+	BYTE $0xB9; BYTE $0x02; BYTE $0x00; BYTE $0x33 // lbl1     ltgr  3,3
+	BYTE $0xA7; BYTE $0x74; BYTE $0x00; BYTE $0x08 // brc   b'0111',lbl2
+
+	// stomic store shunt address in R5 into CEECAADMC
+	BYTE $0xE3; BYTE $0x52; BYTE $0x00; BYTE $0x00; BYTE $0x00; BYTE $0x24 // stg   5,0(2)
+
+	// now try reading from the test pointer in R10, if it fails it branches to the "lghi" instruction above
+	BYTE $0xE3; BYTE $0x9A; BYTE $0x00; BYTE $0x00; BYTE $0x00; BYTE $0x04 // lg    9,0(10)
+
+	// finish here, restore 0 into CEECAADMC
+	BYTE $0xB9; BYTE $0x82; BYTE $0x00; BYTE $0x99                         // lbl2     xgr   9,9
+	BYTE $0xE3; BYTE $0x92; BYTE $0x00; BYTE $0x00; BYTE $0x00; BYTE $0x24 // stg   9,0(2)
+	MOVD R3, ret+8(FP)                                                     // result in R3
+	RET
+
+//
+// function to test if a untptr can be loaded from a pointer
+// return 1: the 8-byte content
+//        2: 0 for success, 1 for failure
+//
+// func safeload(ptr uintptr) ( value uintptr, error uintptr)
+TEXT ·safeload(SB), NOSPLIT, $0-24
+	MOVD ptr+0(FP), R10                                                    // test pointer in R10
+	MOVD $0x0, R6
+	BYTE $0xE3; BYTE $0x20; BYTE $0x04; BYTE $0xB8; BYTE $0x00; BYTE $0x17 // llgt  2,1208
+	BYTE $0xB9; BYTE $0x17; BYTE $0x00; BYTE $0x22                         // llgtr 2,2
+	BYTE $0xA5; BYTE $0x26; BYTE $0x7F; BYTE $0xFF                         // nilh  2,32767
+	BYTE $0xE3; BYTE $0x22; BYTE $0x00; BYTE $0x58; BYTE $0x00; BYTE $0x04 // lg    2,88(2)
+	BYTE $0xE3; BYTE $0x22; BYTE $0x00; BYTE $0x08; BYTE $0x00; BYTE $0x04 // lg    2,8(2)
+	BYTE $0x41; BYTE $0x22; BYTE $0x03; BYTE $0x68                         // la    2,872(2)
+	BYTE $0xB9; BYTE $0x82; BYTE $0x00; BYTE $0x33                         // xgr   3,3
+	BYTE $0xA7; BYTE $0x55; BYTE $0x00; BYTE $0x04                         // bras  5,lbl1
+	BYTE $0xA7; BYTE $0x39; BYTE $0x00; BYTE $0x01                         // lghi  3,1
+	BYTE $0xB9; BYTE $0x02; BYTE $0x00; BYTE $0x33                         // lbl1     ltgr  3,3
+	BYTE $0xA7; BYTE $0x74; BYTE $0x00; BYTE $0x08                         // brc   b'0111',lbl2
+	BYTE $0xE3; BYTE $0x52; BYTE $0x00; BYTE $0x00; BYTE $0x00; BYTE $0x24 // stg 5,0(2)
+	BYTE $0xE3; BYTE $0x6A; BYTE $0x00; BYTE $0x00; BYTE $0x00; BYTE $0x04 // lg    6,0(10)
+	BYTE $0xB9; BYTE $0x82; BYTE $0x00; BYTE $0x99                         // lbl2     xgr   9,9
+	BYTE $0xE3; BYTE $0x92; BYTE $0x00; BYTE $0x00; BYTE $0x00; BYTE $0x24 // stg   9,0(2)
+	MOVD R6, value+8(FP)                                                   // result in R6
+	MOVD R3, error+16(FP)                                                  // error in R3
+	RET

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

@@ -0,0 +1,36 @@
+// Copyright 2025 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build go1.21 && (aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos)
+
+package unix
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+//go:linkname runtime_getAuxv runtime.getAuxv
+func runtime_getAuxv() []uintptr
+
+// Auxv returns the ELF auxiliary vector as a sequence of key/value pairs.
+// The returned slice is always a fresh copy, owned by the caller.
+// It returns an error on non-ELF platforms, or if the auxiliary vector cannot be accessed,
+// which happens in some locked-down environments and build modes.
+func Auxv() ([][2]uintptr, error) {
+	vec := runtime_getAuxv()
+	vecLen := len(vec)
+
+	if vecLen == 0 {
+		return nil, syscall.ENOENT
+	}
+
+	if vecLen%2 != 0 {
+		return nil, syscall.EINVAL
+	}
+
+	result := make([]uintptr, vecLen)
+	copy(result, vec)
+	return unsafe.Slice((*[2]uintptr)(unsafe.Pointer(&result[0])), vecLen/2), nil
+}

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

@@ -0,0 +1,13 @@
+// Copyright 2025 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build !go1.21 && (aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos)
+
+package unix
+
+import "syscall"
+
+func Auxv() ([][2]uintptr, error) {
+	return nil, syscall.ENOTSUP
+}

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

@@ -0,0 +1,657 @@
+// Copyright 2024 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build zos
+
+package unix
+
+import (
+	"bytes"
+	"fmt"
+	"unsafe"
+)
+
+//go:noescape
+func bpxcall(plist []unsafe.Pointer, bpx_offset int64)
+
+//go:noescape
+func A2e([]byte)
+
+//go:noescape
+func E2a([]byte)
+
+const (
+	BPX4STA = 192  // stat
+	BPX4FST = 104  // fstat
+	BPX4LST = 132  // lstat
+	BPX4OPN = 156  // open
+	BPX4CLO = 72   // close
+	BPX4CHR = 500  // chattr
+	BPX4FCR = 504  // fchattr
+	BPX4LCR = 1180 // lchattr
+	BPX4CTW = 492  // cond_timed_wait
+	BPX4GTH = 1056 // __getthent
+	BPX4PTQ = 412  // pthread_quiesc
+	BPX4PTR = 320  // ptrace
+)
+
+const (
+	//options
+	//byte1
+	BPX_OPNFHIGH = 0x80
+	//byte2
+	BPX_OPNFEXEC = 0x80
+	//byte3
+	BPX_O_NOLARGEFILE = 0x08
+	BPX_O_LARGEFILE   = 0x04
+	BPX_O_ASYNCSIG    = 0x02
+	BPX_O_SYNC        = 0x01
+	//byte4
+	BPX_O_CREXCL   = 0xc0
+	BPX_O_CREAT    = 0x80
+	BPX_O_EXCL     = 0x40
+	BPX_O_NOCTTY   = 0x20
+	BPX_O_TRUNC    = 0x10
+	BPX_O_APPEND   = 0x08
+	BPX_O_NONBLOCK = 0x04
+	BPX_FNDELAY    = 0x04
+	BPX_O_RDWR     = 0x03
+	BPX_O_RDONLY   = 0x02
+	BPX_O_WRONLY   = 0x01
+	BPX_O_ACCMODE  = 0x03
+	BPX_O_GETFL    = 0x0f
+
+	//mode
+	// byte1 (file type)
+	BPX_FT_DIR      = 1
+	BPX_FT_CHARSPEC = 2
+	BPX_FT_REGFILE  = 3
+	BPX_FT_FIFO     = 4
+	BPX_FT_SYMLINK  = 5
+	BPX_FT_SOCKET   = 6
+	//byte3
+	BPX_S_ISUID  = 0x08
+	BPX_S_ISGID  = 0x04
+	BPX_S_ISVTX  = 0x02
+	BPX_S_IRWXU1 = 0x01
+	BPX_S_IRUSR  = 0x01
+	//byte4
+	BPX_S_IRWXU2 = 0xc0
+	BPX_S_IWUSR  = 0x80
+	BPX_S_IXUSR  = 0x40
+	BPX_S_IRWXG  = 0x38
+	BPX_S_IRGRP  = 0x20
+	BPX_S_IWGRP  = 0x10
+	BPX_S_IXGRP  = 0x08
+	BPX_S_IRWXOX = 0x07
+	BPX_S_IROTH  = 0x04
+	BPX_S_IWOTH  = 0x02
+	BPX_S_IXOTH  = 0x01
+
+	CW_INTRPT  = 1
+	CW_CONDVAR = 32
+	CW_TIMEOUT = 64
+
+	PGTHA_NEXT        = 2
+	PGTHA_CURRENT     = 1
+	PGTHA_FIRST       = 0
+	PGTHA_LAST        = 3
+	PGTHA_PROCESS     = 0x80
+	PGTHA_CONTTY      = 0x40
+	PGTHA_PATH        = 0x20
+	PGTHA_COMMAND     = 0x10
+	PGTHA_FILEDATA    = 0x08
+	PGTHA_THREAD      = 0x04
+	PGTHA_PTAG        = 0x02
+	PGTHA_COMMANDLONG = 0x01
+	PGTHA_THREADFAST  = 0x80
+	PGTHA_FILEPATH    = 0x40
+	PGTHA_THDSIGMASK  = 0x20
+	// thread quiece mode
+	QUIESCE_TERM       int32 = 1
+	QUIESCE_FORCE      int32 = 2
+	QUIESCE_QUERY      int32 = 3
+	QUIESCE_FREEZE     int32 = 4
+	QUIESCE_UNFREEZE   int32 = 5
+	FREEZE_THIS_THREAD int32 = 6
+	FREEZE_EXIT        int32 = 8
+	QUIESCE_SRB        int32 = 9
+)
+
+type Pgtha struct {
+	Pid        uint32 // 0
+	Tid0       uint32 // 4
+	Tid1       uint32
+	Accesspid  byte    // C
+	Accesstid  byte    // D
+	Accessasid uint16  // E
+	Loginname  [8]byte // 10
+	Flag1      byte    // 18
+	Flag1b2    byte    // 19
+}
+
+type Bpxystat_t struct { // DSECT BPXYSTAT
+	St_id           [4]uint8  // 0
+	St_length       uint16    // 0x4
+	St_version      uint16    // 0x6
+	St_mode         uint32    // 0x8
+	St_ino          uint32    // 0xc
+	St_dev          uint32    // 0x10
+	St_nlink        uint32    // 0x14
+	St_uid          uint32    // 0x18
+	St_gid          uint32    // 0x1c
+	St_size         uint64    // 0x20
+	St_atime        uint32    // 0x28
+	St_mtime        uint32    // 0x2c
+	St_ctime        uint32    // 0x30
+	St_rdev         uint32    // 0x34
+	St_auditoraudit uint32    // 0x38
+	St_useraudit    uint32    // 0x3c
+	St_blksize      uint32    // 0x40
+	St_createtime   uint32    // 0x44
+	St_auditid      [4]uint32 // 0x48
+	St_res01        uint32    // 0x58
+	Ft_ccsid        uint16    // 0x5c
+	Ft_flags        uint16    // 0x5e
+	St_res01a       [2]uint32 // 0x60
+	St_res02        uint32    // 0x68
+	St_blocks       uint32    // 0x6c
+	St_opaque       [3]uint8  // 0x70
+	St_visible      uint8     // 0x73
+	St_reftime      uint32    // 0x74
+	St_fid          uint64    // 0x78
+	St_filefmt      uint8     // 0x80
+	St_fspflag2     uint8     // 0x81
+	St_res03        [2]uint8  // 0x82
+	St_ctimemsec    uint32    // 0x84
+	St_seclabel     [8]uint8  // 0x88
+	St_res04        [4]uint8  // 0x90
+	// end of version 1
+	_               uint32    // 0x94
+	St_atime64      uint64    // 0x98
+	St_mtime64      uint64    // 0xa0
+	St_ctime64      uint64    // 0xa8
+	St_createtime64 uint64    // 0xb0
+	St_reftime64    uint64    // 0xb8
+	_               uint64    // 0xc0
+	St_res05        [16]uint8 // 0xc8
+	// end of version 2
+}
+
+type BpxFilestatus struct {
+	Oflag1 byte
+	Oflag2 byte
+	Oflag3 byte
+	Oflag4 byte
+}
+
+type BpxMode struct {
+	Ftype byte
+	Mode1 byte
+	Mode2 byte
+	Mode3 byte
+}
+
+// Thr attribute structure for extended attributes
+type Bpxyatt_t struct { // DSECT BPXYATT
+	Att_id           [4]uint8
+	Att_version      uint16
+	Att_res01        [2]uint8
+	Att_setflags1    uint8
+	Att_setflags2    uint8
+	Att_setflags3    uint8
+	Att_setflags4    uint8
+	Att_mode         uint32
+	Att_uid          uint32
+	Att_gid          uint32
+	Att_opaquemask   [3]uint8
+	Att_visblmaskres uint8
+	Att_opaque       [3]uint8
+	Att_visibleres   uint8
+	Att_size_h       uint32
+	Att_size_l       uint32
+	Att_atime        uint32
+	Att_mtime        uint32
+	Att_auditoraudit uint32
+	Att_useraudit    uint32
+	Att_ctime        uint32
+	Att_reftime      uint32
+	// end of version 1
+	Att_filefmt uint8
+	Att_res02   [3]uint8
+	Att_filetag uint32
+	Att_res03   [8]uint8
+	// end of version 2
+	Att_atime64   uint64
+	Att_mtime64   uint64
+	Att_ctime64   uint64
+	Att_reftime64 uint64
+	Att_seclabel  [8]uint8
+	Att_ver3res02 [8]uint8
+	// end of version 3
+}
+
+func BpxOpen(name string, options *BpxFilestatus, mode *BpxMode) (rv int32, rc int32, rn int32) {
+	if len(name) < 1024 {
+		var namebuf [1024]byte
+		sz := int32(copy(namebuf[:], name))
+		A2e(namebuf[:sz])
+		var parms [7]unsafe.Pointer
+		parms[0] = unsafe.Pointer(&sz)
+		parms[1] = unsafe.Pointer(&namebuf[0])
+		parms[2] = unsafe.Pointer(options)
+		parms[3] = unsafe.Pointer(mode)
+		parms[4] = unsafe.Pointer(&rv)
+		parms[5] = unsafe.Pointer(&rc)
+		parms[6] = unsafe.Pointer(&rn)
+		bpxcall(parms[:], BPX4OPN)
+		return rv, rc, rn
+	}
+	return -1, -1, -1
+}
+
+func BpxClose(fd int32) (rv int32, rc int32, rn int32) {
+	var parms [4]unsafe.Pointer
+	parms[0] = unsafe.Pointer(&fd)
+	parms[1] = unsafe.Pointer(&rv)
+	parms[2] = unsafe.Pointer(&rc)
+	parms[3] = unsafe.Pointer(&rn)
+	bpxcall(parms[:], BPX4CLO)
+	return rv, rc, rn
+}
+
+func BpxFileFStat(fd int32, st *Bpxystat_t) (rv int32, rc int32, rn int32) {
+	st.St_id = [4]uint8{0xe2, 0xe3, 0xc1, 0xe3}
+	st.St_version = 2
+	stat_sz := uint32(unsafe.Sizeof(*st))
+	var parms [6]unsafe.Pointer
+	parms[0] = unsafe.Pointer(&fd)
+	parms[1] = unsafe.Pointer(&stat_sz)
+	parms[2] = unsafe.Pointer(st)
+	parms[3] = unsafe.Pointer(&rv)
+	parms[4] = unsafe.Pointer(&rc)
+	parms[5] = unsafe.Pointer(&rn)
+	bpxcall(parms[:], BPX4FST)
+	return rv, rc, rn
+}
+
+func BpxFileStat(name string, st *Bpxystat_t) (rv int32, rc int32, rn int32) {
+	if len(name) < 1024 {
+		var namebuf [1024]byte
+		sz := int32(copy(namebuf[:], name))
+		A2e(namebuf[:sz])
+		st.St_id = [4]uint8{0xe2, 0xe3, 0xc1, 0xe3}
+		st.St_version = 2
+		stat_sz := uint32(unsafe.Sizeof(*st))
+		var parms [7]unsafe.Pointer
+		parms[0] = unsafe.Pointer(&sz)
+		parms[1] = unsafe.Pointer(&namebuf[0])
+		parms[2] = unsafe.Pointer(&stat_sz)
+		parms[3] = unsafe.Pointer(st)
+		parms[4] = unsafe.Pointer(&rv)
+		parms[5] = unsafe.Pointer(&rc)
+		parms[6] = unsafe.Pointer(&rn)
+		bpxcall(parms[:], BPX4STA)
+		return rv, rc, rn
+	}
+	return -1, -1, -1
+}
+
+func BpxFileLStat(name string, st *Bpxystat_t) (rv int32, rc int32, rn int32) {
+	if len(name) < 1024 {
+		var namebuf [1024]byte
+		sz := int32(copy(namebuf[:], name))
+		A2e(namebuf[:sz])
+		st.St_id = [4]uint8{0xe2, 0xe3, 0xc1, 0xe3}
+		st.St_version = 2
+		stat_sz := uint32(unsafe.Sizeof(*st))
+		var parms [7]unsafe.Pointer
+		parms[0] = unsafe.Pointer(&sz)
+		parms[1] = unsafe.Pointer(&namebuf[0])
+		parms[2] = unsafe.Pointer(&stat_sz)
+		parms[3] = unsafe.Pointer(st)
+		parms[4] = unsafe.Pointer(&rv)
+		parms[5] = unsafe.Pointer(&rc)
+		parms[6] = unsafe.Pointer(&rn)
+		bpxcall(parms[:], BPX4LST)
+		return rv, rc, rn
+	}
+	return -1, -1, -1
+}
+
+func BpxChattr(path string, attr *Bpxyatt_t) (rv int32, rc int32, rn int32) {
+	if len(path) >= 1024 {
+		return -1, -1, -1
+	}
+	var namebuf [1024]byte
+	sz := int32(copy(namebuf[:], path))
+	A2e(namebuf[:sz])
+	attr_sz := uint32(unsafe.Sizeof(*attr))
+	var parms [7]unsafe.Pointer
+	parms[0] = unsafe.Pointer(&sz)
+	parms[1] = unsafe.Pointer(&namebuf[0])
+	parms[2] = unsafe.Pointer(&attr_sz)
+	parms[3] = unsafe.Pointer(attr)
+	parms[4] = unsafe.Pointer(&rv)
+	parms[5] = unsafe.Pointer(&rc)
+	parms[6] = unsafe.Pointer(&rn)
+	bpxcall(parms[:], BPX4CHR)
+	return rv, rc, rn
+}
+
+func BpxLchattr(path string, attr *Bpxyatt_t) (rv int32, rc int32, rn int32) {
+	if len(path) >= 1024 {
+		return -1, -1, -1
+	}
+	var namebuf [1024]byte
+	sz := int32(copy(namebuf[:], path))
+	A2e(namebuf[:sz])
+	attr_sz := uint32(unsafe.Sizeof(*attr))
+	var parms [7]unsafe.Pointer
+	parms[0] = unsafe.Pointer(&sz)
+	parms[1] = unsafe.Pointer(&namebuf[0])
+	parms[2] = unsafe.Pointer(&attr_sz)
+	parms[3] = unsafe.Pointer(attr)
+	parms[4] = unsafe.Pointer(&rv)
+	parms[5] = unsafe.Pointer(&rc)
+	parms[6] = unsafe.Pointer(&rn)
+	bpxcall(parms[:], BPX4LCR)
+	return rv, rc, rn
+}
+
+func BpxFchattr(fd int32, attr *Bpxyatt_t) (rv int32, rc int32, rn int32) {
+	attr_sz := uint32(unsafe.Sizeof(*attr))
+	var parms [6]unsafe.Pointer
+	parms[0] = unsafe.Pointer(&fd)
+	parms[1] = unsafe.Pointer(&attr_sz)
+	parms[2] = unsafe.Pointer(attr)
+	parms[3] = unsafe.Pointer(&rv)
+	parms[4] = unsafe.Pointer(&rc)
+	parms[5] = unsafe.Pointer(&rn)
+	bpxcall(parms[:], BPX4FCR)
+	return rv, rc, rn
+}
+
+func BpxCondTimedWait(sec uint32, nsec uint32, events uint32, secrem *uint32, nsecrem *uint32) (rv int32, rc int32, rn int32) {
+	var parms [8]unsafe.Pointer
+	parms[0] = unsafe.Pointer(&sec)
+	parms[1] = unsafe.Pointer(&nsec)
+	parms[2] = unsafe.Pointer(&events)
+	parms[3] = unsafe.Pointer(secrem)
+	parms[4] = unsafe.Pointer(nsecrem)
+	parms[5] = unsafe.Pointer(&rv)
+	parms[6] = unsafe.Pointer(&rc)
+	parms[7] = unsafe.Pointer(&rn)
+	bpxcall(parms[:], BPX4CTW)
+	return rv, rc, rn
+}
+func BpxGetthent(in *Pgtha, outlen *uint32, out unsafe.Pointer) (rv int32, rc int32, rn int32) {
+	var parms [7]unsafe.Pointer
+	inlen := uint32(26) // nothing else will work. Go says Pgtha is 28-byte because of alignment, but Pgtha is "packed" and must be 26-byte
+	parms[0] = unsafe.Pointer(&inlen)
+	parms[1] = unsafe.Pointer(&in)
+	parms[2] = unsafe.Pointer(outlen)
+	parms[3] = unsafe.Pointer(&out)
+	parms[4] = unsafe.Pointer(&rv)
+	parms[5] = unsafe.Pointer(&rc)
+	parms[6] = unsafe.Pointer(&rn)
+	bpxcall(parms[:], BPX4GTH)
+	return rv, rc, rn
+}
+func ZosJobname() (jobname string, err error) {
+	var pgtha Pgtha
+	pgtha.Pid = uint32(Getpid())
+	pgtha.Accesspid = PGTHA_CURRENT
+	pgtha.Flag1 = PGTHA_PROCESS
+	var out [256]byte
+	var outlen uint32
+	outlen = 256
+	rv, rc, rn := BpxGetthent(&pgtha, &outlen, unsafe.Pointer(&out[0]))
+	if rv == 0 {
+		gthc := []byte{0x87, 0xa3, 0x88, 0x83} // 'gthc' in ebcdic
+		ix := bytes.Index(out[:], gthc)
+		if ix == -1 {
+			err = fmt.Errorf("BPX4GTH: gthc return data not found")
+			return
+		}
+		jn := out[ix+80 : ix+88] // we didn't declare Pgthc, but jobname is 8-byte at offset 80
+		E2a(jn)
+		jobname = string(bytes.TrimRight(jn, " "))
+
+	} else {
+		err = fmt.Errorf("BPX4GTH: rc=%d errno=%d reason=code=0x%x", rv, rc, rn)
+	}
+	return
+}
+func Bpx4ptq(code int32, data string) (rv int32, rc int32, rn int32) {
+	var userdata [8]byte
+	var parms [5]unsafe.Pointer
+	copy(userdata[:], data+"        ")
+	A2e(userdata[:])
+	parms[0] = unsafe.Pointer(&code)
+	parms[1] = unsafe.Pointer(&userdata[0])
+	parms[2] = unsafe.Pointer(&rv)
+	parms[3] = unsafe.Pointer(&rc)
+	parms[4] = unsafe.Pointer(&rn)
+	bpxcall(parms[:], BPX4PTQ)
+	return rv, rc, rn
+}
+
+const (
+	PT_TRACE_ME             = 0  // Debug this process
+	PT_READ_I               = 1  // Read a full word
+	PT_READ_D               = 2  // Read a full word
+	PT_READ_U               = 3  // Read control info
+	PT_WRITE_I              = 4  //Write a full word
+	PT_WRITE_D              = 5  //Write a full word
+	PT_CONTINUE             = 7  //Continue the process
+	PT_KILL                 = 8  //Terminate the process
+	PT_READ_GPR             = 11 // Read GPR, CR, PSW
+	PT_READ_FPR             = 12 // Read FPR
+	PT_READ_VR              = 13 // Read VR
+	PT_WRITE_GPR            = 14 // Write GPR, CR, PSW
+	PT_WRITE_FPR            = 15 // Write FPR
+	PT_WRITE_VR             = 16 // Write VR
+	PT_READ_BLOCK           = 17 // Read storage
+	PT_WRITE_BLOCK          = 19 // Write storage
+	PT_READ_GPRH            = 20 // Read GPRH
+	PT_WRITE_GPRH           = 21 // Write GPRH
+	PT_REGHSET              = 22 // Read all GPRHs
+	PT_ATTACH               = 30 // Attach to a process
+	PT_DETACH               = 31 // Detach from a process
+	PT_REGSET               = 32 // Read all GPRs
+	PT_REATTACH             = 33 // Reattach to a process
+	PT_LDINFO               = 34 // Read loader info
+	PT_MULTI                = 35 // Multi process mode
+	PT_LD64INFO             = 36 // RMODE64 Info Area
+	PT_BLOCKREQ             = 40 // Block request
+	PT_THREAD_INFO          = 60 // Read thread info
+	PT_THREAD_MODIFY        = 61
+	PT_THREAD_READ_FOCUS    = 62
+	PT_THREAD_WRITE_FOCUS   = 63
+	PT_THREAD_HOLD          = 64
+	PT_THREAD_SIGNAL        = 65
+	PT_EXPLAIN              = 66
+	PT_EVENTS               = 67
+	PT_THREAD_INFO_EXTENDED = 68
+	PT_REATTACH2            = 71
+	PT_CAPTURE              = 72
+	PT_UNCAPTURE            = 73
+	PT_GET_THREAD_TCB       = 74
+	PT_GET_ALET             = 75
+	PT_SWAPIN               = 76
+	PT_EXTENDED_EVENT       = 98
+	PT_RECOVER              = 99  // Debug a program check
+	PT_GPR0                 = 0   // General purpose register 0
+	PT_GPR1                 = 1   // General purpose register 1
+	PT_GPR2                 = 2   // General purpose register 2
+	PT_GPR3                 = 3   // General purpose register 3
+	PT_GPR4                 = 4   // General purpose register 4
+	PT_GPR5                 = 5   // General purpose register 5
+	PT_GPR6                 = 6   // General purpose register 6
+	PT_GPR7                 = 7   // General purpose register 7
+	PT_GPR8                 = 8   // General purpose register 8
+	PT_GPR9                 = 9   // General purpose register 9
+	PT_GPR10                = 10  // General purpose register 10
+	PT_GPR11                = 11  // General purpose register 11
+	PT_GPR12                = 12  // General purpose register 12
+	PT_GPR13                = 13  // General purpose register 13
+	PT_GPR14                = 14  // General purpose register 14
+	PT_GPR15                = 15  // General purpose register 15
+	PT_FPR0                 = 16  // Floating point register 0
+	PT_FPR1                 = 17  // Floating point register 1
+	PT_FPR2                 = 18  // Floating point register 2
+	PT_FPR3                 = 19  // Floating point register 3
+	PT_FPR4                 = 20  // Floating point register 4
+	PT_FPR5                 = 21  // Floating point register 5
+	PT_FPR6                 = 22  // Floating point register 6
+	PT_FPR7                 = 23  // Floating point register 7
+	PT_FPR8                 = 24  // Floating point register 8
+	PT_FPR9                 = 25  // Floating point register 9
+	PT_FPR10                = 26  // Floating point register 10
+	PT_FPR11                = 27  // Floating point register 11
+	PT_FPR12                = 28  // Floating point register 12
+	PT_FPR13                = 29  // Floating point register 13
+	PT_FPR14                = 30  // Floating point register 14
+	PT_FPR15                = 31  // Floating point register 15
+	PT_FPC                  = 32  // Floating point control register
+	PT_PSW                  = 40  // PSW
+	PT_PSW0                 = 40  // Left half of the PSW
+	PT_PSW1                 = 41  // Right half of the PSW
+	PT_CR0                  = 42  // Control register 0
+	PT_CR1                  = 43  // Control register 1
+	PT_CR2                  = 44  // Control register 2
+	PT_CR3                  = 45  // Control register 3
+	PT_CR4                  = 46  // Control register 4
+	PT_CR5                  = 47  // Control register 5
+	PT_CR6                  = 48  // Control register 6
+	PT_CR7                  = 49  // Control register 7
+	PT_CR8                  = 50  // Control register 8
+	PT_CR9                  = 51  // Control register 9
+	PT_CR10                 = 52  // Control register 10
+	PT_CR11                 = 53  // Control register 11
+	PT_CR12                 = 54  // Control register 12
+	PT_CR13                 = 55  // Control register 13
+	PT_CR14                 = 56  // Control register 14
+	PT_CR15                 = 57  // Control register 15
+	PT_GPRH0                = 58  // GP High register 0
+	PT_GPRH1                = 59  // GP High register 1
+	PT_GPRH2                = 60  // GP High register 2
+	PT_GPRH3                = 61  // GP High register 3
+	PT_GPRH4                = 62  // GP High register 4
+	PT_GPRH5                = 63  // GP High register 5
+	PT_GPRH6                = 64  // GP High register 6
+	PT_GPRH7                = 65  // GP High register 7
+	PT_GPRH8                = 66  // GP High register 8
+	PT_GPRH9                = 67  // GP High register 9
+	PT_GPRH10               = 68  // GP High register 10
+	PT_GPRH11               = 69  // GP High register 11
+	PT_GPRH12               = 70  // GP High register 12
+	PT_GPRH13               = 71  // GP High register 13
+	PT_GPRH14               = 72  // GP High register 14
+	PT_GPRH15               = 73  // GP High register 15
+	PT_VR0                  = 74  // Vector register 0
+	PT_VR1                  = 75  // Vector register 1
+	PT_VR2                  = 76  // Vector register 2
+	PT_VR3                  = 77  // Vector register 3
+	PT_VR4                  = 78  // Vector register 4
+	PT_VR5                  = 79  // Vector register 5
+	PT_VR6                  = 80  // Vector register 6
+	PT_VR7                  = 81  // Vector register 7
+	PT_VR8                  = 82  // Vector register 8
+	PT_VR9                  = 83  // Vector register 9
+	PT_VR10                 = 84  // Vector register 10
+	PT_VR11                 = 85  // Vector register 11
+	PT_VR12                 = 86  // Vector register 12
+	PT_VR13                 = 87  // Vector register 13
+	PT_VR14                 = 88  // Vector register 14
+	PT_VR15                 = 89  // Vector register 15
+	PT_VR16                 = 90  // Vector register 16
+	PT_VR17                 = 91  // Vector register 17
+	PT_VR18                 = 92  // Vector register 18
+	PT_VR19                 = 93  // Vector register 19
+	PT_VR20                 = 94  // Vector register 20
+	PT_VR21                 = 95  // Vector register 21
+	PT_VR22                 = 96  // Vector register 22
+	PT_VR23                 = 97  // Vector register 23
+	PT_VR24                 = 98  // Vector register 24
+	PT_VR25                 = 99  // Vector register 25
+	PT_VR26                 = 100 // Vector register 26
+	PT_VR27                 = 101 // Vector register 27
+	PT_VR28                 = 102 // Vector register 28
+	PT_VR29                 = 103 // Vector register 29
+	PT_VR30                 = 104 // Vector register 30
+	PT_VR31                 = 105 // Vector register 31
+	PT_PSWG                 = 106 // PSWG
+	PT_PSWG0                = 106 // Bytes 0-3
+	PT_PSWG1                = 107 // Bytes 4-7
+	PT_PSWG2                = 108 // Bytes 8-11 (IA high word)
+	PT_PSWG3                = 109 // Bytes 12-15 (IA low word)
+)
+
+func Bpx4ptr(request int32, pid int32, addr unsafe.Pointer, data unsafe.Pointer, buffer unsafe.Pointer) (rv int32, rc int32, rn int32) {
+	var parms [8]unsafe.Pointer
+	parms[0] = unsafe.Pointer(&request)
+	parms[1] = unsafe.Pointer(&pid)
+	parms[2] = unsafe.Pointer(&addr)
+	parms[3] = unsafe.Pointer(&data)
+	parms[4] = unsafe.Pointer(&buffer)
+	parms[5] = unsafe.Pointer(&rv)
+	parms[6] = unsafe.Pointer(&rc)
+	parms[7] = unsafe.Pointer(&rn)
+	bpxcall(parms[:], BPX4PTR)
+	return rv, rc, rn
+}
+
+func copyU8(val uint8, dest []uint8) int {
+	if len(dest) < 1 {
+		return 0
+	}
+	dest[0] = val
+	return 1
+}
+
+func copyU8Arr(src, dest []uint8) int {
+	if len(dest) < len(src) {
+		return 0
+	}
+	for i, v := range src {
+		dest[i] = v
+	}
+	return len(src)
+}
+
+func copyU16(val uint16, dest []uint16) int {
+	if len(dest) < 1 {
+		return 0
+	}
+	dest[0] = val
+	return 1
+}
+
+func copyU32(val uint32, dest []uint32) int {
+	if len(dest) < 1 {
+		return 0
+	}
+	dest[0] = val
+	return 1
+}
+
+func copyU32Arr(src, dest []uint32) int {
+	if len(dest) < len(src) {
+		return 0
+	}
+	for i, v := range src {
+		dest[i] = v
+	}
+	return len(src)
+}
+
+func copyU64(val uint64, dest []uint64) int {
+	if len(dest) < 1 {
+		return 0
+	}
+	dest[0] = val
+	return 1
+}

vendor/golang.org/x/sys/unix/bpxsvc_zos.s

@@ -0,0 +1,192 @@
+// Copyright 2024 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#include "go_asm.h"
+#include "textflag.h"
+
+// function to call USS assembly language services
+//
+// doc: https://www.ibm.com/support/knowledgecenter/en/SSLTBW_3.1.0/com.ibm.zos.v3r1.bpxb100/bit64env.htm
+//
+//   arg1 unsafe.Pointer array that ressembles an OS PLIST
+//
+//   arg2 function offset as in
+//       doc: https://www.ibm.com/support/knowledgecenter/en/SSLTBW_3.1.0/com.ibm.zos.v3r1.bpxb100/bpx2cr_List_of_offsets.htm
+//
+// func bpxcall(plist []unsafe.Pointer, bpx_offset int64)
+
+TEXT ·bpxcall(SB), NOSPLIT|NOFRAME, $0
+	MOVD  plist_base+0(FP), R1  // r1 points to plist
+	MOVD  bpx_offset+24(FP), R2 // r2 offset to BPX vector table
+	MOVD  R14, R7               // save r14
+	MOVD  R15, R8               // save r15
+	MOVWZ 16(R0), R9
+	MOVWZ 544(R9), R9
+	MOVWZ 24(R9), R9            // call vector in r9
+	ADD   R2, R9                // add offset to vector table
+	MOVWZ (R9), R9              // r9 points to entry point
+	BYTE  $0x0D                 // BL R14,R9 --> basr r14,r9
+	BYTE  $0xE9                 // clobbers 0,1,14,15
+	MOVD  R8, R15               // restore 15
+	JMP   R7                    // return via saved return address
+
+//   func A2e(arr [] byte)
+//   code page conversion from  819 to 1047
+TEXT ·A2e(SB), NOSPLIT|NOFRAME, $0
+	MOVD arg_base+0(FP), R2                        // pointer to arry of characters
+	MOVD arg_len+8(FP), R3                         // count
+	XOR  R0, R0
+	XOR  R1, R1
+	BYTE $0xA7; BYTE $0x15; BYTE $0x00; BYTE $0x82 // BRAS 1,(2+(256/2))
+
+	// ASCII -> EBCDIC conversion table:
+	BYTE $0x00; BYTE $0x01; BYTE $0x02; BYTE $0x03
+	BYTE $0x37; BYTE $0x2d; BYTE $0x2e; BYTE $0x2f
+	BYTE $0x16; BYTE $0x05; BYTE $0x15; BYTE $0x0b
+	BYTE $0x0c; BYTE $0x0d; BYTE $0x0e; BYTE $0x0f
+	BYTE $0x10; BYTE $0x11; BYTE $0x12; BYTE $0x13
+	BYTE $0x3c; BYTE $0x3d; BYTE $0x32; BYTE $0x26
+	BYTE $0x18; BYTE $0x19; BYTE $0x3f; BYTE $0x27
+	BYTE $0x1c; BYTE $0x1d; BYTE $0x1e; BYTE $0x1f
+	BYTE $0x40; BYTE $0x5a; BYTE $0x7f; BYTE $0x7b
+	BYTE $0x5b; BYTE $0x6c; BYTE $0x50; BYTE $0x7d
+	BYTE $0x4d; BYTE $0x5d; BYTE $0x5c; BYTE $0x4e
+	BYTE $0x6b; BYTE $0x60; BYTE $0x4b; BYTE $0x61
+	BYTE $0xf0; BYTE $0xf1; BYTE $0xf2; BYTE $0xf3
+	BYTE $0xf4; BYTE $0xf5; BYTE $0xf6; BYTE $0xf7
+	BYTE $0xf8; BYTE $0xf9; BYTE $0x7a; BYTE $0x5e
+	BYTE $0x4c; BYTE $0x7e; BYTE $0x6e; BYTE $0x6f
+	BYTE $0x7c; BYTE $0xc1; BYTE $0xc2; BYTE $0xc3
+	BYTE $0xc4; BYTE $0xc5; BYTE $0xc6; BYTE $0xc7
+	BYTE $0xc8; BYTE $0xc9; BYTE $0xd1; BYTE $0xd2
+	BYTE $0xd3; BYTE $0xd4; BYTE $0xd5; BYTE $0xd6
+	BYTE $0xd7; BYTE $0xd8; BYTE $0xd9; BYTE $0xe2
+	BYTE $0xe3; BYTE $0xe4; BYTE $0xe5; BYTE $0xe6
+	BYTE $0xe7; BYTE $0xe8; BYTE $0xe9; BYTE $0xad
+	BYTE $0xe0; BYTE $0xbd; BYTE $0x5f; BYTE $0x6d
+	BYTE $0x79; BYTE $0x81; BYTE $0x82; BYTE $0x83
+	BYTE $0x84; BYTE $0x85; BYTE $0x86; BYTE $0x87
+	BYTE $0x88; BYTE $0x89; BYTE $0x91; BYTE $0x92
+	BYTE $0x93; BYTE $0x94; BYTE $0x95; BYTE $0x96
+	BYTE $0x97; BYTE $0x98; BYTE $0x99; BYTE $0xa2
+	BYTE $0xa3; BYTE $0xa4; BYTE $0xa5; BYTE $0xa6
+	BYTE $0xa7; BYTE $0xa8; BYTE $0xa9; BYTE $0xc0
+	BYTE $0x4f; BYTE $0xd0; BYTE $0xa1; BYTE $0x07
+	BYTE $0x20; BYTE $0x21; BYTE $0x22; BYTE $0x23
+	BYTE $0x24; BYTE $0x25; BYTE $0x06; BYTE $0x17
+	BYTE $0x28; BYTE $0x29; BYTE $0x2a; BYTE $0x2b
+	BYTE $0x2c; BYTE $0x09; BYTE $0x0a; BYTE $0x1b
+	BYTE $0x30; BYTE $0x31; BYTE $0x1a; BYTE $0x33
+	BYTE $0x34; BYTE $0x35; BYTE $0x36; BYTE $0x08
+	BYTE $0x38; BYTE $0x39; BYTE $0x3a; BYTE $0x3b
+	BYTE $0x04; BYTE $0x14; BYTE $0x3e; BYTE $0xff
+	BYTE $0x41; BYTE $0xaa; BYTE $0x4a; BYTE $0xb1
+	BYTE $0x9f; BYTE $0xb2; BYTE $0x6a; BYTE $0xb5
+	BYTE $0xbb; BYTE $0xb4; BYTE $0x9a; BYTE $0x8a
+	BYTE $0xb0; BYTE $0xca; BYTE $0xaf; BYTE $0xbc
+	BYTE $0x90; BYTE $0x8f; BYTE $0xea; BYTE $0xfa
+	BYTE $0xbe; BYTE $0xa0; BYTE $0xb6; BYTE $0xb3
+	BYTE $0x9d; BYTE $0xda; BYTE $0x9b; BYTE $0x8b
+	BYTE $0xb7; BYTE $0xb8; BYTE $0xb9; BYTE $0xab
+	BYTE $0x64; BYTE $0x65; BYTE $0x62; BYTE $0x66
+	BYTE $0x63; BYTE $0x67; BYTE $0x9e; BYTE $0x68
+	BYTE $0x74; BYTE $0x71; BYTE $0x72; BYTE $0x73
+	BYTE $0x78; BYTE $0x75; BYTE $0x76; BYTE $0x77
+	BYTE $0xac; BYTE $0x69; BYTE $0xed; BYTE $0xee
+	BYTE $0xeb; BYTE $0xef; BYTE $0xec; BYTE $0xbf
+	BYTE $0x80; BYTE $0xfd; BYTE $0xfe; BYTE $0xfb
+	BYTE $0xfc; BYTE $0xba; BYTE $0xae; BYTE $0x59
+	BYTE $0x44; BYTE $0x45; BYTE $0x42; BYTE $0x46
+	BYTE $0x43; BYTE $0x47; BYTE $0x9c; BYTE $0x48
+	BYTE $0x54; BYTE $0x51; BYTE $0x52; BYTE $0x53
+	BYTE $0x58; BYTE $0x55; BYTE $0x56; BYTE $0x57
+	BYTE $0x8c; BYTE $0x49; BYTE $0xcd; BYTE $0xce
+	BYTE $0xcb; BYTE $0xcf; BYTE $0xcc; BYTE $0xe1
+	BYTE $0x70; BYTE $0xdd; BYTE $0xde; BYTE $0xdb
+	BYTE $0xdc; BYTE $0x8d; BYTE $0x8e; BYTE $0xdf
+
+retry:
+	WORD $0xB9931022 // TROO 2,2,b'0001'
+	BVS  retry
+	RET
+
+//   func e2a(arr [] byte)
+//   code page conversion from  1047 to 819
+TEXT ·E2a(SB), NOSPLIT|NOFRAME, $0
+	MOVD arg_base+0(FP), R2                        // pointer to arry of characters
+	MOVD arg_len+8(FP), R3                         // count
+	XOR  R0, R0
+	XOR  R1, R1
+	BYTE $0xA7; BYTE $0x15; BYTE $0x00; BYTE $0x82 // BRAS 1,(2+(256/2))
+
+	// EBCDIC -> ASCII conversion table:
+	BYTE $0x00; BYTE $0x01; BYTE $0x02; BYTE $0x03
+	BYTE $0x9c; BYTE $0x09; BYTE $0x86; BYTE $0x7f
+	BYTE $0x97; BYTE $0x8d; BYTE $0x8e; BYTE $0x0b
+	BYTE $0x0c; BYTE $0x0d; BYTE $0x0e; BYTE $0x0f
+	BYTE $0x10; BYTE $0x11; BYTE $0x12; BYTE $0x13
+	BYTE $0x9d; BYTE $0x0a; BYTE $0x08; BYTE $0x87
+	BYTE $0x18; BYTE $0x19; BYTE $0x92; BYTE $0x8f
+	BYTE $0x1c; BYTE $0x1d; BYTE $0x1e; BYTE $0x1f
+	BYTE $0x80; BYTE $0x81; BYTE $0x82; BYTE $0x83
+	BYTE $0x84; BYTE $0x85; BYTE $0x17; BYTE $0x1b
+	BYTE $0x88; BYTE $0x89; BYTE $0x8a; BYTE $0x8b
+	BYTE $0x8c; BYTE $0x05; BYTE $0x06; BYTE $0x07
+	BYTE $0x90; BYTE $0x91; BYTE $0x16; BYTE $0x93
+	BYTE $0x94; BYTE $0x95; BYTE $0x96; BYTE $0x04
+	BYTE $0x98; BYTE $0x99; BYTE $0x9a; BYTE $0x9b
+	BYTE $0x14; BYTE $0x15; BYTE $0x9e; BYTE $0x1a
+	BYTE $0x20; BYTE $0xa0; BYTE $0xe2; BYTE $0xe4
+	BYTE $0xe0; BYTE $0xe1; BYTE $0xe3; BYTE $0xe5
+	BYTE $0xe7; BYTE $0xf1; BYTE $0xa2; BYTE $0x2e
+	BYTE $0x3c; BYTE $0x28; BYTE $0x2b; BYTE $0x7c
+	BYTE $0x26; BYTE $0xe9; BYTE $0xea; BYTE $0xeb
+	BYTE $0xe8; BYTE $0xed; BYTE $0xee; BYTE $0xef
+	BYTE $0xec; BYTE $0xdf; BYTE $0x21; BYTE $0x24
+	BYTE $0x2a; BYTE $0x29; BYTE $0x3b; BYTE $0x5e
+	BYTE $0x2d; BYTE $0x2f; BYTE $0xc2; BYTE $0xc4
+	BYTE $0xc0; BYTE $0xc1; BYTE $0xc3; BYTE $0xc5
+	BYTE $0xc7; BYTE $0xd1; BYTE $0xa6; BYTE $0x2c
+	BYTE $0x25; BYTE $0x5f; BYTE $0x3e; BYTE $0x3f
+	BYTE $0xf8; BYTE $0xc9; BYTE $0xca; BYTE $0xcb
+	BYTE $0xc8; BYTE $0xcd; BYTE $0xce; BYTE $0xcf
+	BYTE $0xcc; BYTE $0x60; BYTE $0x3a; BYTE $0x23
+	BYTE $0x40; BYTE $0x27; BYTE $0x3d; BYTE $0x22
+	BYTE $0xd8; BYTE $0x61; BYTE $0x62; BYTE $0x63
+	BYTE $0x64; BYTE $0x65; BYTE $0x66; BYTE $0x67
+	BYTE $0x68; BYTE $0x69; BYTE $0xab; BYTE $0xbb
+	BYTE $0xf0; BYTE $0xfd; BYTE $0xfe; BYTE $0xb1
+	BYTE $0xb0; BYTE $0x6a; BYTE $0x6b; BYTE $0x6c
+	BYTE $0x6d; BYTE $0x6e; BYTE $0x6f; BYTE $0x70
+	BYTE $0x71; BYTE $0x72; BYTE $0xaa; BYTE $0xba
+	BYTE $0xe6; BYTE $0xb8; BYTE $0xc6; BYTE $0xa4
+	BYTE $0xb5; BYTE $0x7e; BYTE $0x73; BYTE $0x74
+	BYTE $0x75; BYTE $0x76; BYTE $0x77; BYTE $0x78
+	BYTE $0x79; BYTE $0x7a; BYTE $0xa1; BYTE $0xbf
+	BYTE $0xd0; BYTE $0x5b; BYTE $0xde; BYTE $0xae
+	BYTE $0xac; BYTE $0xa3; BYTE $0xa5; BYTE $0xb7
+	BYTE $0xa9; BYTE $0xa7; BYTE $0xb6; BYTE $0xbc
+	BYTE $0xbd; BYTE $0xbe; BYTE $0xdd; BYTE $0xa8
+	BYTE $0xaf; BYTE $0x5d; BYTE $0xb4; BYTE $0xd7
+	BYTE $0x7b; BYTE $0x41; BYTE $0x42; BYTE $0x43
+	BYTE $0x44; BYTE $0x45; BYTE $0x46; BYTE $0x47
+	BYTE $0x48; BYTE $0x49; BYTE $0xad; BYTE $0xf4
+	BYTE $0xf6; BYTE $0xf2; BYTE $0xf3; BYTE $0xf5
+	BYTE $0x7d; BYTE $0x4a; BYTE $0x4b; BYTE $0x4c
+	BYTE $0x4d; BYTE $0x4e; BYTE $0x4f; BYTE $0x50
+	BYTE $0x51; BYTE $0x52; BYTE $0xb9; BYTE $0xfb
+	BYTE $0xfc; BYTE $0xf9; BYTE $0xfa; BYTE $0xff
+	BYTE $0x5c; BYTE $0xf7; BYTE $0x53; BYTE $0x54
+	BYTE $0x55; BYTE $0x56; BYTE $0x57; BYTE $0x58
+	BYTE $0x59; BYTE $0x5a; BYTE $0xb2; BYTE $0xd4
+	BYTE $0xd6; BYTE $0xd2; BYTE $0xd3; BYTE $0xd5
+	BYTE $0x30; BYTE $0x31; BYTE $0x32; BYTE $0x33
+	BYTE $0x34; BYTE $0x35; BYTE $0x36; BYTE $0x37
+	BYTE $0x38; BYTE $0x39; BYTE $0xb3; BYTE $0xdb
+	BYTE $0xdc; BYTE $0xd9; BYTE $0xda; BYTE $0x9f
+
+retry:
+	WORD $0xB9931022 // TROO 2,2,b'0001'
+	BVS  retry
+	RET

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

@@ -1,220 +0,0 @@
-// Copyright 2020 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-//go:build zos && s390x
-
-package unix
-
-import (
-	"sync"
-)
-
-// This file simulates epoll on z/OS using poll.
-
-// Analogous to epoll_event on Linux.
-// TODO(neeilan): Pad is because the Linux kernel expects a 96-bit struct. We never pass this to the kernel; remove?
-type EpollEvent struct {
-	Events uint32
-	Fd     int32
-	Pad    int32
-}
-
-const (
-	EPOLLERR      = 0x8
-	EPOLLHUP      = 0x10
-	EPOLLIN       = 0x1
-	EPOLLMSG      = 0x400
-	EPOLLOUT      = 0x4
-	EPOLLPRI      = 0x2
-	EPOLLRDBAND   = 0x80
-	EPOLLRDNORM   = 0x40
-	EPOLLWRBAND   = 0x200
-	EPOLLWRNORM   = 0x100
-	EPOLL_CTL_ADD = 0x1
-	EPOLL_CTL_DEL = 0x2
-	EPOLL_CTL_MOD = 0x3
-	// The following constants are part of the epoll API, but represent
-	// currently unsupported functionality on z/OS.
-	// EPOLL_CLOEXEC  = 0x80000
-	// EPOLLET        = 0x80000000
-	// EPOLLONESHOT   = 0x40000000
-	// EPOLLRDHUP     = 0x2000     // Typically used with edge-triggered notis
-	// EPOLLEXCLUSIVE = 0x10000000 // Exclusive wake-up mode
-	// EPOLLWAKEUP    = 0x20000000 // Relies on Linux's BLOCK_SUSPEND capability
-)
-
-// TODO(neeilan): We can eliminate these epToPoll / pToEpoll calls by using identical mask values for POLL/EPOLL
-// constants where possible The lower 16 bits of epoll events (uint32) can fit any system poll event (int16).
-
-// epToPollEvt converts epoll event field to poll equivalent.
-// In epoll, Events is a 32-bit field, while poll uses 16 bits.
-func epToPollEvt(events uint32) int16 {
-	var ep2p = map[uint32]int16{
-		EPOLLIN:  POLLIN,
-		EPOLLOUT: POLLOUT,
-		EPOLLHUP: POLLHUP,
-		EPOLLPRI: POLLPRI,
-		EPOLLERR: POLLERR,
-	}
-
-	var pollEvts int16 = 0
-	for epEvt, pEvt := range ep2p {
-		if (events & epEvt) != 0 {
-			pollEvts |= pEvt
-		}
-	}
-
-	return pollEvts
-}
-
-// pToEpollEvt converts 16 bit poll event bitfields to 32-bit epoll event fields.
-func pToEpollEvt(revents int16) uint32 {
-	var p2ep = map[int16]uint32{
-		POLLIN:  EPOLLIN,
-		POLLOUT: EPOLLOUT,
-		POLLHUP: EPOLLHUP,
-		POLLPRI: EPOLLPRI,
-		POLLERR: EPOLLERR,
-	}
-
-	var epollEvts uint32 = 0
-	for pEvt, epEvt := range p2ep {
-		if (revents & pEvt) != 0 {
-			epollEvts |= epEvt
-		}
-	}
-
-	return epollEvts
-}
-
-// Per-process epoll implementation.
-type epollImpl struct {
-	mu       sync.Mutex
-	epfd2ep  map[int]*eventPoll
-	nextEpfd int
-}
-
-// eventPoll holds a set of file descriptors being watched by the process. A process can have multiple epoll instances.
-// On Linux, this is an in-kernel data structure accessed through a fd.
-type eventPoll struct {
-	mu  sync.Mutex
-	fds map[int]*EpollEvent
-}
-
-// epoll impl for this process.
-var impl epollImpl = epollImpl{
-	epfd2ep:  make(map[int]*eventPoll),
-	nextEpfd: 0,
-}
-
-func (e *epollImpl) epollcreate(size int) (epfd int, err error) {
-	e.mu.Lock()
-	defer e.mu.Unlock()
-	epfd = e.nextEpfd
-	e.nextEpfd++
-
-	e.epfd2ep[epfd] = &eventPoll{
-		fds: make(map[int]*EpollEvent),
-	}
-	return epfd, nil
-}
-
-func (e *epollImpl) epollcreate1(flag int) (fd int, err error) {
-	return e.epollcreate(4)
-}
-
-func (e *epollImpl) epollctl(epfd int, op int, fd int, event *EpollEvent) (err error) {
-	e.mu.Lock()
-	defer e.mu.Unlock()
-
-	ep, ok := e.epfd2ep[epfd]
-	if !ok {
-
-		return EBADF
-	}
-
-	switch op {
-	case EPOLL_CTL_ADD:
-		// TODO(neeilan): When we make epfds and fds disjoint, detect epoll
-		// loops here (instances watching each other) and return ELOOP.
-		if _, ok := ep.fds[fd]; ok {
-			return EEXIST
-		}
-		ep.fds[fd] = event
-	case EPOLL_CTL_MOD:
-		if _, ok := ep.fds[fd]; !ok {
-			return ENOENT
-		}
-		ep.fds[fd] = event
-	case EPOLL_CTL_DEL:
-		if _, ok := ep.fds[fd]; !ok {
-			return ENOENT
-		}
-		delete(ep.fds, fd)
-
-	}
-	return nil
-}
-
-// Must be called while holding ep.mu
-func (ep *eventPoll) getFds() []int {
-	fds := make([]int, len(ep.fds))
-	for fd := range ep.fds {
-		fds = append(fds, fd)
-	}
-	return fds
-}
-
-func (e *epollImpl) epollwait(epfd int, events []EpollEvent, msec int) (n int, err error) {
-	e.mu.Lock() // in [rare] case of concurrent epollcreate + epollwait
-	ep, ok := e.epfd2ep[epfd]
-
-	if !ok {
-		e.mu.Unlock()
-		return 0, EBADF
-	}
-
-	pollfds := make([]PollFd, 4)
-	for fd, epollevt := range ep.fds {
-		pollfds = append(pollfds, PollFd{Fd: int32(fd), Events: epToPollEvt(epollevt.Events)})
-	}
-	e.mu.Unlock()
-
-	n, err = Poll(pollfds, msec)
-	if err != nil {
-		return n, err
-	}
-
-	i := 0
-	for _, pFd := range pollfds {
-		if pFd.Revents != 0 {
-			events[i] = EpollEvent{Fd: pFd.Fd, Events: pToEpollEvt(pFd.Revents)}
-			i++
-		}
-
-		if i == n {
-			break
-		}
-	}
-
-	return n, nil
-}
-
-func EpollCreate(size int) (fd int, err error) {
-	return impl.epollcreate(size)
-}
-
-func EpollCreate1(flag int) (fd int, err error) {
-	return impl.epollcreate1(flag)
-}
-
-func EpollCtl(epfd int, op int, fd int, event *EpollEvent) (err error) {
-	return impl.epollctl(epfd, op, fd, event)
-}
-
-// Because EpollWait mutates events, the caller is expected to coordinate
-// concurrent access if calling with the same epfd from multiple goroutines.
-func EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error) {
-	return impl.epollwait(epfd, events, msec)
-}

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

@@ -1,163 +0,0 @@
-// Copyright 2020 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-//go:build zos && s390x
-
-package unix
-
-import (
-	"unsafe"
-)
-
-// This file simulates fstatfs on z/OS using fstatvfs and w_getmntent.
-
-func Fstatfs(fd int, stat *Statfs_t) (err error) {
-	var stat_v Statvfs_t
-	err = Fstatvfs(fd, &stat_v)
-	if err == nil {
-		// populate stat
-		stat.Type = 0
-		stat.Bsize = stat_v.Bsize
-		stat.Blocks = stat_v.Blocks
-		stat.Bfree = stat_v.Bfree
-		stat.Bavail = stat_v.Bavail
-		stat.Files = stat_v.Files
-		stat.Ffree = stat_v.Ffree
-		stat.Fsid = stat_v.Fsid
-		stat.Namelen = stat_v.Namemax
-		stat.Frsize = stat_v.Frsize
-		stat.Flags = stat_v.Flag
-		for passn := 0; passn < 5; passn++ {
-			switch passn {
-			case 0:
-				err = tryGetmntent64(stat)
-				break
-			case 1:
-				err = tryGetmntent128(stat)
-				break
-			case 2:
-				err = tryGetmntent256(stat)
-				break
-			case 3:
-				err = tryGetmntent512(stat)
-				break
-			case 4:
-				err = tryGetmntent1024(stat)
-				break
-			default:
-				break
-			}
-			//proceed to return if: err is nil (found), err is nonnil but not ERANGE (another error occurred)
-			if err == nil || err != nil && err != ERANGE {
-				break
-			}
-		}
-	}
-	return err
-}
-
-func tryGetmntent64(stat *Statfs_t) (err error) {
-	var mnt_ent_buffer struct {
-		header       W_Mnth
-		filesys_info [64]W_Mntent
-	}
-	var buffer_size int = int(unsafe.Sizeof(mnt_ent_buffer))
-	fs_count, err := W_Getmntent((*byte)(unsafe.Pointer(&mnt_ent_buffer)), buffer_size)
-	if err != nil {
-		return err
-	}
-	err = ERANGE //return ERANGE if no match is found in this batch
-	for i := 0; i < fs_count; i++ {
-		if stat.Fsid == uint64(mnt_ent_buffer.filesys_info[i].Dev) {
-			stat.Type = uint32(mnt_ent_buffer.filesys_info[i].Fstname[0])
-			err = nil
-			break
-		}
-	}
-	return err
-}
-
-func tryGetmntent128(stat *Statfs_t) (err error) {
-	var mnt_ent_buffer struct {
-		header       W_Mnth
-		filesys_info [128]W_Mntent
-	}
-	var buffer_size int = int(unsafe.Sizeof(mnt_ent_buffer))
-	fs_count, err := W_Getmntent((*byte)(unsafe.Pointer(&mnt_ent_buffer)), buffer_size)
-	if err != nil {
-		return err
-	}
-	err = ERANGE //return ERANGE if no match is found in this batch
-	for i := 0; i < fs_count; i++ {
-		if stat.Fsid == uint64(mnt_ent_buffer.filesys_info[i].Dev) {
-			stat.Type = uint32(mnt_ent_buffer.filesys_info[i].Fstname[0])
-			err = nil
-			break
-		}
-	}
-	return err
-}
-
-func tryGetmntent256(stat *Statfs_t) (err error) {
-	var mnt_ent_buffer struct {
-		header       W_Mnth
-		filesys_info [256]W_Mntent
-	}
-	var buffer_size int = int(unsafe.Sizeof(mnt_ent_buffer))
-	fs_count, err := W_Getmntent((*byte)(unsafe.Pointer(&mnt_ent_buffer)), buffer_size)
-	if err != nil {
-		return err
-	}
-	err = ERANGE //return ERANGE if no match is found in this batch
-	for i := 0; i < fs_count; i++ {
-		if stat.Fsid == uint64(mnt_ent_buffer.filesys_info[i].Dev) {
-			stat.Type = uint32(mnt_ent_buffer.filesys_info[i].Fstname[0])
-			err = nil
-			break
-		}
-	}
-	return err
-}
-
-func tryGetmntent512(stat *Statfs_t) (err error) {
-	var mnt_ent_buffer struct {
-		header       W_Mnth
-		filesys_info [512]W_Mntent
-	}
-	var buffer_size int = int(unsafe.Sizeof(mnt_ent_buffer))
-	fs_count, err := W_Getmntent((*byte)(unsafe.Pointer(&mnt_ent_buffer)), buffer_size)
-	if err != nil {
-		return err
-	}
-	err = ERANGE //return ERANGE if no match is found in this batch
-	for i := 0; i < fs_count; i++ {
-		if stat.Fsid == uint64(mnt_ent_buffer.filesys_info[i].Dev) {
-			stat.Type = uint32(mnt_ent_buffer.filesys_info[i].Fstname[0])
-			err = nil
-			break
-		}
-	}
-	return err
-}
-
-func tryGetmntent1024(stat *Statfs_t) (err error) {
-	var mnt_ent_buffer struct {
-		header       W_Mnth
-		filesys_info [1024]W_Mntent
-	}
-	var buffer_size int = int(unsafe.Sizeof(mnt_ent_buffer))
-	fs_count, err := W_Getmntent((*byte)(unsafe.Pointer(&mnt_ent_buffer)), buffer_size)
-	if err != nil {
-		return err
-	}
-	err = ERANGE //return ERANGE if no match is found in this batch
-	for i := 0; i < fs_count; i++ {
-		if stat.Fsid == uint64(mnt_ent_buffer.filesys_info[i].Dev) {
-			stat.Type = uint32(mnt_ent_buffer.filesys_info[i].Fstname[0])
-			err = nil
-			break
-		}
-	}
-	return err
-}

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

@@ -58,6 +58,102 @@ func IoctlGetEthtoolDrvinfo(fd int, ifname string) (*EthtoolDrvinfo, error) {
 	return &value, err
 }
 
+// IoctlGetEthtoolTsInfo fetches ethtool timestamping and PHC
+// association for the network device specified by ifname.
+func IoctlGetEthtoolTsInfo(fd int, ifname string) (*EthtoolTsInfo, error) {
+	ifr, err := NewIfreq(ifname)
+	if err != nil {
+		return nil, err
+	}
+
+	value := EthtoolTsInfo{Cmd: ETHTOOL_GET_TS_INFO}
+	ifrd := ifr.withData(unsafe.Pointer(&value))
+
+	err = ioctlIfreqData(fd, SIOCETHTOOL, &ifrd)
+	return &value, err
+}
+
+// IoctlGetHwTstamp retrieves the hardware timestamping configuration
+// for the network device specified by ifname.
+func IoctlGetHwTstamp(fd int, ifname string) (*HwTstampConfig, error) {
+	ifr, err := NewIfreq(ifname)
+	if err != nil {
+		return nil, err
+	}
+
+	value := HwTstampConfig{}
+	ifrd := ifr.withData(unsafe.Pointer(&value))
+
+	err = ioctlIfreqData(fd, SIOCGHWTSTAMP, &ifrd)
+	return &value, err
+}
+
+// IoctlSetHwTstamp updates the hardware timestamping configuration for
+// the network device specified by ifname.
+func IoctlSetHwTstamp(fd int, ifname string, cfg *HwTstampConfig) error {
+	ifr, err := NewIfreq(ifname)
+	if err != nil {
+		return err
+	}
+	ifrd := ifr.withData(unsafe.Pointer(cfg))
+	return ioctlIfreqData(fd, SIOCSHWTSTAMP, &ifrd)
+}
+
+// FdToClockID derives the clock ID from the file descriptor number
+// - see clock_gettime(3), FD_TO_CLOCKID macros. The resulting ID is
+// suitable for system calls like ClockGettime.
+func FdToClockID(fd int) int32 { return int32((int(^fd) << 3) | 3) }
+
+// IoctlPtpClockGetcaps returns the description of a given PTP device.
+func IoctlPtpClockGetcaps(fd int) (*PtpClockCaps, error) {
+	var value PtpClockCaps
+	err := ioctlPtr(fd, PTP_CLOCK_GETCAPS2, unsafe.Pointer(&value))
+	return &value, err
+}
+
+// IoctlPtpSysOffsetPrecise returns a description of the clock
+// offset compared to the system clock.
+func IoctlPtpSysOffsetPrecise(fd int) (*PtpSysOffsetPrecise, error) {
+	var value PtpSysOffsetPrecise
+	err := ioctlPtr(fd, PTP_SYS_OFFSET_PRECISE2, unsafe.Pointer(&value))
+	return &value, err
+}
+
+// IoctlPtpSysOffsetExtended returns an extended description of the
+// clock offset compared to the system clock. The samples parameter
+// specifies the desired number of measurements.
+func IoctlPtpSysOffsetExtended(fd int, samples uint) (*PtpSysOffsetExtended, error) {
+	value := PtpSysOffsetExtended{Samples: uint32(samples)}
+	err := ioctlPtr(fd, PTP_SYS_OFFSET_EXTENDED2, unsafe.Pointer(&value))
+	return &value, err
+}
+
+// IoctlPtpPinGetfunc returns the configuration of the specified
+// I/O pin on given PTP device.
+func IoctlPtpPinGetfunc(fd int, index uint) (*PtpPinDesc, error) {
+	value := PtpPinDesc{Index: uint32(index)}
+	err := ioctlPtr(fd, PTP_PIN_GETFUNC2, unsafe.Pointer(&value))
+	return &value, err
+}
+
+// IoctlPtpPinSetfunc updates configuration of the specified PTP
+// I/O pin.
+func IoctlPtpPinSetfunc(fd int, pd *PtpPinDesc) error {
+	return ioctlPtr(fd, PTP_PIN_SETFUNC2, unsafe.Pointer(pd))
+}
+
+// IoctlPtpPeroutRequest configures the periodic output mode of the
+// PTP I/O pins.
+func IoctlPtpPeroutRequest(fd int, r *PtpPeroutRequest) error {
+	return ioctlPtr(fd, PTP_PEROUT_REQUEST2, unsafe.Pointer(r))
+}
+
+// IoctlPtpExttsRequest configures the external timestamping mode
+// of the PTP I/O pins.
+func IoctlPtpExttsRequest(fd int, r *PtpExttsRequest) error {
+	return ioctlPtr(fd, PTP_EXTTS_REQUEST2, unsafe.Pointer(r))
+}
+
 // IoctlGetWatchdogInfo fetches information about a watchdog device from the
 // Linux watchdog API. For more information, see:
 // https://www.kernel.org/doc/html/latest/watchdog/watchdog-api.html.