├── xo ├── parser.go └── level.go ├── vendor ├── github.com │ ├── as │ │ ├── edit │ │ │ ├── win.go │ │ │ ├── doc.go │ │ │ ├── rec.go │ │ │ └── LICENSE │ │ ├── text │ │ │ ├── alt.go │ │ │ ├── editor.go │ │ │ ├── etc.go │ │ │ ├── dist.go │ │ │ ├── file.go │ │ │ ├── rec.go │ │ │ ├── history.go │ │ │ ├── trace.go │ │ │ └── cor.go │ │ ├── frame │ │ │ ├── box │ │ │ │ ├── ruler.go │ │ │ │ ├── box.go │ │ │ │ └── b.go │ │ │ ├── elastic.png │ │ │ ├── write.go │ │ │ ├── chop.go │ │ │ ├── rgba.go │ │ │ ├── clean.go │ │ │ ├── config.go │ │ │ ├── indexof.go │ │ │ ├── pointof.go │ │ │ ├── color.go │ │ │ └── LICENSE │ │ ├── log │ │ │ ├── go.mod │ │ │ ├── LICENSE │ │ │ └── README.md │ │ ├── font │ │ │ ├── README.md │ │ │ ├── resizer.go │ │ │ ├── gomono │ │ │ │ └── gomono.go │ │ │ ├── gomedium │ │ │ │ └── gomedium.go │ │ │ ├── goregular │ │ │ │ └── goregular.go │ │ │ ├── cliche.go │ │ │ └── gofont.go │ │ ├── io │ │ │ ├── count │ │ │ │ └── count.go │ │ │ └── rev │ │ │ │ └── rev.go │ │ ├── xo │ │ │ └── verb.go │ │ ├── mute │ │ │ └── mute.go │ │ ├── worm │ │ │ ├── logger.go │ │ │ └── README.md │ │ ├── etch │ │ │ └── LICENSE │ │ └── event │ │ │ └── write.go │ ├── BurntSushi │ │ └── xgb │ │ │ ├── .gitignore │ │ │ ├── AUTHORS │ │ │ ├── sync.go │ │ │ ├── STYLE │ │ │ └── CONTRIBUTORS │ ├── go-gl │ │ └── glfw │ │ │ └── v3.3 │ │ │ └── glfw │ │ │ ├── GLFW_C_REVISION.txt │ │ │ ├── go.mod │ │ │ ├── error.c │ │ │ ├── c_glfw.go │ │ │ ├── c_glfw_windows.go │ │ │ ├── c_glfw_darwin.go │ │ │ ├── monitor.c │ │ │ ├── c_glfw_linbsd.go │ │ │ ├── vulkan.go │ │ │ ├── util.go │ │ │ ├── native_windows.go │ │ │ ├── native_darwin.go │ │ │ ├── time.go │ │ │ ├── window.c │ │ │ ├── LICENSE │ │ │ └── input.c │ ├── basgys │ │ └── goxml2json │ │ │ ├── doc.go │ │ │ ├── .gitignore │ │ │ ├── converter.go │ │ │ ├── struct.go │ │ │ └── LICENSE │ └── golang │ │ └── freetype │ │ ├── LICENSE │ │ ├── AUTHORS │ │ └── CONTRIBUTORS ├── rsc.io │ └── pdf │ │ ├── README.md │ │ └── LICENSE ├── golang.org │ └── x │ │ ├── crypto │ │ ├── curve25519 │ │ │ └── internal │ │ │ │ └── field │ │ │ │ ├── sync.checkpoint │ │ │ │ ├── README │ │ │ │ ├── fe_arm64_noasm.go │ │ │ │ ├── fe_amd64_noasm.go │ │ │ │ ├── fe_arm64.go │ │ │ │ ├── fe_amd64.go │ │ │ │ ├── sync.sh │ │ │ │ └── fe_arm64.s │ │ ├── AUTHORS │ │ ├── CONTRIBUTORS │ │ ├── poly1305 │ │ │ ├── mac_noasm.go │ │ │ ├── bits_go1.13.go │ │ │ ├── bits_compat.go │ │ │ ├── sum_amd64.go │ │ │ └── sum_ppc64le.go │ │ ├── sha3 │ │ │ ├── keccakf_amd64.go │ │ │ ├── register.go │ │ │ ├── shake_generic.go │ │ │ ├── xor.go │ │ │ ├── xor_generic.go │ │ │ ├── hashes_generic.go │ │ │ └── sha3_s390x.s │ │ ├── chacha20 │ │ │ ├── chacha_noasm.go │ │ │ ├── chacha_ppc64le.go │ │ │ ├── chacha_arm64.go │ │ │ ├── chacha_s390x.go │ │ │ └── xor.go │ │ ├── ssh │ │ │ ├── doc.go │ │ │ └── mac.go │ │ ├── PATENTS │ │ ├── internal │ │ │ └── subtle │ │ │ │ ├── aliasing.go │ │ │ │ └── aliasing_purego.go │ │ └── LICENSE │ │ ├── exp │ │ ├── AUTHORS │ │ ├── CONTRIBUTORS │ │ ├── shiny │ │ │ └── driver │ │ │ │ ├── windriver │ │ │ │ ├── syscall.go │ │ │ │ ├── other.go │ │ │ │ └── windriver.go │ │ │ │ ├── internal │ │ │ │ ├── win32 │ │ │ │ │ └── syscall.go │ │ │ │ ├── swizzle │ │ │ │ │ ├── swizzle_other.go │ │ │ │ │ ├── swizzle_amd64.go │ │ │ │ │ ├── swizzle_common.go │ │ │ │ │ └── swizzle_amd64.s │ │ │ │ ├── errscreen │ │ │ │ │ └── errscreen.go │ │ │ │ └── drawer │ │ │ │ │ └── drawer.go │ │ │ │ ├── driver_windows.go │ │ │ │ ├── mtldriver │ │ │ │ ├── internal │ │ │ │ │ ├── appkit │ │ │ │ │ │ ├── appkit.h │ │ │ │ │ │ └── appkit.m │ │ │ │ │ └── coreanim │ │ │ │ │ │ └── coreanim.h │ │ │ │ ├── buffer.go │ │ │ │ ├── texture.go │ │ │ │ └── screen.go │ │ │ │ ├── driver_darwin.go │ │ │ │ ├── mtldriver_darwin.go │ │ │ │ ├── driver_x11.go │ │ │ │ ├── driver_fallback.go │ │ │ │ ├── x11driver │ │ │ │ ├── shm_other.go │ │ │ │ ├── shm_openbsd_syscall.go │ │ │ │ ├── shm_shmopen_syscall.go │ │ │ │ └── shm_linux_ipc.go │ │ │ │ ├── gldriver │ │ │ │ ├── context.go │ │ │ │ ├── other.go │ │ │ │ └── buffer.go │ │ │ │ └── driver.go │ │ ├── PATENTS │ │ └── LICENSE │ │ ├── image │ │ ├── AUTHORS │ │ ├── CONTRIBUTORS │ │ ├── tiff │ │ │ ├── fuzz.go │ │ │ └── compress.go │ │ ├── draw │ │ │ └── draw_go117.go │ │ ├── math │ │ │ └── f64 │ │ │ │ └── f64.go │ │ ├── PATENTS │ │ └── LICENSE │ │ ├── net │ │ ├── AUTHORS │ │ ├── CONTRIBUTORS │ │ ├── PATENTS │ │ └── LICENSE │ │ ├── sys │ │ ├── AUTHORS │ │ ├── CONTRIBUTORS │ │ ├── cpu │ │ │ ├── cpu_zos.go │ │ │ ├── cpu_other_arm.go │ │ │ ├── cpu_other_arm64.go │ │ │ ├── cpu_riscv64.go │ │ │ ├── cpu_gc_arm64.go │ │ │ ├── cpu_mipsx.go │ │ │ ├── cpu_other_mips64x.go │ │ │ ├── cpu_gccgo_arm64.go │ │ │ ├── cpu_linux_noinit.go │ │ │ ├── cpu_mips64x.go │ │ │ ├── cpu_linux.go │ │ │ ├── cpu_ppc64x.go │ │ │ ├── asm_aix_ppc64.s │ │ │ ├── cpu_wasm.go │ │ │ ├── cpu_linux_mips64x.go │ │ │ ├── cpu_zos_s390x.go │ │ │ ├── cpu_aix.go │ │ │ ├── cpu_gc_x86.go │ │ │ ├── cpu_gc_s390x.go │ │ │ ├── syscall_aix_gccgo.go │ │ │ ├── cpu_arm64.s │ │ │ ├── cpu_linux_ppc64x.go │ │ │ ├── cpu_gccgo_x86.go │ │ │ ├── cpu_linux_s390x.go │ │ │ ├── cpu_gccgo_s390x.go │ │ │ ├── syscall_aix_ppc64_gc.go │ │ │ ├── cpu_gccgo_x86.c │ │ │ ├── hwcap_linux.go │ │ │ └── cpu_linux_arm.go │ │ ├── windows │ │ │ ├── aliases.go │ │ │ ├── empty.s │ │ │ ├── mksyscall.go │ │ │ ├── race0.go │ │ │ ├── str.go │ │ │ ├── race.go │ │ │ ├── eventlog.go │ │ │ ├── types_windows_amd64.go │ │ │ ├── types_windows_arm64.go │ │ │ ├── types_windows_386.go │ │ │ ├── types_windows_arm.go │ │ │ ├── memory_windows.go │ │ │ ├── env_windows.go │ │ │ └── mkknownfolderids.bash │ │ ├── internal │ │ │ └── unsafeheader │ │ │ │ └── unsafeheader.go │ │ ├── PATENTS │ │ └── LICENSE │ │ ├── text │ │ ├── AUTHORS │ │ ├── CONTRIBUTORS │ │ ├── language │ │ │ ├── go1_2.go │ │ │ └── go1_1.go │ │ ├── encoding │ │ │ ├── japanese │ │ │ │ └── all.go │ │ │ └── simplifiedchinese │ │ │ │ └── all.go │ │ ├── internal │ │ │ └── language │ │ │ │ ├── common.go │ │ │ │ ├── coverage.go │ │ │ │ ├── compact.go │ │ │ │ └── tags.go │ │ ├── PATENTS │ │ └── LICENSE │ │ └── mobile │ │ ├── AUTHORS │ │ ├── CONTRIBUTORS │ │ ├── gl │ │ ├── work_windows_386.s │ │ ├── work_windows_amd64.s │ │ └── work_other.go │ │ ├── event │ │ └── paint │ │ │ └── paint.go │ │ ├── PATENTS │ │ └── LICENSE └── dmitri.shuralyov.com │ └── gpu │ └── mtl │ └── LICENSE ├── edit └── edit_test.go ├── x ├── file.go ├── main.go ├── win.go └── find.go ├── uniq └── books ├── no └── no.go ├── README.md ├── loop └── loop.go ├── stutter └── stutter.go ├── go.mod ├── pp └── pp.go ├── uq └── uq.go └── cat └── cat.go /xo/parser.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /vendor/github.com/as/edit/win.go: -------------------------------------------------------------------------------- 1 | package edit 2 | -------------------------------------------------------------------------------- /vendor/github.com/as/text/alt.go: -------------------------------------------------------------------------------- 1 | package text 2 | -------------------------------------------------------------------------------- /vendor/github.com/as/text/editor.go: -------------------------------------------------------------------------------- 1 | package text 2 | -------------------------------------------------------------------------------- /vendor/github.com/as/frame/box/ruler.go: -------------------------------------------------------------------------------- 1 | package box 2 | -------------------------------------------------------------------------------- /vendor/github.com/BurntSushi/xgb/.gitignore: -------------------------------------------------------------------------------- 1 | xgbgen/xgbgen 2 | .*.swp 3 | -------------------------------------------------------------------------------- /vendor/github.com/as/log/go.mod: -------------------------------------------------------------------------------- 1 | module github.com/as/log 2 | 3 | go 1.16 4 | -------------------------------------------------------------------------------- /vendor/rsc.io/pdf/README.md: -------------------------------------------------------------------------------- 1 | go get rsc.io/pdf 2 | 3 | http://godoc.org/rsc.io/pdf 4 | -------------------------------------------------------------------------------- /vendor/github.com/go-gl/glfw/v3.3/glfw/GLFW_C_REVISION.txt: -------------------------------------------------------------------------------- 1 | 0a49ef0a00baa3ab520ddc452f0e3b1e099c5589 2 | -------------------------------------------------------------------------------- /vendor/github.com/go-gl/glfw/v3.3/glfw/go.mod: -------------------------------------------------------------------------------- 1 | module github.com/go-gl/glfw/v3.3/glfw 2 | 3 | go 1.10 4 | -------------------------------------------------------------------------------- /edit/edit_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "testing" 4 | 5 | func TestEdit(t *testing.T) { 6 | 7 | } 8 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/curve25519/internal/field/sync.checkpoint: -------------------------------------------------------------------------------- 1 | b0c49ae9f59d233526f8934262c5bbbe14d4358d 2 | -------------------------------------------------------------------------------- /vendor/github.com/basgys/goxml2json/doc.go: -------------------------------------------------------------------------------- 1 | // Package xml2json is an XML to JSON converter 2 | package xml2json 3 | -------------------------------------------------------------------------------- /vendor/github.com/as/frame/elastic.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/as/torgo/HEAD/vendor/github.com/as/frame/elastic.png -------------------------------------------------------------------------------- /vendor/github.com/as/font/README.md: -------------------------------------------------------------------------------- 1 | # font 2 | Font contains the IBM vga font 3 | 4 | This API is not ready for general use and is subject to change 5 | -------------------------------------------------------------------------------- /vendor/github.com/go-gl/glfw/v3.3/glfw/error.c: -------------------------------------------------------------------------------- 1 | #include "_cgo_export.h" 2 | 3 | void glfwSetErrorCallbackCB() { glfwSetErrorCallback((GLFWerrorfun)goErrorCB); } 4 | -------------------------------------------------------------------------------- /vendor/github.com/as/text/etc.go: -------------------------------------------------------------------------------- 1 | package text 2 | 3 | func clamp(v, l, h int64) int64 { 4 | if v < l { 5 | return l 6 | } 7 | if v > h { 8 | return h 9 | } 10 | return v 11 | } 12 | -------------------------------------------------------------------------------- /vendor/golang.org/x/exp/AUTHORS: -------------------------------------------------------------------------------- 1 | # This source code refers to The Go Authors for copyright purposes. 2 | # The master list of authors is in the main Go distribution, 3 | # visible at http://tip.golang.org/AUTHORS. 4 | -------------------------------------------------------------------------------- /vendor/golang.org/x/exp/CONTRIBUTORS: -------------------------------------------------------------------------------- 1 | # This source code was written by the Go contributors. 2 | # The master list of contributors is in the main Go distribution, 3 | # visible at http://tip.golang.org/CONTRIBUTORS. 4 | -------------------------------------------------------------------------------- /vendor/golang.org/x/image/AUTHORS: -------------------------------------------------------------------------------- 1 | # This source code refers to The Go Authors for copyright purposes. 2 | # The master list of authors is in the main Go distribution, 3 | # visible at http://tip.golang.org/AUTHORS. 4 | -------------------------------------------------------------------------------- /vendor/golang.org/x/net/AUTHORS: -------------------------------------------------------------------------------- 1 | # This source code refers to The Go Authors for copyright purposes. 2 | # The master list of authors is in the main Go distribution, 3 | # visible at http://tip.golang.org/AUTHORS. 4 | -------------------------------------------------------------------------------- /vendor/golang.org/x/net/CONTRIBUTORS: -------------------------------------------------------------------------------- 1 | # This source code was written by the Go contributors. 2 | # The master list of contributors is in the main Go distribution, 3 | # visible at http://tip.golang.org/CONTRIBUTORS. 4 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/AUTHORS: -------------------------------------------------------------------------------- 1 | # This source code refers to The Go Authors for copyright purposes. 2 | # The master list of authors is in the main Go distribution, 3 | # visible at http://tip.golang.org/AUTHORS. 4 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/CONTRIBUTORS: -------------------------------------------------------------------------------- 1 | # This source code was written by the Go contributors. 2 | # The master list of contributors is in the main Go distribution, 3 | # visible at http://tip.golang.org/CONTRIBUTORS. 4 | -------------------------------------------------------------------------------- /vendor/golang.org/x/text/AUTHORS: -------------------------------------------------------------------------------- 1 | # This source code refers to The Go Authors for copyright purposes. 2 | # The master list of authors is in the main Go distribution, 3 | # visible at http://tip.golang.org/AUTHORS. 4 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/AUTHORS: -------------------------------------------------------------------------------- 1 | # This source code refers to The Go Authors for copyright purposes. 2 | # The master list of authors is in the main Go distribution, 3 | # visible at https://tip.golang.org/AUTHORS. 4 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/CONTRIBUTORS: -------------------------------------------------------------------------------- 1 | # This source code was written by the Go contributors. 2 | # The master list of contributors is in the main Go distribution, 3 | # visible at https://tip.golang.org/CONTRIBUTORS. 4 | -------------------------------------------------------------------------------- /vendor/golang.org/x/image/CONTRIBUTORS: -------------------------------------------------------------------------------- 1 | # This source code was written by the Go contributors. 2 | # The master list of contributors is in the main Go distribution, 3 | # visible at http://tip.golang.org/CONTRIBUTORS. 4 | -------------------------------------------------------------------------------- /vendor/golang.org/x/mobile/AUTHORS: -------------------------------------------------------------------------------- 1 | # This source code refers to The Go Authors for copyright purposes. 2 | # The master list of authors is in the main Go distribution, 3 | # visible at http://tip.golang.org/AUTHORS. 4 | -------------------------------------------------------------------------------- /vendor/golang.org/x/mobile/CONTRIBUTORS: -------------------------------------------------------------------------------- 1 | # This source code was written by the Go contributors. 2 | # The master list of contributors is in the main Go distribution, 3 | # visible at http://tip.golang.org/CONTRIBUTORS. 4 | -------------------------------------------------------------------------------- /vendor/golang.org/x/text/CONTRIBUTORS: -------------------------------------------------------------------------------- 1 | # This source code was written by the Go contributors. 2 | # The master list of contributors is in the main Go distribution, 3 | # visible at http://tip.golang.org/CONTRIBUTORS. 4 | -------------------------------------------------------------------------------- /vendor/github.com/as/edit/doc.go: -------------------------------------------------------------------------------- 1 | // Package edit implements a compiler for Acme Edit command language. The compiled Command operates on types satisfying the text.Editor interface. See github.com/as/text for more. 2 | package edit 3 | -------------------------------------------------------------------------------- /x/file.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | type File interface { 4 | Insert(p []byte, at int64) (wrote int64) 5 | Delete(q0, q1 int64) (del int64) 6 | Select(q0, q1 int64) 7 | Dot() (q0, q1 int64) 8 | Dirty() bool 9 | Bytes() []byte 10 | } 11 | -------------------------------------------------------------------------------- /uniq/books: -------------------------------------------------------------------------------- 1 | 90.00 The Go Programming Language 2 | 80.00 The Elements of Style 3 | 85.00 The C Programming Language 4 | 3.59 Snookie: A Shore Thing 5 | 0.19 Hardcore Java 6 | 0.03 The C++ Programming Language 7 | 0.03 The C++ Programming Language 8 | 0.01 XML: Its Not So bad 9 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_zos.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package cpu 6 | 7 | func archInit() { 8 | doinit() 9 | Initialized = true 10 | } 11 | -------------------------------------------------------------------------------- /no/no.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bufio" 5 | "os" 6 | ) 7 | 8 | var ( 9 | no = []byte("no") 10 | err error 11 | ) 12 | 13 | func main() { 14 | if len(os.Args) > 1 { 15 | no = []byte(os.Args[1]) 16 | } 17 | for br := bufio.NewWriter(os.Stdout); err == nil; _, err = br.Write(no) { 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /vendor/github.com/as/font/resizer.go: -------------------------------------------------------------------------------- 1 | package font 2 | 3 | // Resizer knows how to return an enlarged version of its face 4 | type Resizer struct { 5 | Face 6 | 7 | // New returns a new face with the given size. The current 8 | // size is not closed and is still usable by callers 9 | New func(int) Face 10 | } 11 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_other_arm.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build !linux && arm 6 | // +build !linux,arm 7 | 8 | package cpu 9 | 10 | func archInit() {} 11 | -------------------------------------------------------------------------------- /vendor/github.com/as/font/gomono/gomono.go: -------------------------------------------------------------------------------- 1 | package gomono 2 | 3 | import ( 4 | "log" 5 | 6 | "github.com/golang/freetype/truetype" 7 | . "golang.org/x/image/font/gofont/gomono" 8 | ) 9 | 10 | var Font, err = truetype.Parse(TTF) 11 | 12 | func init() { 13 | if err != nil { 14 | log.Fatalln("goregular", err) 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /vendor/github.com/as/font/gomedium/gomedium.go: -------------------------------------------------------------------------------- 1 | package gomedium 2 | 3 | import ( 4 | "log" 5 | 6 | "github.com/golang/freetype/truetype" 7 | . "golang.org/x/image/font/gofont/gomedium" 8 | ) 9 | 10 | var Font, err = truetype.Parse(TTF) 11 | 12 | func init() { 13 | if err != nil { 14 | log.Fatalln("gomedium", err) 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /vendor/github.com/go-gl/glfw/v3.3/glfw/c_glfw.go: -------------------------------------------------------------------------------- 1 | package glfw 2 | 3 | /* 4 | #include "glfw/src/context.c" 5 | #include "glfw/src/init.c" 6 | #include "glfw/src/input.c" 7 | #include "glfw/src/monitor.c" 8 | #include "glfw/src/vulkan.c" 9 | #include "glfw/src/window.c" 10 | #include "glfw/src/osmesa_context.c" 11 | */ 12 | import "C" 13 | -------------------------------------------------------------------------------- /vendor/github.com/as/font/goregular/goregular.go: -------------------------------------------------------------------------------- 1 | package goregular 2 | 3 | import ( 4 | "log" 5 | 6 | "github.com/golang/freetype/truetype" 7 | . "golang.org/x/image/font/gofont/goregular" 8 | ) 9 | 10 | var Font, err = truetype.Parse(TTF) 11 | 12 | func init() { 13 | if err != nil { 14 | log.Fatalln("goregular", err) 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_other_arm64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build !linux && !netbsd && arm64 6 | // +build !linux,!netbsd,arm64 7 | 8 | package cpu 9 | 10 | func doinit() {} 11 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_riscv64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build riscv64 6 | // +build riscv64 7 | 8 | package cpu 9 | 10 | const cacheLineSize = 32 11 | 12 | func initOptions() {} 13 | -------------------------------------------------------------------------------- /vendor/golang.org/x/text/language/go1_2.go: -------------------------------------------------------------------------------- 1 | // Copyright 2013 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build go1.2 6 | // +build go1.2 7 | 8 | package language 9 | 10 | import "sort" 11 | 12 | var sortStable = sort.Stable 13 | -------------------------------------------------------------------------------- /vendor/golang.org/x/mobile/gl/work_windows_386.s: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | #include "textflag.h" 6 | 7 | // fixFloat is unnecessary for windows/386 8 | TEXT ·fixFloat(SB),NOSPLIT,$0-16 9 | RET 10 | -------------------------------------------------------------------------------- /vendor/golang.org/x/exp/shiny/driver/windriver/syscall.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:generate go run $GOROOT/src/syscall/mksyscall_windows.go -output zsyscall_windows.go syscall_windows.go 6 | 7 | package windriver 8 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_gc_arm64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build gc 6 | // +build gc 7 | 8 | package cpu 9 | 10 | func getisar0() uint64 11 | func getisar1() uint64 12 | func getpfr0() uint64 13 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_mipsx.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build mips || mipsle 6 | // +build mips mipsle 7 | 8 | package cpu 9 | 10 | const cacheLineSize = 32 11 | 12 | func initOptions() {} 13 | -------------------------------------------------------------------------------- /vendor/golang.org/x/exp/shiny/driver/internal/win32/syscall.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:generate go run $GOROOT/src/syscall/mksyscall_windows.go -output zsyscall_windows.go syscall_windows.go 6 | 7 | package win32 8 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/aliases.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build windows 6 | // +build go1.9 7 | 8 | package windows 9 | 10 | import "syscall" 11 | 12 | type Errno = syscall.Errno 13 | type SysProcAttr = syscall.SysProcAttr 14 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/poly1305/mac_noasm.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (!amd64 && !ppc64le && !s390x) || !gc || purego 6 | // +build !amd64,!ppc64le,!s390x !gc purego 7 | 8 | package poly1305 9 | 10 | type mac struct{ macGeneric } 11 | -------------------------------------------------------------------------------- /vendor/golang.org/x/mobile/gl/work_windows_amd64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | #include "textflag.h" 6 | 7 | TEXT ·fixFloat(SB),NOSPLIT,$0-32 8 | MOVQ x0+0(FP), X0 9 | MOVQ x1+8(FP), X1 10 | MOVQ x2+16(FP), X2 11 | MOVQ x3+24(FP), X3 12 | RET 13 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_other_mips64x.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build !linux && (mips64 || mips64le) 6 | // +build !linux 7 | // +build mips64 mips64le 8 | 9 | package cpu 10 | 11 | func archInit() { 12 | Initialized = true 13 | } 14 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/empty.s: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build !go1.12 6 | // +build !go1.12 7 | 8 | // This file is here to allow bodyless functions with go:linkname for Go 1.11 9 | // and earlier (see https://golang.org/issue/23311). 10 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_gccgo_arm64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build gccgo 6 | // +build gccgo 7 | 8 | package cpu 9 | 10 | func getisar0() uint64 { return 0 } 11 | func getisar1() uint64 { return 0 } 12 | func getpfr0() uint64 { return 0 } 13 | -------------------------------------------------------------------------------- /vendor/github.com/go-gl/glfw/v3.3/glfw/c_glfw_windows.go: -------------------------------------------------------------------------------- 1 | package glfw 2 | 3 | /* 4 | #include "glfw/src/win32_init.c" 5 | #include "glfw/src/win32_joystick.c" 6 | #include "glfw/src/win32_monitor.c" 7 | #include "glfw/src/win32_time.c" 8 | #include "glfw/src/win32_thread.c" 9 | #include "glfw/src/win32_window.c" 10 | #include "glfw/src/wgl_context.c" 11 | #include "glfw/src/egl_context.c" 12 | */ 13 | import "C" 14 | -------------------------------------------------------------------------------- /vendor/github.com/as/io/count/count.go: -------------------------------------------------------------------------------- 1 | package count 2 | 3 | import "bytes" 4 | 5 | type Writer struct { 6 | s []byte 7 | N int64 8 | } 9 | 10 | func NewWriter(s string) *Writer { 11 | return &Writer{[]byte(s), 0} 12 | } 13 | 14 | func (c *Writer) Write(p []byte) (int, error) { 15 | c.N += int64(bytes.Count(p, c.s)) 16 | return len(p), nil 17 | } 18 | 19 | func (c Writer) Seen() int64 { 20 | return c.N 21 | } 22 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/mksyscall.go: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build generate 6 | 7 | package windows 8 | 9 | //go:generate go run golang.org/x/sys/windows/mkwinsyscall -output zsyscall_windows.go eventlog.go service.go syscall_windows.go security_windows.go 10 | -------------------------------------------------------------------------------- /vendor/github.com/basgys/goxml2json/.gitignore: -------------------------------------------------------------------------------- 1 | # Compiled Object files, Static and Dynamic libs (Shared Objects) 2 | *.o 3 | *.a 4 | *.so 5 | 6 | # Folders 7 | _obj 8 | _test 9 | 10 | # Architecture specific extensions/prefixes 11 | *.[568vq] 12 | [568vq].out 13 | 14 | *.cgo1.go 15 | *.cgo2.c 16 | _cgo_defun.c 17 | _cgo_gotypes.go 18 | _cgo_export.* 19 | 20 | _testmain.go 21 | 22 | *.exe 23 | *.test 24 | *.prof 25 | /.tags 26 | -------------------------------------------------------------------------------- /vendor/golang.org/x/exp/shiny/driver/driver_windows.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package driver 6 | 7 | import ( 8 | "golang.org/x/exp/shiny/driver/windriver" 9 | "golang.org/x/exp/shiny/screen" 10 | ) 11 | 12 | func main(f func(screen.Screen)) { 13 | windriver.Main(f) 14 | } 15 | -------------------------------------------------------------------------------- /vendor/golang.org/x/exp/shiny/driver/mtldriver/internal/appkit/appkit.h: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build darwin 6 | 7 | void * Window_ContentView(void * window); 8 | 9 | void View_SetLayer(void * view, void * layer); 10 | void View_SetWantsLayer(void * view, bool wantsLayer); 11 | -------------------------------------------------------------------------------- /vendor/golang.org/x/text/encoding/japanese/all.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package japanese 6 | 7 | import ( 8 | "golang.org/x/text/encoding" 9 | ) 10 | 11 | // All is a list of all defined encodings in this package. 12 | var All = []encoding.Encoding{EUCJP, ISO2022JP, ShiftJIS} 13 | -------------------------------------------------------------------------------- /vendor/github.com/as/frame/write.go: -------------------------------------------------------------------------------- 1 | package frame 2 | 3 | import "io" 4 | 5 | // Write implements io.Writer. The write operation appends to the current 6 | // selection given by Dot(). It returns io.EOF when the entire message doesn't 7 | // fit on the frame. 8 | func (f *Frame) Write(p []byte) (n int, err error) { 9 | _, p1 := f.Dot() 10 | if n = f.Insert(p, p1); n == 0 { 11 | return 0, io.EOF 12 | } 13 | return n, nil 14 | } 15 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_linux_noinit.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build linux && !arm && !arm64 && !mips64 && !mips64le && !ppc64 && !ppc64le && !s390x 6 | // +build linux,!arm,!arm64,!mips64,!mips64le,!ppc64,!ppc64le,!s390x 7 | 8 | package cpu 9 | 10 | func doinit() {} 11 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/curve25519/internal/field/README: -------------------------------------------------------------------------------- 1 | This package is kept in sync with crypto/ed25519/internal/edwards25519/field in 2 | the standard library. 3 | 4 | If there are any changes in the standard library that need to be synced to this 5 | package, run sync.sh. It will not overwrite any local changes made since the 6 | previous sync, so it's ok to land changes in this package first, and then sync 7 | to the standard library later. 8 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/curve25519/internal/field/fe_arm64_noasm.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2021 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build !arm64 || !gc || purego 6 | // +build !arm64 !gc purego 7 | 8 | package field 9 | 10 | func (v *Element) carryPropagate() *Element { 11 | return v.carryPropagateGeneric() 12 | } 13 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/sha3/keccakf_amd64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build amd64 && !purego && gc 6 | // +build amd64,!purego,gc 7 | 8 | package sha3 9 | 10 | // This function is implemented in keccakf_amd64.s. 11 | 12 | //go:noescape 13 | 14 | func keccakF1600(a *[25]uint64) 15 | -------------------------------------------------------------------------------- /vendor/github.com/go-gl/glfw/v3.3/glfw/c_glfw_darwin.go: -------------------------------------------------------------------------------- 1 | package glfw 2 | 3 | /* 4 | #cgo CFLAGS: -x objective-c 5 | #include "glfw/src/cocoa_init.m" 6 | #include "glfw/src/cocoa_joystick.m" 7 | #include "glfw/src/cocoa_monitor.m" 8 | #include "glfw/src/cocoa_window.m" 9 | #include "glfw/src/cocoa_time.c" 10 | #include "glfw/src/posix_thread.c" 11 | #include "glfw/src/nsgl_context.m" 12 | #include "glfw/src/egl_context.c" 13 | */ 14 | import "C" 15 | -------------------------------------------------------------------------------- /vendor/golang.org/x/text/encoding/simplifiedchinese/all.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package simplifiedchinese 6 | 7 | import ( 8 | "golang.org/x/text/encoding" 9 | ) 10 | 11 | // All is a list of all defined encodings in this package. 12 | var All = []encoding.Encoding{GB18030, GBK, HZGB2312} 13 | -------------------------------------------------------------------------------- /vendor/golang.org/x/text/internal/language/common.go: -------------------------------------------------------------------------------- 1 | // Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT. 2 | 3 | package language 4 | 5 | // This file contains code common to the maketables.go and the package code. 6 | 7 | // AliasType is the type of an alias in AliasMap. 8 | type AliasType int8 9 | 10 | const ( 11 | Deprecated AliasType = iota 12 | Macro 13 | Legacy 14 | 15 | AliasTypeUnknown AliasType = -1 16 | ) 17 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_mips64x.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build mips64 || mips64le 6 | // +build mips64 mips64le 7 | 8 | package cpu 9 | 10 | const cacheLineSize = 32 11 | 12 | func initOptions() { 13 | options = []option{ 14 | {Name: "msa", Feature: &MIPS64X.HasMSA}, 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_linux.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build !386 && !amd64 && !amd64p32 && !arm64 6 | // +build !386,!amd64,!amd64p32,!arm64 7 | 8 | package cpu 9 | 10 | func archInit() { 11 | if err := readHWCAP(); err != nil { 12 | return 13 | } 14 | doinit() 15 | Initialized = true 16 | } 17 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/curve25519/internal/field/fe_amd64_noasm.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build !amd64 || !gc || purego 6 | // +build !amd64 !gc purego 7 | 8 | package field 9 | 10 | func feMul(v, x, y *Element) { feMulGeneric(v, x, y) } 11 | 12 | func feSquare(v, x *Element) { feSquareGeneric(v, x) } 13 | -------------------------------------------------------------------------------- /vendor/golang.org/x/exp/shiny/driver/internal/swizzle/swizzle_other.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build !amd64 6 | // +build !amd64 7 | 8 | package swizzle 9 | 10 | const ( 11 | useBGRA16 = false 12 | useBGRA4 = false 13 | ) 14 | 15 | func bgra16(p []byte) { panic("unreachable") } 16 | func bgra4(p []byte) { panic("unreachable") } 17 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/curve25519/internal/field/fe_arm64.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2020 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build arm64 && gc && !purego 6 | // +build arm64,gc,!purego 7 | 8 | package field 9 | 10 | //go:noescape 11 | func carryPropagate(v *Element) 12 | 13 | func (v *Element) carryPropagate() *Element { 14 | carryPropagate(v) 15 | return v 16 | } 17 | -------------------------------------------------------------------------------- /vendor/golang.org/x/exp/shiny/driver/driver_darwin.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build darwin && !metal 6 | // +build darwin,!metal 7 | 8 | package driver 9 | 10 | import ( 11 | "golang.org/x/exp/shiny/driver/gldriver" 12 | "golang.org/x/exp/shiny/screen" 13 | ) 14 | 15 | func main(f func(screen.Screen)) { 16 | gldriver.Main(f) 17 | } 18 | -------------------------------------------------------------------------------- /vendor/golang.org/x/exp/shiny/driver/mtldriver_darwin.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build darwin && metal 6 | // +build darwin,metal 7 | 8 | package driver 9 | 10 | import ( 11 | "golang.org/x/exp/shiny/driver/mtldriver" 12 | "golang.org/x/exp/shiny/screen" 13 | ) 14 | 15 | func main(f func(screen.Screen)) { 16 | mtldriver.Main(f) 17 | } 18 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_ppc64x.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build ppc64 || ppc64le 6 | // +build ppc64 ppc64le 7 | 8 | package cpu 9 | 10 | const cacheLineSize = 128 11 | 12 | func initOptions() { 13 | options = []option{ 14 | {Name: "darn", Feature: &PPC64.HasDARN}, 15 | {Name: "scv", Feature: &PPC64.HasSCV}, 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /vendor/github.com/as/frame/chop.go: -------------------------------------------------------------------------------- 1 | package frame 2 | 3 | import ( 4 | "image" 5 | ) 6 | 7 | // trim destroys boxes that went off frame 8 | func (f *Frame) trim(pt image.Point, p int64, bn int) { 9 | for ; bn < f.Nbox; bn++ { 10 | b := &f.Box[bn] 11 | if pt = f.wrapMax(pt, b); pt.Y >= f.r.Max.Y { 12 | break 13 | } 14 | p += int64(b.Len()) 15 | pt = f.advance(pt, b) 16 | } 17 | f.Nchars = p 18 | f.Nlines = f.maxlines 19 | if bn < f.Nbox { 20 | f.Run.Delete(bn, f.Nbox-1) 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/curve25519/internal/field/fe_amd64.go: -------------------------------------------------------------------------------- 1 | // Code generated by command: go run fe_amd64_asm.go -out ../fe_amd64.s -stubs ../fe_amd64.go -pkg field. DO NOT EDIT. 2 | 3 | // +build amd64,gc,!purego 4 | 5 | package field 6 | 7 | // feMul sets out = a * b. It works like feMulGeneric. 8 | //go:noescape 9 | func feMul(out *Element, a *Element, b *Element) 10 | 11 | // feSquare sets out = a * a. It works like feSquareGeneric. 12 | //go:noescape 13 | func feSquare(out *Element, a *Element) 14 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/asm_aix_ppc64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build gc 6 | // +build gc 7 | 8 | #include "textflag.h" 9 | 10 | // 11 | // System calls for ppc64, AIX are implemented in runtime/syscall_aix.go 12 | // 13 | 14 | TEXT ·syscall6(SB),NOSPLIT,$0-88 15 | JMP syscall·syscall6(SB) 16 | 17 | TEXT ·rawSyscall6(SB),NOSPLIT,$0-88 18 | JMP syscall·rawSyscall6(SB) 19 | -------------------------------------------------------------------------------- /vendor/golang.org/x/exp/shiny/driver/driver_x11.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (linux && !android) || dragonfly || openbsd 6 | // +build linux,!android dragonfly openbsd 7 | 8 | package driver 9 | 10 | import ( 11 | "golang.org/x/exp/shiny/driver/x11driver" 12 | "golang.org/x/exp/shiny/screen" 13 | ) 14 | 15 | func main(f func(screen.Screen)) { 16 | x11driver.Main(f) 17 | } 18 | -------------------------------------------------------------------------------- /x/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "io" 6 | "log" 7 | "os" 8 | "strings" 9 | ) 10 | 11 | func main() { 12 | in := os.Stdin 13 | out := os.Stdout 14 | var p [65536]byte 15 | w := &Win{R: nil, Q0: 0, Q1: 0} 16 | cmd := Cmdparse(strings.Join(os.Args[1:], " ")) 17 | for { 18 | n, err := in.Read(p[:]) 19 | if err != nil { 20 | if err != io.EOF { 21 | log.Println(err) 22 | } 23 | return 24 | } 25 | w.R = p[:n] 26 | cmd.fn(w) 27 | io.Copy(out, bytes.NewReader(w.Bytes())) 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/chacha20/chacha_noasm.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (!arm64 && !s390x && !ppc64le) || (arm64 && !go1.11) || !gc || purego 6 | // +build !arm64,!s390x,!ppc64le arm64,!go1.11 !gc purego 7 | 8 | package chacha20 9 | 10 | const bufSize = blockSize 11 | 12 | func (s *Cipher) xorKeyStreamBlocks(dst, src []byte) { 13 | s.xorKeyStreamBlocksGeneric(dst, src) 14 | } 15 | -------------------------------------------------------------------------------- /vendor/github.com/as/edit/rec.go: -------------------------------------------------------------------------------- 1 | package edit 2 | 3 | // Recorder is an overlay over an Editor that prevents mutable 4 | // changes from occuring. 5 | type Recorder struct { 6 | Editor 7 | } 8 | 9 | func (r *Recorder) Write(p []byte) (int, error) { 10 | return len(p), nil 11 | } 12 | func (r *Recorder) WriteAt(p []byte, at int64) (int, error) { 13 | return len(p), nil 14 | } 15 | func (r *Recorder) Insert(p []byte, at int64) (n int) { 16 | return len(p) 17 | } 18 | func (r *Recorder) Delete(q0, q1 int64) (n int) { 19 | return int(q1 - q0) 20 | } 21 | -------------------------------------------------------------------------------- /vendor/github.com/as/io/rev/rev.go: -------------------------------------------------------------------------------- 1 | package rev 2 | 3 | import "io" 4 | 5 | type Reader struct { 6 | b []byte 7 | i int 8 | } 9 | 10 | func NewReader(b []byte) *Reader { 11 | return &Reader{ 12 | b: b, 13 | i: len(b), 14 | } 15 | } 16 | 17 | func (r *Reader) Read(p []byte) (n int, err error) { 18 | pl := len(p) 19 | for { 20 | r.i-- 21 | if r.i < 0 { 22 | if n == 0 { 23 | return 0, io.EOF 24 | } 25 | return n, nil 26 | } 27 | if n >= pl { 28 | return n, err 29 | } 30 | p[n] = r.b[r.i] 31 | n++ 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/sha3/register.go: -------------------------------------------------------------------------------- 1 | // Copyright 2014 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build go1.4 6 | // +build go1.4 7 | 8 | package sha3 9 | 10 | import ( 11 | "crypto" 12 | ) 13 | 14 | func init() { 15 | crypto.RegisterHash(crypto.SHA3_224, New224) 16 | crypto.RegisterHash(crypto.SHA3_256, New256) 17 | crypto.RegisterHash(crypto.SHA3_384, New384) 18 | crypto.RegisterHash(crypto.SHA3_512, New512) 19 | } 20 | -------------------------------------------------------------------------------- /vendor/golang.org/x/exp/shiny/driver/internal/swizzle/swizzle_amd64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package swizzle 6 | 7 | // haveSSSE3 returns whether the CPU supports SSSE3 instructions (i.e. PSHUFB). 8 | // 9 | // Note that this is SSSE3, not SSE3. 10 | func haveSSSE3() bool 11 | 12 | var useBGRA16 = haveSSSE3() 13 | 14 | const useBGRA4 = true 15 | 16 | func bgra16(p []byte) 17 | func bgra4(p []byte) 18 | -------------------------------------------------------------------------------- /vendor/github.com/as/frame/box/box.go: -------------------------------------------------------------------------------- 1 | package box 2 | 3 | const SLOP = 25 4 | 5 | type Box struct { 6 | Nrune int 7 | Ptr []byte 8 | Width int 9 | Minwidth int 10 | } 11 | 12 | func (b *Box) Break() byte { 13 | n := b.Len() 14 | if n == 0 { 15 | return 0 16 | } 17 | return b.Ptr[0] 18 | } 19 | 20 | func (b *Box) Len() int { 21 | if b.Nrune < 0 { 22 | return 1 23 | } 24 | return b.Nrune 25 | } 26 | 27 | func (b *Box) Bytes() []byte { 28 | n := b.Len() 29 | if n <= 0 { 30 | return nil 31 | } 32 | return b.Ptr[:n] 33 | } 34 | -------------------------------------------------------------------------------- /vendor/github.com/basgys/goxml2json/converter.go: -------------------------------------------------------------------------------- 1 | package xml2json 2 | 3 | import ( 4 | "bytes" 5 | "io" 6 | ) 7 | 8 | // Convert converts the given XML document to JSON 9 | func Convert(r io.Reader) (*bytes.Buffer, error) { 10 | // Decode XML document 11 | root := &Node{} 12 | err := NewDecoder(r).Decode(root) 13 | if err != nil { 14 | return nil, err 15 | } 16 | 17 | // Then encode it in JSON 18 | buf := new(bytes.Buffer) 19 | err = NewEncoder(buf).Encode(root) 20 | if err != nil { 21 | return nil, err 22 | } 23 | 24 | return buf, nil 25 | } 26 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_wasm.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build wasm 6 | // +build wasm 7 | 8 | package cpu 9 | 10 | // We're compiling the cpu package for an unknown (software-abstracted) CPU. 11 | // Make CacheLinePad an empty struct and hope that the usual struct alignment 12 | // rules are good enough. 13 | 14 | const cacheLineSize = 0 15 | 16 | func initOptions() {} 17 | 18 | func archInit() {} 19 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/chacha20/chacha_ppc64le.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build gc && !purego 6 | // +build gc,!purego 7 | 8 | package chacha20 9 | 10 | const bufSize = 256 11 | 12 | //go:noescape 13 | func chaCha20_ctr32_vsx(out, inp *byte, len int, key *[8]uint32, counter *uint32) 14 | 15 | func (c *Cipher) xorKeyStreamBlocks(dst, src []byte) { 16 | chaCha20_ctr32_vsx(&dst[0], &src[0], len(src), &c.key, &c.counter) 17 | } 18 | -------------------------------------------------------------------------------- /vendor/github.com/as/frame/rgba.go: -------------------------------------------------------------------------------- 1 | package frame 2 | 3 | import ( 4 | "image" 5 | "image/color" 6 | ) 7 | 8 | // copied from github.com/as/rgba to avoid a dependency 9 | 10 | // hex converts a 32-bit RGBA quad to a color.RGBA 11 | func hex(rgba uint32) color.RGBA { 12 | return color.RGBA{ 13 | R: uint8(rgba >> 24), 14 | G: uint8(rgba << 8 >> 24), 15 | B: uint8(rgba << 16 >> 24), 16 | A: uint8(rgba << 24 >> 24), 17 | } 18 | } 19 | 20 | // uniform is short for image.NewUniform(hex(rgba)) 21 | func uniform(rgba uint32) *image.Uniform { 22 | return image.NewUniform(hex(rgba)) 23 | } 24 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/chacha20/chacha_arm64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build go1.11 && gc && !purego 6 | // +build go1.11,gc,!purego 7 | 8 | package chacha20 9 | 10 | const bufSize = 256 11 | 12 | //go:noescape 13 | func xorKeyStreamVX(dst, src []byte, key *[8]uint32, nonce *[3]uint32, counter *uint32) 14 | 15 | func (c *Cipher) xorKeyStreamBlocks(dst, src []byte) { 16 | xorKeyStreamVX(dst, src, &c.key, &c.nonce, &c.counter) 17 | } 18 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/race0.go: -------------------------------------------------------------------------------- 1 | // Copyright 2012 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build windows,!race 6 | 7 | package windows 8 | 9 | import ( 10 | "unsafe" 11 | ) 12 | 13 | const raceenabled = false 14 | 15 | func raceAcquire(addr unsafe.Pointer) { 16 | } 17 | 18 | func raceReleaseMerge(addr unsafe.Pointer) { 19 | } 20 | 21 | func raceReadRange(addr unsafe.Pointer, len int) { 22 | } 23 | 24 | func raceWriteRange(addr unsafe.Pointer, len int) { 25 | } 26 | -------------------------------------------------------------------------------- /xo/level.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "os" 6 | ) 7 | 8 | type level int 9 | 10 | var verb level 11 | 12 | func (v level) Printf(fm string, i ...interface{}) (n int, err error) { 13 | if verb < 1 { 14 | return 15 | } 16 | return fmt.Fprintf(os.Stderr, fm, i...) 17 | } 18 | func (v level) Println(i ...interface{}) (n int, err error) { 19 | if verb < 1 { 20 | return 21 | } 22 | return fmt.Fprintln(os.Stderr, i...) 23 | } 24 | func (v level) Print(i ...interface{}) (n int, err error) { 25 | if verb < 1 { 26 | return 27 | } 28 | return fmt.Fprint(os.Stderr, i...) 29 | } 30 | -------------------------------------------------------------------------------- /vendor/github.com/go-gl/glfw/v3.3/glfw/monitor.c: -------------------------------------------------------------------------------- 1 | #include "_cgo_export.h" 2 | 3 | GLFWmonitor *GetMonitorAtIndex(GLFWmonitor **monitors, int index) { 4 | return monitors[index]; 5 | } 6 | 7 | GLFWvidmode GetVidmodeAtIndex(GLFWvidmode *vidmodes, int index) { 8 | return vidmodes[index]; 9 | } 10 | 11 | void glfwSetMonitorCallbackCB() { 12 | glfwSetMonitorCallback((GLFWmonitorfun)goMonitorCB); 13 | } 14 | 15 | unsigned int GetGammaAtIndex(unsigned short *color, int i) { return color[i]; } 16 | 17 | void SetGammaAtIndex(unsigned short *color, int i, unsigned short value) { 18 | color[i] = value; 19 | } 20 | -------------------------------------------------------------------------------- /vendor/github.com/as/xo/verb.go: -------------------------------------------------------------------------------- 1 | package xo 2 | 3 | import ( 4 | "fmt" 5 | "os" 6 | ) 7 | 8 | type level int 9 | 10 | var verb level 11 | 12 | func (v level) Printf(fm string, i ...interface{}) (n int, err error) { 13 | if verb < 1 { 14 | return 15 | } 16 | return fmt.Fprintf(os.Stderr, fm, i...) 17 | } 18 | func (v level) Println(i ...interface{}) (n int, err error) { 19 | if verb < 1 { 20 | return 21 | } 22 | return fmt.Fprintln(os.Stderr, i...) 23 | } 24 | func (v level) Print(i ...interface{}) (n int, err error) { 25 | if verb < 1 { 26 | return 27 | } 28 | return fmt.Fprint(os.Stderr, i...) 29 | } 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/str.go: -------------------------------------------------------------------------------- 1 | // Copyright 2009 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build windows 6 | 7 | package windows 8 | 9 | func itoa(val int) string { // do it here rather than with fmt to avoid dependency 10 | if val < 0 { 11 | return "-" + itoa(-val) 12 | } 13 | var buf [32]byte // big enough for int64 14 | i := len(buf) - 1 15 | for val >= 10 { 16 | buf[i] = byte(val%10 + '0') 17 | i-- 18 | val /= 10 19 | } 20 | buf[i] = byte(val + '0') 21 | return string(buf[i:]) 22 | } 23 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/poly1305/bits_go1.13.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build go1.13 6 | // +build go1.13 7 | 8 | package poly1305 9 | 10 | import "math/bits" 11 | 12 | func bitsAdd64(x, y, carry uint64) (sum, carryOut uint64) { 13 | return bits.Add64(x, y, carry) 14 | } 15 | 16 | func bitsSub64(x, y, borrow uint64) (diff, borrowOut uint64) { 17 | return bits.Sub64(x, y, borrow) 18 | } 19 | 20 | func bitsMul64(x, y uint64) (hi, lo uint64) { 21 | return bits.Mul64(x, y) 22 | } 23 | -------------------------------------------------------------------------------- /vendor/github.com/golang/freetype/LICENSE: -------------------------------------------------------------------------------- 1 | Use of the Freetype-Go software is subject to your choice of exactly one of 2 | the following two licenses: 3 | * The FreeType License, which is similar to the original BSD license with 4 | an advertising clause, or 5 | * The GNU General Public License (GPL), version 2 or later. 6 | 7 | The text of these licenses are available in the licenses/ftl.txt and the 8 | licenses/gpl.txt files respectively. They are also available at 9 | http://freetype.sourceforge.net/license.html 10 | 11 | The Luxi fonts in the testdata directory are licensed separately. See the 12 | testdata/COPYING file for details. 13 | -------------------------------------------------------------------------------- /vendor/github.com/as/mute/mute.go: -------------------------------------------------------------------------------- 1 | // This package was created before "flags" had an option for this 2 | 3 | package mute 4 | 5 | import ( 6 | "os" 7 | "flag" 8 | ) 9 | 10 | // Parse silences the noisy flag package Parse() methods 11 | // instead returning errors properly via the error variable 12 | func Parse(f *flag.FlagSet, a []string) error { 13 | n, err := os.Open(os.DevNull) 14 | if err != nil { 15 | return err 16 | } 17 | 18 | n, os.Stderr = os.Stderr, n 19 | defer func() { 20 | n, os.Stderr = os.Stderr, n 21 | }() 22 | 23 | err = f.Parse(a) 24 | if err != nil { 25 | return err 26 | } 27 | 28 | return nil 29 | } 30 | 31 | -------------------------------------------------------------------------------- /vendor/golang.org/x/exp/shiny/driver/mtldriver/internal/appkit/appkit.m: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build darwin 6 | 7 | #import 8 | #include "appkit.h" 9 | 10 | void * Window_ContentView(void * window) { 11 | return ((NSWindow *)window).contentView; 12 | } 13 | 14 | void View_SetLayer(void * view, void * layer) { 15 | ((NSView *)view).layer = (CALayer *)layer; 16 | } 17 | 18 | void View_SetWantsLayer(void * view, bool wantsLayer) { 19 | ((NSView *)view).wantsLayer = wantsLayer; 20 | } 21 | -------------------------------------------------------------------------------- /vendor/github.com/basgys/goxml2json/struct.go: -------------------------------------------------------------------------------- 1 | package xml2json 2 | 3 | // Node is a data element on a tree 4 | type Node struct { 5 | Children map[string]Nodes 6 | Data string 7 | } 8 | 9 | // Nodes is a list of nodes 10 | type Nodes []*Node 11 | 12 | // AddChild appends a node to the list of children 13 | func (n *Node) AddChild(s string, c *Node) { 14 | // Lazy lazy 15 | if n.Children == nil { 16 | n.Children = map[string]Nodes{} 17 | } 18 | 19 | n.Children[s] = append(n.Children[s], c) 20 | } 21 | 22 | // IsComplex returns whether it is a complex type (has children) 23 | func (n *Node) IsComplex() bool { 24 | return len(n.Children) > 0 25 | } 26 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_linux_mips64x.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build linux && (mips64 || mips64le) 6 | // +build linux 7 | // +build mips64 mips64le 8 | 9 | package cpu 10 | 11 | // HWCAP bits. These are exposed by the Linux kernel 5.4. 12 | const ( 13 | // CPU features 14 | hwcap_MIPS_MSA = 1 << 1 15 | ) 16 | 17 | func doinit() { 18 | // HWCAP feature bits 19 | MIPS64X.HasMSA = isSet(hwCap, hwcap_MIPS_MSA) 20 | } 21 | 22 | func isSet(hwc uint, value uint) bool { 23 | return hwc&value != 0 24 | } 25 | -------------------------------------------------------------------------------- /vendor/github.com/as/text/dist.go: -------------------------------------------------------------------------------- 1 | package text 2 | 3 | func min(a, b int) int { 4 | if a < b { 5 | return a 6 | } 7 | return b 8 | } 9 | func min3(a, b, c int) int { 10 | return min(c, min(a, b)) 11 | } 12 | 13 | func Distance(s, t []byte) int { 14 | dtab := make([]int, len(s)+1) 15 | 16 | for i := range dtab { 17 | dtab[i] = i 18 | } 19 | for j := 1; j <= len(t); j++ { 20 | last := dtab[0] 21 | dtab[0] = j 22 | for i := 1; i <= len(s); i++ { 23 | if s[i-1] == t[j-1] { 24 | dtab[i], last = last, dtab[i] 25 | } else { 26 | dtab[i], last = min3(last, dtab[i], dtab[i-1])+1, dtab[i] 27 | } 28 | } 29 | } 30 | return dtab[len(s)] 31 | } 32 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/sha3/shake_generic.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build !gc || purego || !s390x 6 | // +build !gc purego !s390x 7 | 8 | package sha3 9 | 10 | // newShake128Asm returns an assembly implementation of SHAKE-128 if available, 11 | // otherwise it returns nil. 12 | func newShake128Asm() ShakeHash { 13 | return nil 14 | } 15 | 16 | // newShake256Asm returns an assembly implementation of SHAKE-256 if available, 17 | // otherwise it returns nil. 18 | func newShake256Asm() ShakeHash { 19 | return nil 20 | } 21 | -------------------------------------------------------------------------------- /vendor/github.com/as/frame/clean.go: -------------------------------------------------------------------------------- 1 | package frame 2 | 3 | import ( 4 | "image" 5 | ) 6 | 7 | func (f *Frame) clean(pt image.Point, n0, n1 int) { 8 | c := f.r.Max.X 9 | for ; n0 < n1-1; n0++ { 10 | b0 := &f.Box[n0] 11 | b1 := &f.Box[n0+1] 12 | pt = f.wrapMax(pt, b0) 13 | for b0.Nrune >= 0 && n0 < n1-1 && b1.Nrune >= 0 && pt.X+b0.Width+b1.Width < c { 14 | f.Merge(n0) 15 | n1-- 16 | } 17 | 18 | pt = f.advance(pt, &f.Box[n0]) // dont simplify this 19 | } 20 | 21 | for ; n0 < f.Nbox; n0++ { 22 | b0 := &f.Box[n0] 23 | pt = f.wrapMax(pt, b0) 24 | pt = f.advance(pt, b0) 25 | } 26 | 27 | f.full = 0 28 | if pt.Y >= f.r.Max.Y { 29 | f.full = 1 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /vendor/github.com/go-gl/glfw/v3.3/glfw/c_glfw_linbsd.go: -------------------------------------------------------------------------------- 1 | // +build linux freebsd 2 | 3 | package glfw 4 | 5 | /* 6 | #ifdef _GLFW_WAYLAND 7 | #include "glfw/src/wl_init.c" 8 | #include "glfw/src/wl_monitor.c" 9 | #include "glfw/src/wl_window.c" 10 | #include "glfw/src/wl_platform.h" 11 | #endif 12 | #ifdef _GLFW_X11 13 | #include "glfw/src/x11_init.c" 14 | #include "glfw/src/x11_monitor.c" 15 | #include "glfw/src/x11_window.c" 16 | #include "glfw/src/glx_context.c" 17 | #endif 18 | #include "glfw/src/linux_joystick.c" 19 | #include "glfw/src/posix_time.c" 20 | #include "glfw/src/posix_thread.c" 21 | #include "glfw/src/xkb_unicode.c" 22 | #include "glfw/src/egl_context.c" 23 | */ 24 | import "C" 25 | -------------------------------------------------------------------------------- /vendor/golang.org/x/exp/shiny/driver/mtldriver/buffer.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build darwin 6 | // +build darwin 7 | 8 | package mtldriver 9 | 10 | import "image" 11 | 12 | // bufferImpl implements screen.Buffer. 13 | type bufferImpl struct { 14 | rgba *image.RGBA 15 | } 16 | 17 | func (*bufferImpl) Release() {} 18 | func (b *bufferImpl) Size() image.Point { return b.rgba.Rect.Max } 19 | func (b *bufferImpl) Bounds() image.Rectangle { return b.rgba.Rect } 20 | func (b *bufferImpl) RGBA() *image.RGBA { return b.rgba } 21 | -------------------------------------------------------------------------------- /vendor/github.com/BurntSushi/xgb/AUTHORS: -------------------------------------------------------------------------------- 1 | Andrew Gallant is the maintainer of this fork. What follows is the original 2 | list of authors for the x-go-binding. 3 | 4 | # This is the official list of XGB authors for copyright purposes. 5 | # This file is distinct from the CONTRIBUTORS files. 6 | # See the latter for an explanation. 7 | 8 | # Names should be added to this file as 9 | # Name or Organization 10 | # The email address is not required for organizations. 11 | 12 | # Please keep the list sorted. 13 | 14 | Anthony Martin 15 | Firmansyah Adiputra 16 | Google Inc. 17 | Scott Lawrence 18 | Tor Andersson 19 | -------------------------------------------------------------------------------- /vendor/github.com/as/frame/config.go: -------------------------------------------------------------------------------- 1 | package frame 2 | 3 | import ( 4 | "github.com/as/font" 5 | ) 6 | 7 | type Config struct { 8 | Flag int 9 | Scroll func(int) 10 | Color Color 11 | Face font.Face 12 | Drawer Drawer 13 | } 14 | 15 | func (c *Config) check() *Config { 16 | if c.Color == zc { 17 | c.Color = A 18 | } 19 | if c.Face == nil { 20 | c.Face = font.NewFace(11) 21 | } 22 | if c.Drawer == nil { 23 | c.Drawer = &defaultDrawer{} 24 | } 25 | return c 26 | } 27 | 28 | func getflag(flag ...int) (fl int) { 29 | if len(flag) != 0 { 30 | fl = flag[0] 31 | } 32 | if ForceElastic { 33 | fl |= FrElastic 34 | } 35 | if ForceUTF8 { 36 | fl |= FrUTF8 37 | } 38 | return fl 39 | } 40 | -------------------------------------------------------------------------------- /vendor/golang.org/x/image/tiff/fuzz.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build gofuzz 6 | // +build gofuzz 7 | 8 | package tiff 9 | 10 | import "bytes" 11 | 12 | func Fuzz(data []byte) int { 13 | cfg, err := DecodeConfig(bytes.NewReader(data)) 14 | if err != nil { 15 | return 0 16 | } 17 | if cfg.Width*cfg.Height > 1e6 { 18 | return 0 19 | } 20 | img, err := Decode(bytes.NewReader(data)) 21 | if err != nil { 22 | return 0 23 | } 24 | var w bytes.Buffer 25 | err = Encode(&w, img, nil) 26 | if err != nil { 27 | panic(err) 28 | } 29 | return 1 30 | } 31 | -------------------------------------------------------------------------------- /vendor/golang.org/x/exp/shiny/driver/driver_fallback.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build !darwin && (!linux || android) && !windows && !dragonfly && !openbsd 6 | // +build !darwin 7 | // +build !linux android 8 | // +build !windows 9 | // +build !dragonfly 10 | // +build !openbsd 11 | 12 | package driver 13 | 14 | import ( 15 | "errors" 16 | 17 | "golang.org/x/exp/shiny/driver/internal/errscreen" 18 | "golang.org/x/exp/shiny/screen" 19 | ) 20 | 21 | func main(f func(screen.Screen)) { 22 | f(errscreen.Stub(errors.New("no driver for accessing a screen"))) 23 | } 24 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/curve25519/internal/field/sync.sh: -------------------------------------------------------------------------------- 1 | #! /bin/bash 2 | set -euo pipefail 3 | 4 | cd "$(git rev-parse --show-toplevel)" 5 | 6 | STD_PATH=src/crypto/ed25519/internal/edwards25519/field 7 | LOCAL_PATH=curve25519/internal/field 8 | LAST_SYNC_REF=$(cat $LOCAL_PATH/sync.checkpoint) 9 | 10 | git fetch https://go.googlesource.com/go master 11 | 12 | if git diff --quiet $LAST_SYNC_REF:$STD_PATH FETCH_HEAD:$STD_PATH; then 13 | echo "No changes." 14 | else 15 | NEW_REF=$(git rev-parse FETCH_HEAD | tee $LOCAL_PATH/sync.checkpoint) 16 | echo "Applying changes from $LAST_SYNC_REF to $NEW_REF..." 17 | git diff $LAST_SYNC_REF:$STD_PATH FETCH_HEAD:$STD_PATH | \ 18 | git apply -3 --directory=$LOCAL_PATH 19 | fi 20 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/sha3/xor.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (!amd64 && !386 && !ppc64le) || purego 6 | // +build !amd64,!386,!ppc64le purego 7 | 8 | package sha3 9 | 10 | // A storageBuf is an aligned array of maxRate bytes. 11 | type storageBuf [maxRate]byte 12 | 13 | func (b *storageBuf) asBytes() *[maxRate]byte { 14 | return (*[maxRate]byte)(b) 15 | } 16 | 17 | var ( 18 | xorIn = xorInGeneric 19 | copyOut = copyOutGeneric 20 | xorInUnaligned = xorInGeneric 21 | copyOutUnaligned = copyOutGeneric 22 | ) 23 | 24 | const xorImplementationUnaligned = "generic" 25 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/race.go: -------------------------------------------------------------------------------- 1 | // Copyright 2012 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build windows,race 6 | 7 | package windows 8 | 9 | import ( 10 | "runtime" 11 | "unsafe" 12 | ) 13 | 14 | const raceenabled = true 15 | 16 | func raceAcquire(addr unsafe.Pointer) { 17 | runtime.RaceAcquire(addr) 18 | } 19 | 20 | func raceReleaseMerge(addr unsafe.Pointer) { 21 | runtime.RaceReleaseMerge(addr) 22 | } 23 | 24 | func raceReadRange(addr unsafe.Pointer, len int) { 25 | runtime.RaceReadRange(addr, len) 26 | } 27 | 28 | func raceWriteRange(addr unsafe.Pointer, len int) { 29 | runtime.RaceWriteRange(addr, len) 30 | } 31 | -------------------------------------------------------------------------------- /vendor/github.com/go-gl/glfw/v3.3/glfw/vulkan.go: -------------------------------------------------------------------------------- 1 | package glfw 2 | 3 | //#define GLFW_INCLUDE_NONE 4 | //#include "glfw/include/GLFW/glfw3.h" 5 | import "C" 6 | 7 | // VulkanSupported reports whether the Vulkan loader has been found. This check is performed by Init. 8 | // 9 | // The availability of a Vulkan loader does not by itself guarantee that window surface creation or 10 | // even device creation is possible. Call GetRequiredInstanceExtensions to check whether the 11 | // extensions necessary for Vulkan surface creation are available and GetPhysicalDevicePresentationSupport 12 | // to check whether a queue family of a physical device supports image presentation. 13 | func VulkanSupported() bool { 14 | return glfwbool(C.glfwVulkanSupported()) 15 | } 16 | -------------------------------------------------------------------------------- /vendor/golang.org/x/exp/shiny/driver/x11driver/shm_other.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build !linux && !dragonfly && !openbsd 6 | // +build !linux,!dragonfly,!openbsd 7 | 8 | package x11driver 9 | 10 | import ( 11 | "fmt" 12 | "runtime" 13 | "unsafe" 14 | ) 15 | 16 | func shmOpen(size int) (shmid uintptr, addr unsafe.Pointer, err error) { 17 | return 0, unsafe.Pointer(uintptr(0)), 18 | fmt.Errorf("unsupported GOOS/GOARCH %s/%s", runtime.GOOS, runtime.GOARCH) 19 | } 20 | 21 | func shmClose(p unsafe.Pointer) error { 22 | return fmt.Errorf("unsupported GOOS/GOARCH %s/%s", runtime.GOOS, runtime.GOARCH) 23 | } 24 | -------------------------------------------------------------------------------- /vendor/github.com/go-gl/glfw/v3.3/glfw/util.go: -------------------------------------------------------------------------------- 1 | package glfw 2 | 3 | //#include 4 | //#define GLFW_INCLUDE_NONE 5 | //#include "glfw/include/GLFW/glfw3.h" 6 | import "C" 7 | 8 | import ( 9 | "reflect" 10 | "unsafe" 11 | ) 12 | 13 | func glfwbool(b C.int) bool { 14 | if b == C.int(True) { 15 | return true 16 | } 17 | return false 18 | } 19 | 20 | func bytes(origin []byte) (pointer *uint8, free func()) { 21 | n := len(origin) 22 | 23 | if n == 0 { 24 | return nil, func() {} 25 | } 26 | 27 | data := C.malloc(C.size_t(n)) 28 | 29 | dataSlice := *(*[]byte)(unsafe.Pointer(&reflect.SliceHeader{ 30 | Data: uintptr(data), 31 | Len: n, 32 | Cap: n, 33 | })) 34 | 35 | copy(dataSlice, origin) 36 | 37 | return &dataSlice[0], func() { C.free(data) } 38 | } 39 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_zos_s390x.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package cpu 6 | 7 | func initS390Xbase() { 8 | // get the facilities list 9 | facilities := stfle() 10 | 11 | // mandatory 12 | S390X.HasZARCH = facilities.Has(zarch) 13 | S390X.HasSTFLE = facilities.Has(stflef) 14 | S390X.HasLDISP = facilities.Has(ldisp) 15 | S390X.HasEIMM = facilities.Has(eimm) 16 | 17 | // optional 18 | S390X.HasETF3EH = facilities.Has(etf3eh) 19 | S390X.HasDFP = facilities.Has(dfp) 20 | S390X.HasMSA = facilities.Has(msa) 21 | S390X.HasVX = facilities.Has(vx) 22 | if S390X.HasVX { 23 | S390X.HasVXE = facilities.Has(vxe) 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /vendor/github.com/as/text/file.go: -------------------------------------------------------------------------------- 1 | package text 2 | 3 | /* 4 | type ReadWriteSeekCloser interface{ 5 | io.ReadWriteSeeker 6 | io.Closer 7 | } 8 | 9 | func (f *file) Insert(p []byte, at int64) (n int){ 10 | at, err = f.f.Seek(at, io.SeekStart) 11 | if err==nil{return} 12 | dx := len(p) 13 | dy := 4096 14 | tmp := make([]byte, dy) 15 | sp := f.f.Len()-1 16 | for { 17 | _, _ = f.f.Seek(sp, io.SeekCurrent) 18 | if sp-dy < at+dx{ 19 | sp -= dy+(sp-dy) (at+dx) 20 | } 21 | 22 | } 23 | 24 | 25 | } 26 | 27 | type File struct{ 28 | f ReadWriteSeekCloser 29 | Insert(p []byte, at int64) (n int) 30 | Delete(q0, q1 int64) (n int) 31 | Len() int64 32 | ReadAt(p []byte, at int64) (n int, err error) 33 | WriteAt(p []byte, at int64) (n int, err error) 34 | } 35 | 36 | 37 | */ 38 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_aix.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build aix 6 | // +build aix 7 | 8 | package cpu 9 | 10 | const ( 11 | // getsystemcfg constants 12 | _SC_IMPL = 2 13 | _IMPL_POWER8 = 0x10000 14 | _IMPL_POWER9 = 0x20000 15 | ) 16 | 17 | func archInit() { 18 | impl := getsystemcfg(_SC_IMPL) 19 | if impl&_IMPL_POWER8 != 0 { 20 | PPC64.IsPOWER8 = true 21 | } 22 | if impl&_IMPL_POWER9 != 0 { 23 | PPC64.IsPOWER8 = true 24 | PPC64.IsPOWER9 = true 25 | } 26 | 27 | Initialized = true 28 | } 29 | 30 | func getsystemcfg(label int) (n uint64) { 31 | r0, _ := callgetsystemcfg(label) 32 | n = uint64(r0) 33 | return 34 | } 35 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_gc_x86.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (386 || amd64 || amd64p32) && gc 6 | // +build 386 amd64 amd64p32 7 | // +build gc 8 | 9 | package cpu 10 | 11 | // cpuid is implemented in cpu_x86.s for gc compiler 12 | // and in cpu_gccgo.c for gccgo. 13 | func cpuid(eaxArg, ecxArg uint32) (eax, ebx, ecx, edx uint32) 14 | 15 | // xgetbv with ecx = 0 is implemented in cpu_x86.s for gc compiler 16 | // and in cpu_gccgo.c for gccgo. 17 | func xgetbv() (eax, edx uint32) 18 | 19 | // darwinSupportsAVX512 is implemented in cpu_x86.s for gc compiler 20 | // and in cpu_gccgo_x86.go for gccgo. 21 | func darwinSupportsAVX512() bool 22 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_gc_s390x.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build gc 6 | // +build gc 7 | 8 | package cpu 9 | 10 | // haveAsmFunctions reports whether the other functions in this file can 11 | // be safely called. 12 | func haveAsmFunctions() bool { return true } 13 | 14 | // The following feature detection functions are defined in cpu_s390x.s. 15 | // They are likely to be expensive to call so the results should be cached. 16 | func stfle() facilityList 17 | func kmQuery() queryResult 18 | func kmcQuery() queryResult 19 | func kmctrQuery() queryResult 20 | func kmaQuery() queryResult 21 | func kimdQuery() queryResult 22 | func klmdQuery() queryResult 23 | -------------------------------------------------------------------------------- /vendor/github.com/golang/freetype/AUTHORS: -------------------------------------------------------------------------------- 1 | # This is the official list of Freetype-Go authors for copyright purposes. 2 | # This file is distinct from the CONTRIBUTORS files. 3 | # See the latter for an explanation. 4 | # 5 | # Freetype-Go is derived from Freetype, which is written in C. The latter 6 | # is copyright 1996-2010 David Turner, Robert Wilhelm, and Werner Lemberg. 7 | 8 | # Names should be added to this file as 9 | # Name or Organization 10 | # The email address is not required for organizations. 11 | 12 | # Please keep the list sorted. 13 | 14 | Google Inc. 15 | Jeff R. Allen 16 | Maksim Kochkin 17 | Michael Fogleman 18 | Rémy Oudompheng 19 | Roger Peppe 20 | Steven Edwards 21 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/sha3/xor_generic.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package sha3 6 | 7 | import "encoding/binary" 8 | 9 | // xorInGeneric xors the bytes in buf into the state; it 10 | // makes no non-portable assumptions about memory layout 11 | // or alignment. 12 | func xorInGeneric(d *state, buf []byte) { 13 | n := len(buf) / 8 14 | 15 | for i := 0; i < n; i++ { 16 | a := binary.LittleEndian.Uint64(buf) 17 | d.a[i] ^= a 18 | buf = buf[8:] 19 | } 20 | } 21 | 22 | // copyOutGeneric copies uint64s to a byte buffer. 23 | func copyOutGeneric(d *state, b []byte) { 24 | for i := 0; len(b) >= 8; i++ { 25 | binary.LittleEndian.PutUint64(b, d.a[i]) 26 | b = b[8:] 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /vendor/golang.org/x/exp/shiny/driver/windriver/other.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build !windows 6 | // +build !windows 7 | 8 | package windriver 9 | 10 | import ( 11 | "fmt" 12 | "runtime" 13 | 14 | "golang.org/x/exp/shiny/driver/internal/errscreen" 15 | "golang.org/x/exp/shiny/screen" 16 | ) 17 | 18 | // Main is called by the program's main function to run the graphical 19 | // application. 20 | // 21 | // It calls f on the Screen, possibly in a separate goroutine, as some OS- 22 | // specific libraries require being on 'the main thread'. It returns when f 23 | // returns. 24 | func Main(f func(screen.Screen)) { 25 | f(errscreen.Stub(fmt.Errorf( 26 | "windriver: unsupported GOOS/GOARCH %s/%s", runtime.GOOS, runtime.GOARCH))) 27 | } 28 | -------------------------------------------------------------------------------- /vendor/golang.org/x/text/internal/language/coverage.go: -------------------------------------------------------------------------------- 1 | // Copyright 2014 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package language 6 | 7 | // BaseLanguages returns the list of all supported base languages. It generates 8 | // the list by traversing the internal structures. 9 | func BaseLanguages() []Language { 10 | base := make([]Language, 0, NumLanguages) 11 | for i := 0; i < langNoIndexOffset; i++ { 12 | // We included "und" already for the value 0. 13 | if i != nonCanonicalUnd { 14 | base = append(base, Language(i)) 15 | } 16 | } 17 | i := langNoIndexOffset 18 | for _, v := range langNoIndex { 19 | for k := 0; k < 8; k++ { 20 | if v&1 == 1 { 21 | base = append(base, Language(i)) 22 | } 23 | v >>= 1 24 | i++ 25 | } 26 | } 27 | return base 28 | } 29 | -------------------------------------------------------------------------------- /vendor/golang.org/x/exp/shiny/driver/windriver/windriver.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build windows 6 | // +build windows 7 | 8 | package windriver 9 | 10 | import ( 11 | "golang.org/x/exp/shiny/driver/internal/errscreen" 12 | "golang.org/x/exp/shiny/driver/internal/win32" 13 | "golang.org/x/exp/shiny/screen" 14 | ) 15 | 16 | // Main is called by the program's main function to run the graphical 17 | // application. 18 | // 19 | // It calls f on the Screen, possibly in a separate goroutine, as some OS- 20 | // specific libraries require being on 'the main thread'. It returns when f 21 | // returns. 22 | func Main(f func(screen.Screen)) { 23 | if err := win32.Main(func() { f(theScreen) }); err != nil { 24 | f(errscreen.Stub(err)) 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/syscall_aix_gccgo.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Recreate a getsystemcfg syscall handler instead of 6 | // using the one provided by x/sys/unix to avoid having 7 | // the dependency between them. (See golang.org/issue/32102) 8 | // Morever, this file will be used during the building of 9 | // gccgo's libgo and thus must not used a CGo method. 10 | 11 | //go:build aix && gccgo 12 | // +build aix,gccgo 13 | 14 | package cpu 15 | 16 | import ( 17 | "syscall" 18 | ) 19 | 20 | //extern getsystemcfg 21 | func gccgoGetsystemcfg(label uint32) (r uint64) 22 | 23 | func callgetsystemcfg(label int) (r1 uintptr, e1 syscall.Errno) { 24 | r1 = uintptr(gccgoGetsystemcfg(uint32(label))) 25 | e1 = syscall.GetErrno() 26 | return 27 | } 28 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/chacha20/chacha_s390x.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build gc && !purego 6 | // +build gc,!purego 7 | 8 | package chacha20 9 | 10 | import "golang.org/x/sys/cpu" 11 | 12 | var haveAsm = cpu.S390X.HasVX 13 | 14 | const bufSize = 256 15 | 16 | // xorKeyStreamVX is an assembly implementation of XORKeyStream. It must only 17 | // be called when the vector facility is available. Implementation in asm_s390x.s. 18 | //go:noescape 19 | func xorKeyStreamVX(dst, src []byte, key *[8]uint32, nonce *[3]uint32, counter *uint32) 20 | 21 | func (c *Cipher) xorKeyStreamBlocks(dst, src []byte) { 22 | if cpu.S390X.HasVX { 23 | xorKeyStreamVX(dst, src, &c.key, &c.nonce, &c.counter) 24 | } else { 25 | c.xorKeyStreamBlocksGeneric(dst, src) 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /vendor/github.com/as/text/rec.go: -------------------------------------------------------------------------------- 1 | package text 2 | 3 | import ( 4 | "github.com/as/event" 5 | "github.com/as/worm" 6 | ) 7 | 8 | func NewRecorder(l worm.Logger) *Recorder { 9 | return &Recorder{ 10 | l: l, 11 | } 12 | } 13 | 14 | type Recorder struct { 15 | l worm.Logger 16 | } 17 | 18 | func (r *Recorder) Insert(p []byte, q0 int64) int { 19 | if len(p) == 0 { 20 | //return 0 21 | } 22 | ev := &event.Insert{event.Rec{Kind: 'i', P: p, Q0: q0, Q1: q0 + int64(len(p))}} 23 | r.l.Write(ev) 24 | return len(p) 25 | } 26 | func (r *Recorder) Delete(q0, q1 int64) int { 27 | ev := &event.Delete{event.Rec{Kind: 'd', Q0: q0, Q1: q1}} 28 | 29 | r.l.Write(ev) 30 | return int(q1 - q0) 31 | } 32 | func (r *Recorder) Write(p []byte) (int, error) { 33 | return r.Insert(p, (^int64(0))>>1), nil 34 | } 35 | func (r *Recorder) Select(q0, q1 int64) { 36 | r.l.Write(&event.Select{event.Rec{Kind: 's', Q0: q0, Q1: q1}}) 37 | } 38 | -------------------------------------------------------------------------------- /vendor/golang.org/x/text/language/go1_1.go: -------------------------------------------------------------------------------- 1 | // Copyright 2013 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build !go1.2 6 | // +build !go1.2 7 | 8 | package language 9 | 10 | import "sort" 11 | 12 | func sortStable(s sort.Interface) { 13 | ss := stableSort{ 14 | s: s, 15 | pos: make([]int, s.Len()), 16 | } 17 | for i := range ss.pos { 18 | ss.pos[i] = i 19 | } 20 | sort.Sort(&ss) 21 | } 22 | 23 | type stableSort struct { 24 | s sort.Interface 25 | pos []int 26 | } 27 | 28 | func (s *stableSort) Len() int { 29 | return len(s.pos) 30 | } 31 | 32 | func (s *stableSort) Less(i, j int) bool { 33 | return s.s.Less(i, j) || !s.s.Less(j, i) && s.pos[i] < s.pos[j] 34 | } 35 | 36 | func (s *stableSort) Swap(i, j int) { 37 | s.s.Swap(i, j) 38 | s.pos[i], s.pos[j] = s.pos[j], s.pos[i] 39 | } 40 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_arm64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build gc 6 | // +build gc 7 | 8 | #include "textflag.h" 9 | 10 | // func getisar0() uint64 11 | TEXT ·getisar0(SB),NOSPLIT,$0-8 12 | // get Instruction Set Attributes 0 into x0 13 | // mrs x0, ID_AA64ISAR0_EL1 = d5380600 14 | WORD $0xd5380600 15 | MOVD R0, ret+0(FP) 16 | RET 17 | 18 | // func getisar1() uint64 19 | TEXT ·getisar1(SB),NOSPLIT,$0-8 20 | // get Instruction Set Attributes 1 into x0 21 | // mrs x0, ID_AA64ISAR1_EL1 = d5380620 22 | WORD $0xd5380620 23 | MOVD R0, ret+0(FP) 24 | RET 25 | 26 | // func getpfr0() uint64 27 | TEXT ·getpfr0(SB),NOSPLIT,$0-8 28 | // get Processor Feature Register 0 into x0 29 | // mrs x0, ID_AA64PFR0_EL1 = d5380400 30 | WORD $0xd5380400 31 | MOVD R0, ret+0(FP) 32 | RET 33 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/eventlog.go: -------------------------------------------------------------------------------- 1 | // Copyright 2012 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build windows 6 | 7 | package windows 8 | 9 | const ( 10 | EVENTLOG_SUCCESS = 0 11 | EVENTLOG_ERROR_TYPE = 1 12 | EVENTLOG_WARNING_TYPE = 2 13 | EVENTLOG_INFORMATION_TYPE = 4 14 | EVENTLOG_AUDIT_SUCCESS = 8 15 | EVENTLOG_AUDIT_FAILURE = 16 16 | ) 17 | 18 | //sys RegisterEventSource(uncServerName *uint16, sourceName *uint16) (handle Handle, err error) [failretval==0] = advapi32.RegisterEventSourceW 19 | //sys DeregisterEventSource(handle Handle) (err error) = advapi32.DeregisterEventSource 20 | //sys ReportEvent(log Handle, etype uint16, category uint16, eventId uint32, usrSId uintptr, numStrings uint16, dataSize uint32, strings **uint16, rawData *byte) (err error) = advapi32.ReportEventW 21 | -------------------------------------------------------------------------------- /vendor/golang.org/x/exp/shiny/driver/gldriver/context.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build !android 6 | // +build !android 7 | 8 | package gldriver 9 | 10 | import ( 11 | "runtime" 12 | 13 | "golang.org/x/mobile/gl" 14 | ) 15 | 16 | // NewContext creates an OpenGL ES context with a dedicated processing thread. 17 | func NewContext() (gl.Context, error) { 18 | glctx, worker := gl.NewContext() 19 | 20 | errCh := make(chan error) 21 | workAvailable := worker.WorkAvailable() 22 | go func() { 23 | runtime.LockOSThread() 24 | err := surfaceCreate() 25 | errCh <- err 26 | if err != nil { 27 | return 28 | } 29 | 30 | for range workAvailable { 31 | worker.DoWork() 32 | } 33 | }() 34 | if err := <-errCh; err != nil { 35 | return nil, err 36 | } 37 | return glctx, nil 38 | } 39 | -------------------------------------------------------------------------------- /vendor/golang.org/x/exp/shiny/driver/internal/errscreen/errscreen.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Package errscreen provides a stub Screen implementation. 6 | package errscreen // import "golang.org/x/exp/shiny/driver/internal/errscreen" 7 | 8 | import ( 9 | "image" 10 | 11 | "golang.org/x/exp/shiny/screen" 12 | ) 13 | 14 | // Stub returns a Screen whose methods all return the given error. 15 | func Stub(err error) screen.Screen { 16 | return stub{err} 17 | } 18 | 19 | type stub struct { 20 | err error 21 | } 22 | 23 | func (s stub) NewBuffer(size image.Point) (screen.Buffer, error) { return nil, s.err } 24 | func (s stub) NewTexture(size image.Point) (screen.Texture, error) { return nil, s.err } 25 | func (s stub) NewWindow(opts *screen.NewWindowOptions) (screen.Window, error) { return nil, s.err } 26 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_linux_ppc64x.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build linux && (ppc64 || ppc64le) 6 | // +build linux 7 | // +build ppc64 ppc64le 8 | 9 | package cpu 10 | 11 | // HWCAP/HWCAP2 bits. These are exposed by the kernel. 12 | const ( 13 | // ISA Level 14 | _PPC_FEATURE2_ARCH_2_07 = 0x80000000 15 | _PPC_FEATURE2_ARCH_3_00 = 0x00800000 16 | 17 | // CPU features 18 | _PPC_FEATURE2_DARN = 0x00200000 19 | _PPC_FEATURE2_SCV = 0x00100000 20 | ) 21 | 22 | func doinit() { 23 | // HWCAP2 feature bits 24 | PPC64.IsPOWER8 = isSet(hwCap2, _PPC_FEATURE2_ARCH_2_07) 25 | PPC64.IsPOWER9 = isSet(hwCap2, _PPC_FEATURE2_ARCH_3_00) 26 | PPC64.HasDARN = isSet(hwCap2, _PPC_FEATURE2_DARN) 27 | PPC64.HasSCV = isSet(hwCap2, _PPC_FEATURE2_SCV) 28 | } 29 | 30 | func isSet(hwc uint, value uint) bool { 31 | return hwc&value != 0 32 | } 33 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/sha3/hashes_generic.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build !gc || purego || !s390x 6 | // +build !gc purego !s390x 7 | 8 | package sha3 9 | 10 | import ( 11 | "hash" 12 | ) 13 | 14 | // new224Asm returns an assembly implementation of SHA3-224 if available, 15 | // otherwise it returns nil. 16 | func new224Asm() hash.Hash { return nil } 17 | 18 | // new256Asm returns an assembly implementation of SHA3-256 if available, 19 | // otherwise it returns nil. 20 | func new256Asm() hash.Hash { return nil } 21 | 22 | // new384Asm returns an assembly implementation of SHA3-384 if available, 23 | // otherwise it returns nil. 24 | func new384Asm() hash.Hash { return nil } 25 | 26 | // new512Asm returns an assembly implementation of SHA3-512 if available, 27 | // otherwise it returns nil. 28 | func new512Asm() hash.Hash { return nil } 29 | -------------------------------------------------------------------------------- /vendor/golang.org/x/exp/shiny/driver/mtldriver/internal/coreanim/coreanim.h: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build darwin 6 | 7 | typedef unsigned long uint_t; 8 | typedef unsigned short uint16_t; 9 | 10 | void * MakeMetalLayer(); 11 | 12 | uint16_t MetalLayer_PixelFormat(void * metalLayer); 13 | void MetalLayer_SetDevice(void * metalLayer, void * device); 14 | const char * MetalLayer_SetPixelFormat(void * metalLayer, uint16_t pixelFormat); 15 | const char * MetalLayer_SetMaximumDrawableCount(void * metalLayer, uint_t maximumDrawableCount); 16 | void MetalLayer_SetDisplaySyncEnabled(void * metalLayer, bool displaySyncEnabled); 17 | void MetalLayer_SetDrawableSize(void * metalLayer, double width, double height); 18 | void * MetalLayer_NextDrawable(void * metalLayer); 19 | 20 | void * MetalDrawable_Texture(void * drawable); 21 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/types_windows_amd64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2011 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package windows 6 | 7 | type WSAData struct { 8 | Version uint16 9 | HighVersion uint16 10 | MaxSockets uint16 11 | MaxUdpDg uint16 12 | VendorInfo *byte 13 | Description [WSADESCRIPTION_LEN + 1]byte 14 | SystemStatus [WSASYS_STATUS_LEN + 1]byte 15 | } 16 | 17 | type Servent struct { 18 | Name *byte 19 | Aliases **byte 20 | Proto *byte 21 | Port uint16 22 | } 23 | 24 | type JOBOBJECT_BASIC_LIMIT_INFORMATION struct { 25 | PerProcessUserTimeLimit int64 26 | PerJobUserTimeLimit int64 27 | LimitFlags uint32 28 | MinimumWorkingSetSize uintptr 29 | MaximumWorkingSetSize uintptr 30 | ActiveProcessLimit uint32 31 | Affinity uintptr 32 | PriorityClass uint32 33 | SchedulingClass uint32 34 | } 35 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/types_windows_arm64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2011 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package windows 6 | 7 | type WSAData struct { 8 | Version uint16 9 | HighVersion uint16 10 | MaxSockets uint16 11 | MaxUdpDg uint16 12 | VendorInfo *byte 13 | Description [WSADESCRIPTION_LEN + 1]byte 14 | SystemStatus [WSASYS_STATUS_LEN + 1]byte 15 | } 16 | 17 | type Servent struct { 18 | Name *byte 19 | Aliases **byte 20 | Proto *byte 21 | Port uint16 22 | } 23 | 24 | type JOBOBJECT_BASIC_LIMIT_INFORMATION struct { 25 | PerProcessUserTimeLimit int64 26 | PerJobUserTimeLimit int64 27 | LimitFlags uint32 28 | MinimumWorkingSetSize uintptr 29 | MaximumWorkingSetSize uintptr 30 | ActiveProcessLimit uint32 31 | Affinity uintptr 32 | PriorityClass uint32 33 | SchedulingClass uint32 34 | } 35 | -------------------------------------------------------------------------------- /vendor/golang.org/x/exp/shiny/driver/internal/swizzle/swizzle_common.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Package swizzle provides functions for converting between RGBA pixel 6 | // formats. 7 | package swizzle // import "golang.org/x/exp/shiny/driver/internal/swizzle" 8 | 9 | // BGRA converts a pixel buffer between Go's RGBA and other systems' BGRA byte 10 | // orders. 11 | // 12 | // It panics if the input slice length is not a multiple of 4. 13 | func BGRA(p []byte) { 14 | if len(p)%4 != 0 { 15 | panic("input slice length is not a multiple of 4") 16 | } 17 | 18 | // Use asm code for 16- or 4-byte chunks, if supported. 19 | if useBGRA16 { 20 | n := len(p) &^ (16 - 1) 21 | bgra16(p[:n]) 22 | p = p[n:] 23 | } else if useBGRA4 { 24 | bgra4(p) 25 | return 26 | } 27 | 28 | for i := 0; i < len(p); i += 4 { 29 | p[i+0], p[i+2] = p[i+2], p[i+0] 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /vendor/github.com/BurntSushi/xgb/sync.go: -------------------------------------------------------------------------------- 1 | package xgb 2 | 3 | // Sync sends a round trip request and waits for the response. 4 | // This forces all pending cookies to be dealt with. 5 | // You actually shouldn't need to use this like you might with Xlib. Namely, 6 | // buffers are automatically flushed using Go's channels and round trip requests 7 | // are forced where appropriate automatically. 8 | func (c *Conn) Sync() { 9 | cookie := c.NewCookie(true, true) 10 | c.NewRequest(c.getInputFocusRequest(), cookie) 11 | cookie.Reply() // wait for the buffer to clear 12 | } 13 | 14 | // getInputFocusRequest writes the raw bytes to a buffer. 15 | // It is duplicated from xproto/xproto.go. 16 | func (c *Conn) getInputFocusRequest() []byte { 17 | size := 4 18 | b := 0 19 | buf := make([]byte, size) 20 | 21 | buf[b] = 43 // request opcode 22 | b += 1 23 | 24 | b += 1 // padding 25 | Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units 26 | b += 2 27 | 28 | return buf 29 | } 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/exp/shiny/driver/driver.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Package driver provides the default driver for accessing a screen. 6 | package driver // import "golang.org/x/exp/shiny/driver" 7 | 8 | // TODO: figure out what to say about the responsibility for users of this 9 | // package to check any implicit dependencies' LICENSEs. For example, the 10 | // driver might use third party software outside of golang.org/x, like an X11 11 | // or OpenGL library. 12 | 13 | import ( 14 | "golang.org/x/exp/shiny/screen" 15 | ) 16 | 17 | // Main is called by the program's main function to run the graphical 18 | // application. 19 | // 20 | // It calls f on the Screen, possibly in a separate goroutine, as some OS- 21 | // specific libraries require being on 'the main thread'. It returns when f 22 | // returns. 23 | func Main(f func(screen.Screen)) { 24 | main(f) 25 | } 26 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_gccgo_x86.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (386 || amd64 || amd64p32) && gccgo 6 | // +build 386 amd64 amd64p32 7 | // +build gccgo 8 | 9 | package cpu 10 | 11 | //extern gccgoGetCpuidCount 12 | func gccgoGetCpuidCount(eaxArg, ecxArg uint32, eax, ebx, ecx, edx *uint32) 13 | 14 | func cpuid(eaxArg, ecxArg uint32) (eax, ebx, ecx, edx uint32) { 15 | var a, b, c, d uint32 16 | gccgoGetCpuidCount(eaxArg, ecxArg, &a, &b, &c, &d) 17 | return a, b, c, d 18 | } 19 | 20 | //extern gccgoXgetbv 21 | func gccgoXgetbv(eax, edx *uint32) 22 | 23 | func xgetbv() (eax, edx uint32) { 24 | var a, d uint32 25 | gccgoXgetbv(&a, &d) 26 | return a, d 27 | } 28 | 29 | // gccgo doesn't build on Darwin, per: 30 | // https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/gcc.rb#L76 31 | func darwinSupportsAVX512() bool { 32 | return false 33 | } 34 | -------------------------------------------------------------------------------- /vendor/golang.org/x/text/internal/language/compact.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package language 6 | 7 | // CompactCoreInfo is a compact integer with the three core tags encoded. 8 | type CompactCoreInfo uint32 9 | 10 | // GetCompactCore generates a uint32 value that is guaranteed to be unique for 11 | // different language, region, and script values. 12 | func GetCompactCore(t Tag) (cci CompactCoreInfo, ok bool) { 13 | if t.LangID > langNoIndexOffset { 14 | return 0, false 15 | } 16 | cci |= CompactCoreInfo(t.LangID) << (8 + 12) 17 | cci |= CompactCoreInfo(t.ScriptID) << 12 18 | cci |= CompactCoreInfo(t.RegionID) 19 | return cci, true 20 | } 21 | 22 | // Tag generates a tag from c. 23 | func (c CompactCoreInfo) Tag() Tag { 24 | return Tag{ 25 | LangID: Language(c >> 20), 26 | RegionID: Region(c & 0x3ff), 27 | ScriptID: Script(c>>12) & 0xff, 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/ssh/doc.go: -------------------------------------------------------------------------------- 1 | // Copyright 2011 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | /* 6 | Package ssh implements an SSH client and server. 7 | 8 | SSH is a transport security protocol, an authentication protocol and a 9 | family of application protocols. The most typical application level 10 | protocol is a remote shell and this is specifically implemented. However, 11 | the multiplexed nature of SSH is exposed to users that wish to support 12 | others. 13 | 14 | References: 15 | [PROTOCOL.certkeys]: http://cvsweb.openbsd.org/cgi-bin/cvsweb/src/usr.bin/ssh/PROTOCOL.certkeys?rev=HEAD 16 | [SSH-PARAMETERS]: http://www.iana.org/assignments/ssh-parameters/ssh-parameters.xml#ssh-parameters-1 17 | 18 | This package does not fall under the stability promise of the Go language itself, 19 | so its API may be changed when pressing needs arise. 20 | */ 21 | package ssh // import "golang.org/x/crypto/ssh" 22 | -------------------------------------------------------------------------------- /vendor/golang.org/x/image/draw/draw_go117.go: -------------------------------------------------------------------------------- 1 | // Copyright 2021 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build go1.17 6 | // +build go1.17 7 | 8 | package draw 9 | 10 | import ( 11 | "image/draw" 12 | ) 13 | 14 | // The package documentation, in draw.go, gives the intent of this package: 15 | // 16 | // This package is a superset of and a drop-in replacement for the 17 | // image/draw package in the standard library. 18 | // 19 | // "Drop-in replacement" means that we use type aliases in this file. 20 | // 21 | // TODO: move the type aliases to draw.go once Go 1.16 is no longer supported. 22 | 23 | // RGBA64Image extends both the Image and image.RGBA64Image interfaces with a 24 | // SetRGBA64 method to change a single pixel. SetRGBA64 is equivalent to 25 | // calling Set, but it can avoid allocations from converting concrete color 26 | // types to the color.Color interface type. 27 | type RGBA64Image = draw.RGBA64Image 28 | -------------------------------------------------------------------------------- /vendor/github.com/as/frame/indexof.go: -------------------------------------------------------------------------------- 1 | package frame 2 | 3 | import ( 4 | "image" 5 | ) 6 | 7 | // IndexOf returns the chracter index under the 8 | // point pt. 9 | func (f *Frame) IndexOf(pt image.Point) (p int64) { 10 | pt.X += 1 11 | return f.indexOf(pt) 12 | } 13 | 14 | func (f *Frame) indexOf(pt image.Point) (p int64) { 15 | pt = f.grid(pt) 16 | qt := f.r.Min 17 | bn := 0 18 | for ; bn < f.Nbox && qt.Y < pt.Y; bn++ { 19 | b := &f.Box[bn] 20 | qt = f.wrapMax(qt, b) 21 | if qt.Y >= pt.Y { 22 | break 23 | } 24 | qt = f.advance(qt, b) 25 | p += int64(b.Len()) 26 | } 27 | 28 | for ; bn < f.Nbox && qt.X <= pt.X; bn++ { 29 | b := &f.Box[bn] 30 | qt = f.wrapMax(qt, b) 31 | if qt.Y > pt.Y { 32 | break 33 | } 34 | if qt.X+b.Width > pt.X { 35 | if b.Nrune < 0 { 36 | qt = f.advance(qt, b) 37 | } else { 38 | left := pt.X - qt.X 39 | p += int64(f.Face.Fits(b.Ptr, left)) 40 | qt.X += left 41 | } 42 | } else { 43 | p += int64(b.Len()) 44 | qt = f.advance(qt, b) 45 | } 46 | } 47 | return p 48 | } 49 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Torgo 2 | Torgo is a set UNIX and Plan9-like command line tools. Target platforms are Windows, Plan 9, Linux, and possibly OSX. The project's technical goal is to provide command line utilities that are accessible, homogeneous, and interoperable with each other. Non-goals are compatibility with the existing syntax and semantics of similar toolkits, such as GNU coreutils. 3 | 4 | # Warning 5 | Use this pre-alpha toolkit at your own risk. Many of the tools will do not work the way you expect them to on Linux. 6 | 7 | # Installation 8 | 9 | ``` 10 | go get github.com/as/torgo/... 11 | go install github.com/as/torgo/... 12 | ``` 13 | 14 | # Example 15 | 16 | Print a list of duplicate files in the current working directory tree, prefixed by the number of duplicates and the sha1 sum of the file contents 17 | 18 | `walk -f | hash sha1 - | uniq -d -l -c -x "[0-9a-f]{16}" | sort -n` 19 | 20 | See the wiki for more examples 21 | 22 | # License 23 | The license shall be identical to that of the Go programming language at the time of 2017/01/01. (BSD-like). 24 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/types_windows_386.go: -------------------------------------------------------------------------------- 1 | // Copyright 2011 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package windows 6 | 7 | type WSAData struct { 8 | Version uint16 9 | HighVersion uint16 10 | Description [WSADESCRIPTION_LEN + 1]byte 11 | SystemStatus [WSASYS_STATUS_LEN + 1]byte 12 | MaxSockets uint16 13 | MaxUdpDg uint16 14 | VendorInfo *byte 15 | } 16 | 17 | type Servent struct { 18 | Name *byte 19 | Aliases **byte 20 | Port uint16 21 | Proto *byte 22 | } 23 | 24 | type JOBOBJECT_BASIC_LIMIT_INFORMATION struct { 25 | PerProcessUserTimeLimit int64 26 | PerJobUserTimeLimit int64 27 | LimitFlags uint32 28 | MinimumWorkingSetSize uintptr 29 | MaximumWorkingSetSize uintptr 30 | ActiveProcessLimit uint32 31 | Affinity uintptr 32 | PriorityClass uint32 33 | SchedulingClass uint32 34 | _ uint32 // pad to 8 byte boundary 35 | } 36 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/types_windows_arm.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package windows 6 | 7 | type WSAData struct { 8 | Version uint16 9 | HighVersion uint16 10 | Description [WSADESCRIPTION_LEN + 1]byte 11 | SystemStatus [WSASYS_STATUS_LEN + 1]byte 12 | MaxSockets uint16 13 | MaxUdpDg uint16 14 | VendorInfo *byte 15 | } 16 | 17 | type Servent struct { 18 | Name *byte 19 | Aliases **byte 20 | Port uint16 21 | Proto *byte 22 | } 23 | 24 | type JOBOBJECT_BASIC_LIMIT_INFORMATION struct { 25 | PerProcessUserTimeLimit int64 26 | PerJobUserTimeLimit int64 27 | LimitFlags uint32 28 | MinimumWorkingSetSize uintptr 29 | MaximumWorkingSetSize uintptr 30 | ActiveProcessLimit uint32 31 | Affinity uintptr 32 | PriorityClass uint32 33 | SchedulingClass uint32 34 | _ uint32 // pad to 8 byte boundary 35 | } 36 | -------------------------------------------------------------------------------- /loop/loop.go: -------------------------------------------------------------------------------- 1 | // loop is a temporary program for Windows systems that executes a looping command 2 | // this is because (for /l %a in () do (somecommand.exe)) | filter.exe crashes command prompt 3 | package main 4 | 5 | import ( 6 | "flag" 7 | "fmt" 8 | "log" 9 | "os/exec" 10 | ) 11 | 12 | var ( 13 | checkStatus = flag.Bool("ck", false, "check exit status and terminate loop if non-zero") 14 | mon = flag.Bool("mon", false, "opposite of ck--exit only when the command outputs a non zero exit status") 15 | ) 16 | 17 | func init() { 18 | log.SetFlags(0) 19 | log.SetPrefix("loop:") 20 | flag.Parse() 21 | } 22 | 23 | func main() { 24 | a := flag.Args() 25 | if len(a) < 1 { 26 | log.Println("usage: loop cmd [args...]") 27 | } 28 | for { 29 | out, err := exec.Command(a[0], a[1:]...).CombinedOutput() 30 | fmt.Print(string(out)) 31 | if err != nil { 32 | e, _ := err.(*exec.ExitError) 33 | if e == nil && *mon { 34 | continue 35 | } 36 | if e != nil && !*checkStatus { 37 | continue 38 | } 39 | log.Println(e) 40 | break 41 | } 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /stutter/stutter.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 "as". All rights reserved. Torgo is governed 2 | // the same BSD license as the go programming language. 3 | 4 | package main 5 | 6 | import ( 7 | "bufio" 8 | "fmt" 9 | "io" 10 | "log" 11 | "os" 12 | ) 13 | 14 | type parser struct { 15 | br *bufio.Reader 16 | tok byte 17 | n int 18 | err error 19 | } 20 | 21 | func (p *parser) next() (byte, error) { 22 | last := p.tok 23 | lasterr := p.err 24 | p.tok, p.err = p.br.ReadByte() 25 | return last, lasterr 26 | } 27 | 28 | func main() { 29 | parser := &parser{br: bufio.NewReader(os.Stdin)} 30 | parser.next() 31 | thresh := 9 32 | for { 33 | b, err := parser.next() 34 | if err != nil { 35 | if err != io.EOF { 36 | log.Println(err) 37 | } 38 | break 39 | } 40 | if b == parser.tok { 41 | parser.n++ 42 | continue 43 | } 44 | if parser.n < thresh { 45 | for i := 0; i < parser.n+1; i++ { 46 | fmt.Printf("%c", b) 47 | } 48 | } else { 49 | fmt.Printf(`%c{{%d}}`, b, parser.n+1) 50 | fmt.Println() 51 | } 52 | parser.n = 0 53 | } 54 | } 55 | -------------------------------------------------------------------------------- /vendor/golang.org/x/mobile/event/paint/paint.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Package paint defines an event for the app being ready to paint. 6 | // 7 | // See the golang.org/x/mobile/app package for details on the event model. 8 | package paint // import "golang.org/x/mobile/event/paint" 9 | 10 | // Event indicates that the app is ready to paint the next frame of the GUI. 11 | // 12 | //A frame is completed by calling the App's Publish method. 13 | type Event struct { 14 | // External is true for paint events sent by the screen driver. 15 | // 16 | // An external event may be sent at any time in response to an 17 | // operating system event, for example the window opened, was 18 | // resized, or the screen memory was lost. 19 | // 20 | // Programs actively drawing to the screen as fast as vsync allows 21 | // should ignore external paint events to avoid a backlog of paint 22 | // events building up. 23 | External bool 24 | } 25 | -------------------------------------------------------------------------------- /go.mod: -------------------------------------------------------------------------------- 1 | module github.com/as/torgo 2 | 3 | go 1.14 4 | 5 | require ( 6 | github.com/as/argfile v0.0.0-20180402135007-9e79a4ce7beb 7 | github.com/as/edit v0.6.14 8 | github.com/as/etch v0.6.7 // indirect 9 | github.com/as/event v0.6.8 // indirect 10 | github.com/as/font v0.6.8 11 | github.com/as/frame v0.8.0 12 | github.com/as/io v0.1.0 13 | github.com/as/log v0.0.4 14 | github.com/as/ms v0.1.0 15 | github.com/as/mute v0.0.0-20160629060040-74b2ea619898 16 | github.com/as/pkcs7 v0.0.0-20160629054332-16667ce7d482 17 | github.com/as/text v0.7.0 18 | github.com/as/worm v0.6.7 // indirect 19 | github.com/as/xo v0.0.0-20170221193853-60ce2913333b 20 | github.com/basgys/goxml2json v1.1.0 21 | github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0 // indirect 22 | golang.org/x/crypto v0.0.0-20210817164053-32db794688a5 23 | golang.org/x/exp v0.0.0-20210823210606-b36147abdb7c 24 | golang.org/x/image v0.0.0-20210628002857-a66eb6448b8d 25 | golang.org/x/mobile v0.0.0-20210716004757-34ab1303b554 26 | golang.org/x/net v0.0.0-20210813160813-60bc85c4be6d 27 | rsc.io/pdf v0.1.1 28 | ) 29 | -------------------------------------------------------------------------------- /vendor/golang.org/x/exp/shiny/driver/mtldriver/texture.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build darwin 6 | // +build darwin 7 | 8 | package mtldriver 9 | 10 | import ( 11 | "image" 12 | "image/color" 13 | 14 | "golang.org/x/exp/shiny/screen" 15 | "golang.org/x/image/draw" 16 | ) 17 | 18 | // textureImpl implements screen.Texture. 19 | type textureImpl struct { 20 | rgba *image.RGBA 21 | } 22 | 23 | func (*textureImpl) Release() {} 24 | func (t *textureImpl) Size() image.Point { return t.rgba.Rect.Max } 25 | func (t *textureImpl) Bounds() image.Rectangle { return t.rgba.Rect } 26 | 27 | func (t *textureImpl) Upload(dp image.Point, src screen.Buffer, sr image.Rectangle) { 28 | draw.Draw(t.rgba, sr.Sub(sr.Min).Add(dp), src.RGBA(), sr.Min, draw.Src) 29 | } 30 | 31 | func (t *textureImpl) Fill(dr image.Rectangle, src color.Color, op draw.Op) { 32 | draw.Draw(t.rgba, dr, &image.Uniform{src}, image.Point{}, op) 33 | } 34 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/internal/unsafeheader/unsafeheader.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Package unsafeheader contains header declarations for the Go runtime's 6 | // slice and string implementations. 7 | // 8 | // This package allows x/sys to use types equivalent to 9 | // reflect.SliceHeader and reflect.StringHeader without introducing 10 | // a dependency on the (relatively heavy) "reflect" package. 11 | package unsafeheader 12 | 13 | import ( 14 | "unsafe" 15 | ) 16 | 17 | // Slice is the runtime representation of a slice. 18 | // It cannot be used safely or portably and its representation may change in a later release. 19 | type Slice struct { 20 | Data unsafe.Pointer 21 | Len int 22 | Cap int 23 | } 24 | 25 | // String is the runtime representation of a string. 26 | // It cannot be used safely or portably and its representation may change in a later release. 27 | type String struct { 28 | Data unsafe.Pointer 29 | Len int 30 | } 31 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_linux_s390x.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package cpu 6 | 7 | const ( 8 | // bit mask values from /usr/include/bits/hwcap.h 9 | hwcap_ZARCH = 2 10 | hwcap_STFLE = 4 11 | hwcap_MSA = 8 12 | hwcap_LDISP = 16 13 | hwcap_EIMM = 32 14 | hwcap_DFP = 64 15 | hwcap_ETF3EH = 256 16 | hwcap_VX = 2048 17 | hwcap_VXE = 8192 18 | ) 19 | 20 | func initS390Xbase() { 21 | // test HWCAP bit vector 22 | has := func(featureMask uint) bool { 23 | return hwCap&featureMask == featureMask 24 | } 25 | 26 | // mandatory 27 | S390X.HasZARCH = has(hwcap_ZARCH) 28 | 29 | // optional 30 | S390X.HasSTFLE = has(hwcap_STFLE) 31 | S390X.HasLDISP = has(hwcap_LDISP) 32 | S390X.HasEIMM = has(hwcap_EIMM) 33 | S390X.HasETF3EH = has(hwcap_ETF3EH) 34 | S390X.HasDFP = has(hwcap_DFP) 35 | S390X.HasMSA = has(hwcap_MSA) 36 | S390X.HasVX = has(hwcap_VX) 37 | if S390X.HasVX { 38 | S390X.HasVXE = has(hwcap_VXE) 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /vendor/github.com/go-gl/glfw/v3.3/glfw/native_windows.go: -------------------------------------------------------------------------------- 1 | package glfw 2 | 3 | //#define GLFW_EXPOSE_NATIVE_WIN32 4 | //#define GLFW_EXPOSE_NATIVE_WGL 5 | //#define GLFW_INCLUDE_NONE 6 | //#include "glfw/include/GLFW/glfw3.h" 7 | //#include "glfw/include/GLFW/glfw3native.h" 8 | import "C" 9 | 10 | // GetWin32Adapter returns the adapter device name of the monitor. 11 | func (m *Monitor) GetWin32Adapter() string { 12 | ret := C.glfwGetWin32Adapter(m.data) 13 | panicError() 14 | return C.GoString(ret) 15 | } 16 | 17 | // GetWin32Monitor returns the display device name of the monitor. 18 | func (m *Monitor) GetWin32Monitor() string { 19 | ret := C.glfwGetWin32Monitor(m.data) 20 | panicError() 21 | return C.GoString(ret) 22 | } 23 | 24 | // GetWin32Window returns the HWND of the window. 25 | func (w *Window) GetWin32Window() C.HWND { 26 | ret := C.glfwGetWin32Window(w.data) 27 | panicError() 28 | return ret 29 | } 30 | 31 | // GetWGLContext returns the HGLRC of the window. 32 | func (w *Window) GetWGLContext() C.HGLRC { 33 | ret := C.glfwGetWGLContext(w.data) 34 | panicError() 35 | return ret 36 | } 37 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/sha3/sha3_s390x.s: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build gc && !purego 6 | // +build gc,!purego 7 | 8 | #include "textflag.h" 9 | 10 | // func kimd(function code, chain *[200]byte, src []byte) 11 | TEXT ·kimd(SB), NOFRAME|NOSPLIT, $0-40 12 | MOVD function+0(FP), R0 13 | MOVD chain+8(FP), R1 14 | LMG src+16(FP), R2, R3 // R2=base, R3=len 15 | 16 | continue: 17 | WORD $0xB93E0002 // KIMD --, R2 18 | BVS continue // continue if interrupted 19 | MOVD $0, R0 // reset R0 for pre-go1.8 compilers 20 | RET 21 | 22 | // func klmd(function code, chain *[200]byte, dst, src []byte) 23 | TEXT ·klmd(SB), NOFRAME|NOSPLIT, $0-64 24 | // TODO: SHAKE support 25 | MOVD function+0(FP), R0 26 | MOVD chain+8(FP), R1 27 | LMG dst+16(FP), R2, R3 // R2=base, R3=len 28 | LMG src+40(FP), R4, R5 // R4=base, R5=len 29 | 30 | continue: 31 | WORD $0xB93F0024 // KLMD R2, R4 32 | BVS continue // continue if interrupted 33 | MOVD $0, R0 // reset R0 for pre-go1.8 compilers 34 | RET 35 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/poly1305/bits_compat.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build !go1.13 6 | // +build !go1.13 7 | 8 | package poly1305 9 | 10 | // Generic fallbacks for the math/bits intrinsics, copied from 11 | // src/math/bits/bits.go. They were added in Go 1.12, but Add64 and Sum64 had 12 | // variable time fallbacks until Go 1.13. 13 | 14 | func bitsAdd64(x, y, carry uint64) (sum, carryOut uint64) { 15 | sum = x + y + carry 16 | carryOut = ((x & y) | ((x | y) &^ sum)) >> 63 17 | return 18 | } 19 | 20 | func bitsSub64(x, y, borrow uint64) (diff, borrowOut uint64) { 21 | diff = x - y - borrow 22 | borrowOut = ((^x & y) | (^(x ^ y) & diff)) >> 63 23 | return 24 | } 25 | 26 | func bitsMul64(x, y uint64) (hi, lo uint64) { 27 | const mask32 = 1<<32 - 1 28 | x0 := x & mask32 29 | x1 := x >> 32 30 | y0 := y & mask32 31 | y1 := y >> 32 32 | w0 := x0 * y0 33 | t := x1*y0 + w0>>32 34 | w1 := t & mask32 35 | w2 := t >> 32 36 | w1 += x0 * y1 37 | hi = x1*y1 + w2 + w1>>32 38 | lo = x * y 39 | return 40 | } 41 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_gccgo_s390x.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build gccgo 6 | // +build gccgo 7 | 8 | package cpu 9 | 10 | // haveAsmFunctions reports whether the other functions in this file can 11 | // be safely called. 12 | func haveAsmFunctions() bool { return false } 13 | 14 | // TODO(mundaym): the following feature detection functions are currently 15 | // stubs. See https://golang.org/cl/162887 for how to fix this. 16 | // They are likely to be expensive to call so the results should be cached. 17 | func stfle() facilityList { panic("not implemented for gccgo") } 18 | func kmQuery() queryResult { panic("not implemented for gccgo") } 19 | func kmcQuery() queryResult { panic("not implemented for gccgo") } 20 | func kmctrQuery() queryResult { panic("not implemented for gccgo") } 21 | func kmaQuery() queryResult { panic("not implemented for gccgo") } 22 | func kimdQuery() queryResult { panic("not implemented for gccgo") } 23 | func klmdQuery() queryResult { panic("not implemented for gccgo") } 24 | -------------------------------------------------------------------------------- /vendor/golang.org/x/exp/shiny/driver/gldriver/other.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (!darwin || ios || !cgo) && (!linux || android || !cgo) && (!openbsd || !cgo) && !windows 6 | // +build !darwin ios !cgo 7 | // +build !linux android !cgo 8 | // +build !openbsd !cgo 9 | // +build !windows 10 | 11 | package gldriver 12 | 13 | import ( 14 | "fmt" 15 | "runtime" 16 | 17 | "golang.org/x/exp/shiny/screen" 18 | ) 19 | 20 | const useLifecycler = true 21 | const handleSizeEventsAtChannelReceive = true 22 | 23 | var errUnsupported = fmt.Errorf("gldriver: unsupported GOOS/GOARCH %s/%s or cgo not enabled", runtime.GOOS, runtime.GOARCH) 24 | 25 | func newWindow(opts *screen.NewWindowOptions) (uintptr, error) { return 0, errUnsupported } 26 | 27 | func initWindow(id *windowImpl) {} 28 | func showWindow(id *windowImpl) {} 29 | func closeWindow(id uintptr) {} 30 | func drawLoop(w *windowImpl) {} 31 | 32 | func surfaceCreate() error { return errUnsupported } 33 | func main(f func(screen.Screen)) error { return errUnsupported } 34 | -------------------------------------------------------------------------------- /vendor/github.com/basgys/goxml2json/LICENSE: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2016 Bastien Gysler 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/syscall_aix_ppc64_gc.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Minimal copy of x/sys/unix so the cpu package can make a 6 | // system call on AIX without depending on x/sys/unix. 7 | // (See golang.org/issue/32102) 8 | 9 | //go:build aix && ppc64 && gc 10 | // +build aix,ppc64,gc 11 | 12 | package cpu 13 | 14 | import ( 15 | "syscall" 16 | "unsafe" 17 | ) 18 | 19 | //go:cgo_import_dynamic libc_getsystemcfg getsystemcfg "libc.a/shr_64.o" 20 | 21 | //go:linkname libc_getsystemcfg libc_getsystemcfg 22 | 23 | type syscallFunc uintptr 24 | 25 | var libc_getsystemcfg syscallFunc 26 | 27 | type errno = syscall.Errno 28 | 29 | // Implemented in runtime/syscall_aix.go. 30 | func rawSyscall6(trap, nargs, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err errno) 31 | func syscall6(trap, nargs, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err errno) 32 | 33 | func callgetsystemcfg(label int) (r1 uintptr, e1 errno) { 34 | r1, _, e1 = syscall6(uintptr(unsafe.Pointer(&libc_getsystemcfg)), 1, uintptr(label), 0, 0, 0, 0, 0) 35 | return 36 | } 37 | -------------------------------------------------------------------------------- /vendor/github.com/as/text/history.go: -------------------------------------------------------------------------------- 1 | package text 2 | 3 | import ( 4 | "io" 5 | 6 | "github.com/as/event" 7 | "github.com/as/worm" 8 | ) 9 | 10 | type history struct { 11 | Editor 12 | l worm.Logger 13 | } 14 | 15 | func NewHistory(ed Editor, l worm.Logger) Editor { 16 | return &history{ 17 | Editor: ed, 18 | l: l, 19 | } 20 | } 21 | 22 | func (w *history) WriteAt(p []byte, q0 int64) (int, error) { 23 | if len(p) == 0 { 24 | return 0, nil 25 | } 26 | n, err := w.Editor.(io.WriterAt).WriteAt(p, q0) 27 | w.l.Write(&event.Write{Rec: event.Rec{Kind: 'w', P: p, Q0: q0, Q1: q0 + int64(len(p))}}) 28 | return n, err 29 | } 30 | 31 | func (w *history) Insert(p []byte, q0 int64) int { 32 | if len(p) == 0 { 33 | return 0 34 | } 35 | n := w.Editor.Insert(p, q0) 36 | w.l.Write(&event.Insert{event.Rec{Kind: 'i', P: p, Q0: q0, Q1: q0 + int64(len(p))}}) 37 | return n 38 | } 39 | func (w *history) Delete(q0, q1 int64) int { 40 | n := w.Editor.Delete(q0, q1) 41 | w.l.Write(&event.Delete{event.Rec{Kind: 'd', Q0: q0, Q1: q1}}) 42 | return n 43 | } 44 | func (w *history) Select(q0, q1 int64) { 45 | w.Editor.Select(q0, q1) 46 | w.l.Write(&event.Select{event.Rec{Kind: 's', Q0: q0, Q1: q1}}) 47 | } 48 | -------------------------------------------------------------------------------- /x/win.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | type Win struct { 4 | Q0, Q1 int64 5 | R []byte 6 | } 7 | 8 | func (w *Win) Select(q0, q1 int64) { 9 | w.Q0, w.Q1 = q0, q1 10 | } 11 | 12 | func (w *Win) Insert(s []byte, q0 int64) int64 { 13 | n := int64(len(s)) 14 | if n == 0 { 15 | return 0 16 | } 17 | nr := int64(len(w.R)) 18 | if q0 > nr { 19 | q0 = nr 20 | } 21 | back := []byte{} 22 | if q0 < nr-1 { 23 | back = w.R[q0:] 24 | } 25 | if w.R == nil { 26 | w.R = []byte{} 27 | } 28 | w.R = append(w.R[:q0], append(s, back...)...) 29 | return int64(len(s)) 30 | } 31 | 32 | func (w *Win) Delete(q0, q1 int64) int64 { 33 | n := q1 - q0 34 | if n == 0 { 35 | return 0 36 | } 37 | 38 | Nr := int64(len(w.R)) 39 | copy(w.R[q0:], w.R[q1:][:Nr-q1]) 40 | w.R = w.R[:Nr-n] 41 | return n 42 | } 43 | 44 | func (w *Win) Dot() (q0, q1 int64) { 45 | nr := int64(len(w.R)) 46 | q0 = clamp(w.Q0, 0, nr) 47 | q1 = clamp(w.Q1, 0, nr) 48 | return 49 | } 50 | 51 | func (w *Win) Dirty() bool { 52 | return false 53 | } 54 | 55 | func (w *Win) Bytes() []byte { 56 | return w.R 57 | } 58 | 59 | func clamp(v, l, h int64) int64 { 60 | if v < l { 61 | return l 62 | } 63 | if v > h { 64 | return h 65 | } 66 | return v 67 | } 68 | -------------------------------------------------------------------------------- /vendor/golang.org/x/mobile/gl/work_other.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (!cgo || (!darwin && !linux && !openbsd)) && !windows 6 | // +build !cgo !darwin,!linux,!openbsd 7 | // +build !windows 8 | 9 | package gl 10 | 11 | // This file contains stub implementations of what the other work*.go files 12 | // provide. These stubs don't do anything, other than compile (e.g. when cgo is 13 | // disabled). 14 | 15 | type context struct{} 16 | 17 | func (*context) enqueue(c call) uintptr { 18 | panic("unimplemented; GOOS/CGO combination not supported") 19 | } 20 | 21 | func (*context) cString(str string) (uintptr, func()) { 22 | panic("unimplemented; GOOS/CGO combination not supported") 23 | } 24 | 25 | func (*context) cStringPtr(str string) (uintptr, func()) { 26 | panic("unimplemented; GOOS/CGO combination not supported") 27 | } 28 | 29 | type context3 = context 30 | 31 | func NewContext() (Context, Worker) { 32 | panic("unimplemented; GOOS/CGO combination not supported") 33 | } 34 | 35 | func Version() string { 36 | panic("unimplemented; GOOS/CGO combination not supported") 37 | } 38 | -------------------------------------------------------------------------------- /vendor/github.com/go-gl/glfw/v3.3/glfw/native_darwin.go: -------------------------------------------------------------------------------- 1 | package glfw 2 | 3 | /* 4 | #define GLFW_EXPOSE_NATIVE_COCOA 5 | #define GLFW_EXPOSE_NATIVE_NSGL 6 | #include "glfw/include/GLFW/glfw3.h" 7 | #include "glfw/include/GLFW/glfw3native.h" 8 | 9 | // workaround wrappers needed due to a cgo and/or LLVM bug. 10 | // See: https://github.com/go-gl/glfw/issues/136 11 | void *workaround_glfwGetCocoaWindow(GLFWwindow *w) { 12 | return (void *)glfwGetCocoaWindow(w); 13 | } 14 | void *workaround_glfwGetNSGLContext(GLFWwindow *w) { 15 | return (void *)glfwGetNSGLContext(w); 16 | } 17 | */ 18 | import "C" 19 | import "unsafe" 20 | 21 | // GetCocoaMonitor returns the CGDirectDisplayID of the monitor. 22 | func (m *Monitor) GetCocoaMonitor() uintptr { 23 | ret := uintptr(C.glfwGetCocoaMonitor(m.data)) 24 | panicError() 25 | return ret 26 | } 27 | 28 | // GetCocoaWindow returns the NSWindow of the window. 29 | func (w *Window) GetCocoaWindow() unsafe.Pointer { 30 | ret := C.workaround_glfwGetCocoaWindow(w.data) 31 | panicError() 32 | return ret 33 | } 34 | 35 | // GetNSGLContext returns the NSOpenGLContext of the window. 36 | func (w *Window) GetNSGLContext() unsafe.Pointer { 37 | ret := C.workaround_glfwGetNSGLContext(w.data) 38 | panicError() 39 | return ret 40 | } 41 | -------------------------------------------------------------------------------- /vendor/github.com/as/text/trace.go: -------------------------------------------------------------------------------- 1 | package text 2 | 3 | import "fmt" 4 | 5 | // Trace wraps ed with methods that logs the arguments passed to each 6 | // method call of the text.Editor interface for debugging purposes. 7 | func Trace(ed Editor) Editor { 8 | return &tracer{ed} 9 | } 10 | 11 | type tracer struct { 12 | Editor 13 | } 14 | 15 | /* 16 | func (x *tracer) WriteAt(p []byte, at int64) (int, error){ 17 | fmt.Printf("WriteAt: %q @ %d\n", p, at) 18 | return x.Editor.(io.WriterAt).WriteAt(p, at) 19 | } 20 | */ 21 | func (x *tracer) Insert(p []byte, at int64) int { 22 | fmt.Printf("Insert: %q @ %d\n", p, at) 23 | return x.Editor.Insert(p, at) 24 | } 25 | func (x *tracer) Delete(q0, q1 int64) int { 26 | fmt.Printf("Delete: %d:%d\n", q0, q1) 27 | return x.Editor.Delete(q0, q1) 28 | } 29 | func (x *tracer) Dot() (q0, q1 int64) { 30 | fmt.Printf("Dot: %d:%d\n", q0, q1) 31 | return x.Editor.Dot() 32 | } 33 | func (x *tracer) Select(q0, q1 int64) { 34 | fmt.Printf("Select: %d:%d\n\n", q0, q1) 35 | x.Editor.Select(q0, q1) 36 | } 37 | func (x *tracer) Len() int64 { 38 | fmt.Printf("Len: %d\n\n", x.Editor.Len()) 39 | return x.Editor.Len() 40 | } 41 | func (x *tracer) Bytes() []byte { 42 | fmt.Printf("Bytes: %q\n\n", x.Editor.Bytes()) 43 | return x.Editor.Bytes() 44 | } 45 | -------------------------------------------------------------------------------- /vendor/golang.org/x/image/math/f64/f64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Package f64 implements float64 vector and matrix types. 6 | package f64 // import "golang.org/x/image/math/f64" 7 | 8 | // Vec2 is a 2-element vector. 9 | type Vec2 [2]float64 10 | 11 | // Vec3 is a 3-element vector. 12 | type Vec3 [3]float64 13 | 14 | // Vec4 is a 4-element vector. 15 | type Vec4 [4]float64 16 | 17 | // Mat3 is a 3x3 matrix in row major order. 18 | // 19 | // m[3*r + c] is the element in the r'th row and c'th column. 20 | type Mat3 [9]float64 21 | 22 | // Mat4 is a 4x4 matrix in row major order. 23 | // 24 | // m[4*r + c] is the element in the r'th row and c'th column. 25 | type Mat4 [16]float64 26 | 27 | // Aff3 is a 3x3 affine transformation matrix in row major order, where the 28 | // bottom row is implicitly [0 0 1]. 29 | // 30 | // m[3*r + c] is the element in the r'th row and c'th column. 31 | type Aff3 [6]float64 32 | 33 | // Aff4 is a 4x4 affine transformation matrix in row major order, where the 34 | // bottom row is implicitly [0 0 0 1]. 35 | // 36 | // m[4*r + c] is the element in the r'th row and c'th column. 37 | type Aff4 [12]float64 38 | -------------------------------------------------------------------------------- /vendor/golang.org/x/exp/shiny/driver/mtldriver/screen.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build darwin 6 | // +build darwin 7 | 8 | package mtldriver 9 | 10 | import ( 11 | "image" 12 | 13 | "github.com/go-gl/glfw/v3.3/glfw" 14 | "golang.org/x/exp/shiny/screen" 15 | ) 16 | 17 | // screenImpl implements screen.Screen. 18 | type screenImpl struct { 19 | newWindowCh chan newWindowReq 20 | } 21 | 22 | func (*screenImpl) NewBuffer(size image.Point) (screen.Buffer, error) { 23 | return &bufferImpl{ 24 | rgba: image.NewRGBA(image.Rectangle{Max: size}), 25 | }, nil 26 | } 27 | 28 | func (*screenImpl) NewTexture(size image.Point) (screen.Texture, error) { 29 | return &textureImpl{ 30 | rgba: image.NewRGBA(image.Rectangle{Max: size}), 31 | }, nil 32 | } 33 | 34 | func (s *screenImpl) NewWindow(opts *screen.NewWindowOptions) (screen.Window, error) { 35 | respCh := make(chan newWindowResp) 36 | s.newWindowCh <- newWindowReq{ 37 | opts: opts, 38 | respCh: respCh, 39 | } 40 | glfw.PostEmptyEvent() // Break main loop out of glfw.WaitEvents so it can receive on newWindowCh. 41 | resp := <-respCh 42 | return resp.w, resp.err 43 | } 44 | -------------------------------------------------------------------------------- /pp/pp.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 "as". All rights reserved. Torgo is governed 2 | // the same BSD license as the go programming language. 3 | package main 4 | 5 | import ( 6 | "bytes" 7 | "encoding/json" 8 | "flag" 9 | "fmt" 10 | "io" 11 | "io/ioutil" 12 | "log" 13 | "os" 14 | ) 15 | 16 | const prefix = "pp: " 17 | 18 | var ( 19 | h1, h2 = flag.Bool("h", false, "help"), flag.Bool("?", false, "help") 20 | ) 21 | 22 | func init() { 23 | log.SetPrefix(prefix) 24 | flag.Parse() 25 | if *h1 || *h2 { 26 | usage() 27 | os.Exit(0) 28 | } 29 | } 30 | 31 | func main() { 32 | src, err := ioutil.ReadAll(os.Stdin) 33 | ck("read", err) 34 | 35 | dst := new(bytes.Buffer) 36 | 37 | if err = json.Indent(dst, src, "", "\t"); err != nil { 38 | fmt.Print(string(src)) 39 | os.Exit(1) 40 | } 41 | _, err = io.Copy(os.Stdout, dst) 42 | ck("write", err) 43 | } 44 | 45 | func ck(where string, err error) { 46 | if err != nil { 47 | log.Fatalf("%s: %v", where, err) 48 | } 49 | } 50 | 51 | func usage() { 52 | fmt.Print(` 53 | NAME 54 | pp - pretty print 55 | 56 | SYNOPSIS 57 | pp 58 | 59 | DESCRIPTION 60 | Pp is a pretty printer. If it can't make it pretty, 61 | it outputs the current ugly and returns a non-zero exit code 62 | 63 | BUGS 64 | Only works on JSON for now 65 | `) 66 | } 67 | -------------------------------------------------------------------------------- /vendor/github.com/as/log/LICENSE: -------------------------------------------------------------------------------- 1 | This is free and unencumbered software released into the public domain. 2 | 3 | Anyone is free to copy, modify, publish, use, compile, sell, or 4 | distribute this software, either in source code form or as a compiled 5 | binary, for any purpose, commercial or non-commercial, and by any 6 | means. 7 | 8 | In jurisdictions that recognize copyright laws, the author or authors 9 | of this software dedicate any and all copyright interest in the 10 | software to the public domain. We make this dedication for the benefit 11 | of the public at large and to the detriment of our heirs and 12 | successors. We intend this dedication to be an overt act of 13 | relinquishment in perpetuity of all present and future rights to this 14 | software under copyright law. 15 | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 17 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 18 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 19 | IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR 20 | OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 21 | ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 22 | OTHER DEALINGS IN THE SOFTWARE. 23 | 24 | For more information, please refer to 25 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/curve25519/internal/field/fe_arm64.s: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2020 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build arm64 && gc && !purego 6 | // +build arm64,gc,!purego 7 | 8 | #include "textflag.h" 9 | 10 | // carryPropagate works exactly like carryPropagateGeneric and uses the 11 | // same AND, ADD, and LSR+MADD instructions emitted by the compiler, but 12 | // avoids loading R0-R4 twice and uses LDP and STP. 13 | // 14 | // See https://golang.org/issues/43145 for the main compiler issue. 15 | // 16 | // func carryPropagate(v *Element) 17 | TEXT ·carryPropagate(SB),NOFRAME|NOSPLIT,$0-8 18 | MOVD v+0(FP), R20 19 | 20 | LDP 0(R20), (R0, R1) 21 | LDP 16(R20), (R2, R3) 22 | MOVD 32(R20), R4 23 | 24 | AND $0x7ffffffffffff, R0, R10 25 | AND $0x7ffffffffffff, R1, R11 26 | AND $0x7ffffffffffff, R2, R12 27 | AND $0x7ffffffffffff, R3, R13 28 | AND $0x7ffffffffffff, R4, R14 29 | 30 | ADD R0>>51, R11, R11 31 | ADD R1>>51, R12, R12 32 | ADD R2>>51, R13, R13 33 | ADD R3>>51, R14, R14 34 | // R4>>51 * 19 + R10 -> R10 35 | LSR $51, R4, R21 36 | MOVD $19, R22 37 | MADD R22, R10, R21, R10 38 | 39 | STP (R10, R11), 0(R20) 40 | STP (R12, R13), 16(R20) 41 | MOVD R14, 32(R20) 42 | 43 | RET 44 | -------------------------------------------------------------------------------- /vendor/github.com/as/frame/pointof.go: -------------------------------------------------------------------------------- 1 | package frame 2 | 3 | import ( 4 | "image" 5 | ) 6 | 7 | // Grid returns a grid-aligned point on the frame relative to pt 8 | func (f *Frame) Grid(pt image.Point) image.Point { 9 | if f == nil { 10 | return image.ZP 11 | } 12 | return f.grid(pt) 13 | } 14 | 15 | // PointOf returns the point on the closest to index p. 16 | func (f *Frame) PointOf(p int64) image.Point { 17 | if f == nil { 18 | return image.ZP 19 | } 20 | return f.pointOf(p, f.r.Min, 0) 21 | } 22 | 23 | func (f *Frame) grid(pt image.Point) image.Point { 24 | pt.Y -= f.r.Min.Y 25 | pt.Y -= pt.Y % f.Face.Dy() 26 | pt.Y += f.r.Min.Y 27 | if pt.X > f.r.Max.X { 28 | pt.X = f.r.Max.X 29 | } 30 | return pt 31 | } 32 | func (f *Frame) pointOf(p int64, pt image.Point, bn int) (x image.Point) { 33 | for ; bn < f.Nbox; bn++ { 34 | b := &f.Box[bn] 35 | pt = f.wrapMax(pt, b) 36 | l := b.Len() 37 | if p < int64(l) { 38 | if b.Nrune > 0 { 39 | ptr := b.Ptr 40 | if p > 0 { 41 | pt.X += f.Face.Dx(ptr[:p]) 42 | } 43 | } 44 | break 45 | } 46 | p -= int64(l) 47 | pt = f.advance(pt, b) 48 | } 49 | return pt 50 | } 51 | 52 | func (f *Frame) pointOfBox(p int64, nb int) (pt image.Point) { 53 | Nbox := f.Nbox 54 | f.Nbox = nb 55 | pt = f.pointOf(p, f.r.Min, 0) 56 | f.Nbox = Nbox 57 | return pt 58 | } 59 | -------------------------------------------------------------------------------- /vendor/github.com/as/frame/box/b.go: -------------------------------------------------------------------------------- 1 | package box 2 | 3 | type B interface { 4 | Seek(bn int, whence int) int 5 | Next() bool 6 | Prev() bool 7 | Box() *Box 8 | } 9 | type boxes struct { 10 | bn int 11 | b []Box 12 | } 13 | 14 | func clamp(v, l, h int) int { 15 | if v < l { 16 | return l 17 | } 18 | if v > h { 19 | return h 20 | } 21 | return v 22 | } 23 | func (b *boxes) Prev() bool { 24 | if b.bn == 0 { 25 | return false 26 | } 27 | b.bn-- 28 | return true 29 | } 30 | func (b *boxes) Next() bool { 31 | if b.bn+1 == len(b.b) { 32 | return false 33 | } 34 | b.bn++ 35 | return true 36 | } 37 | func (b *boxes) Box() *Box { 38 | return &b.b[b.bn] 39 | } 40 | 41 | func (b *boxes) Seek(bn int, whence int) int { 42 | oldbn := b.bn 43 | switch whence { 44 | case 0: 45 | b.bn = clamp(bn, 0, len(b.b)) 46 | case 1: 47 | b.bn = clamp(b.bn+bn, 0, len(b.b)) 48 | case 2: 49 | b.bn = clamp(b.bn+bn, 0, len(b.b)) 50 | } 51 | return oldbn 52 | } 53 | 54 | func PrevLine(bx B) bool { 55 | if bx.Seek(0, 1) == 0 { 56 | return false 57 | } 58 | for bx.Box().Break() != '\n' && bx.Prev() { 59 | } 60 | if bx.Seek(0, 1) == 0 && bx.Box().Break() == '\n' { 61 | return true 62 | } 63 | for bx.Prev() && bx.Box().Break() != '\n' { 64 | } 65 | if bx.Box().Break() == '\n' { 66 | return bx.Next() 67 | } 68 | return true 69 | } 70 | -------------------------------------------------------------------------------- /uq/uq.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 "as". All rights reserved. Torgo is governed 2 | // the same BSD license as the go programming language. 3 | package main 4 | 5 | import ( 6 | "flag" 7 | "fmt" 8 | "io/ioutil" 9 | "log" 10 | "os" 11 | "strconv" 12 | ) 13 | 14 | const prefix = "uq: " 15 | 16 | var ( 17 | h1, h2 = flag.Bool("h", false, "help"), flag.Bool("?", false, "help") 18 | ) 19 | 20 | func init() { 21 | log.SetPrefix(prefix) 22 | flag.Parse() 23 | if *h1 || *h2 { 24 | usage() 25 | os.Exit(0) 26 | } 27 | } 28 | 29 | func main() { 30 | src, err := ioutil.ReadAll(os.Stdin) 31 | ck("read", err) 32 | 33 | dst, err := strconv.Unquote(string(src)) 34 | if err != nil { 35 | dst, err = strconv.Unquote(`"` + string(src) + `"`) 36 | } 37 | if err != nil { 38 | fmt.Print(string(src)) 39 | os.Exit(1) 40 | } else { 41 | fmt.Print(string(dst)) 42 | } 43 | } 44 | 45 | func ck(where string, err error) { 46 | if err != nil { 47 | log.Fatalf("%s: %v", where, err) 48 | } 49 | } 50 | 51 | func usage() { 52 | fmt.Print(` 53 | NAME 54 | uq - unquote input 55 | 56 | SYNOPSIS 57 | uq < quoted.txt 58 | 59 | DESCRIPTION 60 | Uq reads from standard input and unquotes it using the Go rules 61 | for quotation. Uq is non-destructive. If the operation fails, uq prints 62 | the original input and exits with a non-zero status. 63 | `) 64 | } 65 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/memory_windows.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package windows 6 | 7 | const ( 8 | MEM_COMMIT = 0x00001000 9 | MEM_RESERVE = 0x00002000 10 | MEM_DECOMMIT = 0x00004000 11 | MEM_RELEASE = 0x00008000 12 | MEM_RESET = 0x00080000 13 | MEM_TOP_DOWN = 0x00100000 14 | MEM_WRITE_WATCH = 0x00200000 15 | MEM_PHYSICAL = 0x00400000 16 | MEM_RESET_UNDO = 0x01000000 17 | MEM_LARGE_PAGES = 0x20000000 18 | 19 | PAGE_NOACCESS = 0x00000001 20 | PAGE_READONLY = 0x00000002 21 | PAGE_READWRITE = 0x00000004 22 | PAGE_WRITECOPY = 0x00000008 23 | PAGE_EXECUTE = 0x00000010 24 | PAGE_EXECUTE_READ = 0x00000020 25 | PAGE_EXECUTE_READWRITE = 0x00000040 26 | PAGE_EXECUTE_WRITECOPY = 0x00000080 27 | PAGE_GUARD = 0x00000100 28 | PAGE_NOCACHE = 0x00000200 29 | PAGE_WRITECOMBINE = 0x00000400 30 | PAGE_TARGETS_INVALID = 0x40000000 31 | PAGE_TARGETS_NO_UPDATE = 0x40000000 32 | 33 | QUOTA_LIMITS_HARDWS_MIN_DISABLE = 0x00000002 34 | QUOTA_LIMITS_HARDWS_MIN_ENABLE = 0x00000001 35 | QUOTA_LIMITS_HARDWS_MAX_DISABLE = 0x00000008 36 | QUOTA_LIMITS_HARDWS_MAX_ENABLE = 0x00000004 37 | ) 38 | -------------------------------------------------------------------------------- /vendor/github.com/as/font/cliche.go: -------------------------------------------------------------------------------- 1 | package font 2 | 3 | import ( 4 | "image" 5 | "image/color" 6 | "image/draw" 7 | 8 | "golang.org/x/image/font" 9 | ) 10 | 11 | type Cliche interface { 12 | Cache 13 | LoadBox(s []byte, fg, bg color.Color) image.Image 14 | } 15 | 16 | type boxsig struct { 17 | b string 18 | fg color.RGBA 19 | bg color.RGBA 20 | } 21 | 22 | func NewCliche(f font.Face) Cliche { 23 | if f, ok := f.(Cliche); ok { 24 | return f 25 | } 26 | return &cliche{ 27 | Cache: NewCache(f), 28 | cache: make(map[boxsig]image.Image), 29 | } 30 | } 31 | 32 | type cliche struct { 33 | Cache 34 | cache map[boxsig]image.Image 35 | } 36 | 37 | func (c *cliche) LoadBox(b []byte, fg, bg color.Color) image.Image { 38 | if len(b) == 0 { 39 | return nil 40 | } 41 | sig := boxsig{string(b), convert(fg), convert(bg)} 42 | if img, ok := c.cache[sig]; ok { 43 | return img 44 | } 45 | var list []image.Image 46 | dx := 0 47 | for _, v := range b { 48 | img := c.LoadGlyph(rune(v), fg, bg) 49 | dx += img.Bounds().Dx() 50 | list = append(list, img) 51 | } 52 | r := list[0].Bounds() 53 | r.Max.X += dx 54 | boximg := image.NewRGBA(r) 55 | for _, img := range list { 56 | dx := img.Bounds().Dx() 57 | r.Max.X += dx 58 | draw.Draw(boximg, r, img, image.ZP, draw.Src) 59 | r.Min.X += dx 60 | } 61 | c.cache[sig] = boximg 62 | return boximg 63 | } 64 | -------------------------------------------------------------------------------- /x/find.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bufio" 5 | "bytes" 6 | "io" 7 | 8 | "github.com/as/io/rev" 9 | ) 10 | 11 | func findlinerev(p []byte, org, N int64) (q0, q1 int64) { 12 | N = -N + 1 13 | p0 := p 14 | p = p[:org] 15 | q0, q1 = findline2(N, rev.NewReader(p)) // 0 = len(p)-1 16 | l := q1 - q0 17 | q0 = org - q1 18 | q1 = q0 + l 19 | q0 = q1 - l 20 | if q0 >= 0 && q0 < int64(len(p0)) && p0[q0] == '\n' { 21 | q0++ 22 | } 23 | return 24 | } 25 | func findline3(p []byte, org, N int64) (q0, q1 int64) { 26 | p = p[org:] 27 | q0, q1 = findline2(N, bytes.NewReader(p)) 28 | return q0 + org, q1 + org 29 | } 30 | 31 | // Put Edit 354 32 | func findline2(N int64, r io.Reader) (q0, q1 int64) { 33 | br := bufio.NewReader(r) 34 | nl := int64(0) 35 | for nl != N { 36 | b, err := br.ReadByte() 37 | if err != nil { 38 | break 39 | } 40 | q1++ 41 | if b == '\n' { 42 | nl++ 43 | if nl == N { 44 | break 45 | } 46 | q0 = q1 47 | } 48 | } 49 | return 50 | } 51 | 52 | func findline(N int64, p []byte) (q0, q1 int64) { 53 | nl := int64(0) 54 | l := int64(len(p)) 55 | for ; q1 < l; q1++ { 56 | if p[q1] != '\n' { 57 | continue 58 | } 59 | nl++ 60 | if nl == N { 61 | if q0 != 0 { 62 | q0++ 63 | } 64 | q1++ 65 | break 66 | } 67 | q0 = q1 68 | } 69 | if q1 >= l { 70 | q0++ 71 | } 72 | return q0, q1 73 | } 74 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/poly1305/sum_amd64.go: -------------------------------------------------------------------------------- 1 | // Copyright 2012 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build gc && !purego 6 | // +build gc,!purego 7 | 8 | package poly1305 9 | 10 | //go:noescape 11 | func update(state *macState, msg []byte) 12 | 13 | // mac is a wrapper for macGeneric that redirects calls that would have gone to 14 | // updateGeneric to update. 15 | // 16 | // Its Write and Sum methods are otherwise identical to the macGeneric ones, but 17 | // using function pointers would carry a major performance cost. 18 | type mac struct{ macGeneric } 19 | 20 | func (h *mac) Write(p []byte) (int, error) { 21 | nn := len(p) 22 | if h.offset > 0 { 23 | n := copy(h.buffer[h.offset:], p) 24 | if h.offset+n < TagSize { 25 | h.offset += n 26 | return nn, nil 27 | } 28 | p = p[n:] 29 | h.offset = 0 30 | update(&h.macState, h.buffer[:]) 31 | } 32 | if n := len(p) - (len(p) % TagSize); n > 0 { 33 | update(&h.macState, p[:n]) 34 | p = p[n:] 35 | } 36 | if len(p) > 0 { 37 | h.offset += copy(h.buffer[h.offset:], p) 38 | } 39 | return nn, nil 40 | } 41 | 42 | func (h *mac) Sum(out *[16]byte) { 43 | state := h.macState 44 | if h.offset > 0 { 45 | update(&state, h.buffer[:h.offset]) 46 | } 47 | finalize(out, &state.h, &state.s) 48 | } 49 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/poly1305/sum_ppc64le.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build gc && !purego 6 | // +build gc,!purego 7 | 8 | package poly1305 9 | 10 | //go:noescape 11 | func update(state *macState, msg []byte) 12 | 13 | // mac is a wrapper for macGeneric that redirects calls that would have gone to 14 | // updateGeneric to update. 15 | // 16 | // Its Write and Sum methods are otherwise identical to the macGeneric ones, but 17 | // using function pointers would carry a major performance cost. 18 | type mac struct{ macGeneric } 19 | 20 | func (h *mac) Write(p []byte) (int, error) { 21 | nn := len(p) 22 | if h.offset > 0 { 23 | n := copy(h.buffer[h.offset:], p) 24 | if h.offset+n < TagSize { 25 | h.offset += n 26 | return nn, nil 27 | } 28 | p = p[n:] 29 | h.offset = 0 30 | update(&h.macState, h.buffer[:]) 31 | } 32 | if n := len(p) - (len(p) % TagSize); n > 0 { 33 | update(&h.macState, p[:n]) 34 | p = p[n:] 35 | } 36 | if len(p) > 0 { 37 | h.offset += copy(h.buffer[h.offset:], p) 38 | } 39 | return nn, nil 40 | } 41 | 42 | func (h *mac) Sum(out *[16]byte) { 43 | state := h.macState 44 | if h.offset > 0 { 45 | update(&state, h.buffer[:h.offset]) 46 | } 47 | finalize(out, &state.h, &state.s) 48 | } 49 | -------------------------------------------------------------------------------- /vendor/golang.org/x/exp/shiny/driver/gldriver/buffer.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package gldriver 6 | 7 | import "image" 8 | 9 | type bufferImpl struct { 10 | // buf should always be equal to (i.e. the same ptr, len, cap as) rgba.Pix. 11 | // It is a separate, redundant field in order to detect modifications to 12 | // the rgba field that are invalid as per the screen.Buffer documentation. 13 | buf []byte 14 | rgba image.RGBA 15 | size image.Point 16 | } 17 | 18 | func (b *bufferImpl) Release() {} 19 | func (b *bufferImpl) Size() image.Point { return b.size } 20 | func (b *bufferImpl) Bounds() image.Rectangle { return image.Rectangle{Max: b.size} } 21 | func (b *bufferImpl) RGBA() *image.RGBA { return &b.rgba } 22 | 23 | func (b *bufferImpl) preUpload() { 24 | // Check that the program hasn't tried to modify the rgba field via the 25 | // pointer returned by the bufferImpl.RGBA method. This check doesn't catch 26 | // 100% of all cases; it simply tries to detect some invalid uses of a 27 | // screen.Buffer such as: 28 | // *buffer.RGBA() = anotherImageRGBA 29 | if len(b.buf) != 0 && len(b.rgba.Pix) != 0 && &b.buf[0] != &b.rgba.Pix[0] { 30 | panic("gldriver: invalid Buffer.RGBA modification") 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/PATENTS: -------------------------------------------------------------------------------- 1 | Additional IP Rights Grant (Patents) 2 | 3 | "This implementation" means the copyrightable works distributed by 4 | Google as part of the Go project. 5 | 6 | Google hereby grants to You a perpetual, worldwide, non-exclusive, 7 | no-charge, royalty-free, irrevocable (except as stated in this section) 8 | patent license to make, have made, use, offer to sell, sell, import, 9 | transfer and otherwise run, modify and propagate the contents of this 10 | implementation of Go, where such license applies only to those patent 11 | claims, both currently owned or controlled by Google and acquired in 12 | the future, licensable by Google that are necessarily infringed by this 13 | implementation of Go. This grant does not include claims that would be 14 | infringed only as a consequence of further modification of this 15 | implementation. If you or your agent or exclusive licensee institute or 16 | order or agree to the institution of patent litigation against any 17 | entity (including a cross-claim or counterclaim in a lawsuit) alleging 18 | that this implementation of Go or any code incorporated within this 19 | implementation of Go constitutes direct or contributory patent 20 | infringement, or inducement of patent infringement, then any patent 21 | rights granted to you under this License for this implementation of Go 22 | shall terminate as of the date such litigation is filed. 23 | -------------------------------------------------------------------------------- /vendor/golang.org/x/exp/PATENTS: -------------------------------------------------------------------------------- 1 | Additional IP Rights Grant (Patents) 2 | 3 | "This implementation" means the copyrightable works distributed by 4 | Google as part of the Go project. 5 | 6 | Google hereby grants to You a perpetual, worldwide, non-exclusive, 7 | no-charge, royalty-free, irrevocable (except as stated in this section) 8 | patent license to make, have made, use, offer to sell, sell, import, 9 | transfer and otherwise run, modify and propagate the contents of this 10 | implementation of Go, where such license applies only to those patent 11 | claims, both currently owned or controlled by Google and acquired in 12 | the future, licensable by Google that are necessarily infringed by this 13 | implementation of Go. This grant does not include claims that would be 14 | infringed only as a consequence of further modification of this 15 | implementation. If you or your agent or exclusive licensee institute or 16 | order or agree to the institution of patent litigation against any 17 | entity (including a cross-claim or counterclaim in a lawsuit) alleging 18 | that this implementation of Go or any code incorporated within this 19 | implementation of Go constitutes direct or contributory patent 20 | infringement, or inducement of patent infringement, then any patent 21 | rights granted to you under this License for this implementation of Go 22 | shall terminate as of the date such litigation is filed. 23 | -------------------------------------------------------------------------------- /vendor/golang.org/x/image/PATENTS: -------------------------------------------------------------------------------- 1 | Additional IP Rights Grant (Patents) 2 | 3 | "This implementation" means the copyrightable works distributed by 4 | Google as part of the Go project. 5 | 6 | Google hereby grants to You a perpetual, worldwide, non-exclusive, 7 | no-charge, royalty-free, irrevocable (except as stated in this section) 8 | patent license to make, have made, use, offer to sell, sell, import, 9 | transfer and otherwise run, modify and propagate the contents of this 10 | implementation of Go, where such license applies only to those patent 11 | claims, both currently owned or controlled by Google and acquired in 12 | the future, licensable by Google that are necessarily infringed by this 13 | implementation of Go. This grant does not include claims that would be 14 | infringed only as a consequence of further modification of this 15 | implementation. If you or your agent or exclusive licensee institute or 16 | order or agree to the institution of patent litigation against any 17 | entity (including a cross-claim or counterclaim in a lawsuit) alleging 18 | that this implementation of Go or any code incorporated within this 19 | implementation of Go constitutes direct or contributory patent 20 | infringement, or inducement of patent infringement, then any patent 21 | rights granted to you under this License for this implementation of Go 22 | shall terminate as of the date such litigation is filed. 23 | -------------------------------------------------------------------------------- /vendor/golang.org/x/mobile/PATENTS: -------------------------------------------------------------------------------- 1 | Additional IP Rights Grant (Patents) 2 | 3 | "This implementation" means the copyrightable works distributed by 4 | Google as part of the Go project. 5 | 6 | Google hereby grants to You a perpetual, worldwide, non-exclusive, 7 | no-charge, royalty-free, irrevocable (except as stated in this section) 8 | patent license to make, have made, use, offer to sell, sell, import, 9 | transfer and otherwise run, modify and propagate the contents of this 10 | implementation of Go, where such license applies only to those patent 11 | claims, both currently owned or controlled by Google and acquired in 12 | the future, licensable by Google that are necessarily infringed by this 13 | implementation of Go. This grant does not include claims that would be 14 | infringed only as a consequence of further modification of this 15 | implementation. If you or your agent or exclusive licensee institute or 16 | order or agree to the institution of patent litigation against any 17 | entity (including a cross-claim or counterclaim in a lawsuit) alleging 18 | that this implementation of Go or any code incorporated within this 19 | implementation of Go constitutes direct or contributory patent 20 | infringement, or inducement of patent infringement, then any patent 21 | rights granted to you under this License for this implementation of Go 22 | shall terminate as of the date such litigation is filed. 23 | -------------------------------------------------------------------------------- /vendor/golang.org/x/net/PATENTS: -------------------------------------------------------------------------------- 1 | Additional IP Rights Grant (Patents) 2 | 3 | "This implementation" means the copyrightable works distributed by 4 | Google as part of the Go project. 5 | 6 | Google hereby grants to You a perpetual, worldwide, non-exclusive, 7 | no-charge, royalty-free, irrevocable (except as stated in this section) 8 | patent license to make, have made, use, offer to sell, sell, import, 9 | transfer and otherwise run, modify and propagate the contents of this 10 | implementation of Go, where such license applies only to those patent 11 | claims, both currently owned or controlled by Google and acquired in 12 | the future, licensable by Google that are necessarily infringed by this 13 | implementation of Go. This grant does not include claims that would be 14 | infringed only as a consequence of further modification of this 15 | implementation. If you or your agent or exclusive licensee institute or 16 | order or agree to the institution of patent litigation against any 17 | entity (including a cross-claim or counterclaim in a lawsuit) alleging 18 | that this implementation of Go or any code incorporated within this 19 | implementation of Go constitutes direct or contributory patent 20 | infringement, or inducement of patent infringement, then any patent 21 | rights granted to you under this License for this implementation of Go 22 | shall terminate as of the date such litigation is filed. 23 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/PATENTS: -------------------------------------------------------------------------------- 1 | Additional IP Rights Grant (Patents) 2 | 3 | "This implementation" means the copyrightable works distributed by 4 | Google as part of the Go project. 5 | 6 | Google hereby grants to You a perpetual, worldwide, non-exclusive, 7 | no-charge, royalty-free, irrevocable (except as stated in this section) 8 | patent license to make, have made, use, offer to sell, sell, import, 9 | transfer and otherwise run, modify and propagate the contents of this 10 | implementation of Go, where such license applies only to those patent 11 | claims, both currently owned or controlled by Google and acquired in 12 | the future, licensable by Google that are necessarily infringed by this 13 | implementation of Go. This grant does not include claims that would be 14 | infringed only as a consequence of further modification of this 15 | implementation. If you or your agent or exclusive licensee institute or 16 | order or agree to the institution of patent litigation against any 17 | entity (including a cross-claim or counterclaim in a lawsuit) alleging 18 | that this implementation of Go or any code incorporated within this 19 | implementation of Go constitutes direct or contributory patent 20 | infringement, or inducement of patent infringement, then any patent 21 | rights granted to you under this License for this implementation of Go 22 | shall terminate as of the date such litigation is filed. 23 | -------------------------------------------------------------------------------- /vendor/golang.org/x/text/PATENTS: -------------------------------------------------------------------------------- 1 | Additional IP Rights Grant (Patents) 2 | 3 | "This implementation" means the copyrightable works distributed by 4 | Google as part of the Go project. 5 | 6 | Google hereby grants to You a perpetual, worldwide, non-exclusive, 7 | no-charge, royalty-free, irrevocable (except as stated in this section) 8 | patent license to make, have made, use, offer to sell, sell, import, 9 | transfer and otherwise run, modify and propagate the contents of this 10 | implementation of Go, where such license applies only to those patent 11 | claims, both currently owned or controlled by Google and acquired in 12 | the future, licensable by Google that are necessarily infringed by this 13 | implementation of Go. This grant does not include claims that would be 14 | infringed only as a consequence of further modification of this 15 | implementation. If you or your agent or exclusive licensee institute or 16 | order or agree to the institution of patent litigation against any 17 | entity (including a cross-claim or counterclaim in a lawsuit) alleging 18 | that this implementation of Go or any code incorporated within this 19 | implementation of Go constitutes direct or contributory patent 20 | infringement, or inducement of patent infringement, then any patent 21 | rights granted to you under this License for this implementation of Go 22 | shall terminate as of the date such litigation is filed. 23 | -------------------------------------------------------------------------------- /vendor/golang.org/x/image/tiff/compress.go: -------------------------------------------------------------------------------- 1 | // Copyright 2011 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package tiff 6 | 7 | import ( 8 | "bufio" 9 | "io" 10 | ) 11 | 12 | type byteReader interface { 13 | io.Reader 14 | io.ByteReader 15 | } 16 | 17 | // unpackBits decodes the PackBits-compressed data in src and returns the 18 | // uncompressed data. 19 | // 20 | // The PackBits compression format is described in section 9 (p. 42) 21 | // of the TIFF spec. 22 | func unpackBits(r io.Reader) ([]byte, error) { 23 | buf := make([]byte, 128) 24 | dst := make([]byte, 0, 1024) 25 | br, ok := r.(byteReader) 26 | if !ok { 27 | br = bufio.NewReader(r) 28 | } 29 | 30 | for { 31 | b, err := br.ReadByte() 32 | if err != nil { 33 | if err == io.EOF { 34 | return dst, nil 35 | } 36 | return nil, err 37 | } 38 | code := int(int8(b)) 39 | switch { 40 | case code >= 0: 41 | n, err := io.ReadFull(br, buf[:code+1]) 42 | if err != nil { 43 | return nil, err 44 | } 45 | dst = append(dst, buf[:n]...) 46 | case code == -128: 47 | // No-op. 48 | default: 49 | if b, err = br.ReadByte(); err != nil { 50 | return nil, err 51 | } 52 | for j := 0; j < 1-code; j++ { 53 | buf[j] = b 54 | } 55 | dst = append(dst, buf[:1-code]...) 56 | } 57 | } 58 | } 59 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_gccgo_x86.c: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // +build 386 amd64 amd64p32 6 | // +build gccgo 7 | 8 | #include 9 | #include 10 | 11 | // Need to wrap __get_cpuid_count because it's declared as static. 12 | int 13 | gccgoGetCpuidCount(uint32_t leaf, uint32_t subleaf, 14 | uint32_t *eax, uint32_t *ebx, 15 | uint32_t *ecx, uint32_t *edx) 16 | { 17 | return __get_cpuid_count(leaf, subleaf, eax, ebx, ecx, edx); 18 | } 19 | 20 | // xgetbv reads the contents of an XCR (Extended Control Register) 21 | // specified in the ECX register into registers EDX:EAX. 22 | // Currently, the only supported value for XCR is 0. 23 | // 24 | // TODO: Replace with a better alternative: 25 | // 26 | // #include 27 | // 28 | // #pragma GCC target("xsave") 29 | // 30 | // void gccgoXgetbv(uint32_t *eax, uint32_t *edx) { 31 | // unsigned long long x = _xgetbv(0); 32 | // *eax = x & 0xffffffff; 33 | // *edx = (x >> 32) & 0xffffffff; 34 | // } 35 | // 36 | // Note that _xgetbv is defined starting with GCC 8. 37 | void 38 | gccgoXgetbv(uint32_t *eax, uint32_t *edx) 39 | { 40 | __asm(" xorl %%ecx, %%ecx\n" 41 | " xgetbv" 42 | : "=a"(*eax), "=d"(*edx)); 43 | } 44 | -------------------------------------------------------------------------------- /vendor/github.com/as/log/README.md: -------------------------------------------------------------------------------- 1 | # Synopsis 2 | 3 | Package log implements a structured JSON log which can't be 4 | easily dependency injected into your microservice (on purpose). 5 | 6 | # Variables 7 | 8 | To use, first override the package-scoped variables at runtime. 9 | 10 | ``` 11 | var ( 12 | // Service name 13 | Service = "" 14 | 15 | // Time is your time function 16 | Time = func() interface{} { 17 | return time.Now().UnixNano() / int64(time.Millisecond) 18 | } 19 | 20 | // Default is the level used when calling Printf and Fatalf 21 | Default = Info 22 | ) 23 | ``` 24 | 25 | # Examples 26 | 27 | main.go 28 | ``` 29 | package main 30 | 31 | import "github.com/as/log" 32 | 33 | func main() { 34 | log.Service = "ex" 35 | log.Time = func() interface{} { return "2121.12.04" } 36 | 37 | log.Error.Add( 38 | "env", "prod", 39 | "burning", true, 40 | "pi", 3.14, 41 | ).Printf("error: %v", io.EOF) 42 | } 43 | ``` 44 | 45 | output 46 | ``` 47 | {"svc":"ex", "time":"2121.12.04", "level":"error", "msg":"error: EOF", "env":"prod", "burning":true, "pi":3.14} 48 | ``` 49 | 50 | # Install 51 | 52 | ``` 53 | go get github.com/as/log 54 | go test github.com/as/log -v -bench . 55 | go test github.com/as/log -race -count 1 56 | ``` 57 | 58 | This code may also be copied and pasted into your microservice 59 | and modified to your liking. Put it in a package called 60 | log. A little copying is better than a little dependency. 61 | -------------------------------------------------------------------------------- /vendor/golang.org/x/exp/shiny/driver/internal/drawer/drawer.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Package drawer provides functions that help implement screen.Drawer methods. 6 | package drawer // import "golang.org/x/exp/shiny/driver/internal/drawer" 7 | 8 | import ( 9 | "image" 10 | "image/draw" 11 | 12 | "golang.org/x/exp/shiny/screen" 13 | "golang.org/x/image/math/f64" 14 | ) 15 | 16 | // Copy implements the Copy method of the screen.Drawer interface by calling 17 | // the Draw method of that same interface. 18 | func Copy(dst screen.Drawer, dp image.Point, src screen.Texture, sr image.Rectangle, op draw.Op, opts *screen.DrawOptions) { 19 | dst.Draw(f64.Aff3{ 20 | 1, 0, float64(dp.X - sr.Min.X), 21 | 0, 1, float64(dp.Y - sr.Min.Y), 22 | }, src, sr, op, opts) 23 | } 24 | 25 | // Scale implements the Scale method of the screen.Drawer interface by calling 26 | // the Draw method of that same interface. 27 | func Scale(dst screen.Drawer, dr image.Rectangle, src screen.Texture, sr image.Rectangle, op draw.Op, opts *screen.DrawOptions) { 28 | rx := float64(dr.Dx()) / float64(sr.Dx()) 29 | ry := float64(dr.Dy()) / float64(sr.Dy()) 30 | dst.Draw(f64.Aff3{ 31 | rx, 0, float64(dr.Min.X) - rx*float64(sr.Min.X), 32 | 0, ry, float64(dr.Min.Y) - ry*float64(sr.Min.Y), 33 | }, src, sr, op, opts) 34 | } 35 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/internal/subtle/aliasing.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build !purego 6 | // +build !purego 7 | 8 | // Package subtle implements functions that are often useful in cryptographic 9 | // code but require careful thought to use correctly. 10 | package subtle // import "golang.org/x/crypto/internal/subtle" 11 | 12 | import "unsafe" 13 | 14 | // AnyOverlap reports whether x and y share memory at any (not necessarily 15 | // corresponding) index. The memory beyond the slice length is ignored. 16 | func AnyOverlap(x, y []byte) bool { 17 | return len(x) > 0 && len(y) > 0 && 18 | uintptr(unsafe.Pointer(&x[0])) <= uintptr(unsafe.Pointer(&y[len(y)-1])) && 19 | uintptr(unsafe.Pointer(&y[0])) <= uintptr(unsafe.Pointer(&x[len(x)-1])) 20 | } 21 | 22 | // InexactOverlap reports whether x and y share memory at any non-corresponding 23 | // index. The memory beyond the slice length is ignored. Note that x and y can 24 | // have different lengths and still not have any inexact overlap. 25 | // 26 | // InexactOverlap can be used to implement the requirements of the crypto/cipher 27 | // AEAD, Block, BlockMode and Stream interfaces. 28 | func InexactOverlap(x, y []byte) bool { 29 | if len(x) == 0 || len(y) == 0 || &x[0] == &y[0] { 30 | return false 31 | } 32 | return AnyOverlap(x, y) 33 | } 34 | -------------------------------------------------------------------------------- /vendor/golang.org/x/exp/shiny/driver/x11driver/shm_openbsd_syscall.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build openbsd && (i386 || amd64) 6 | // +build openbsd 7 | // +build i386 amd64 8 | 9 | package x11driver 10 | 11 | import ( 12 | "fmt" 13 | "syscall" 14 | "unsafe" 15 | ) 16 | 17 | // These constants are from /usr/include/sys/ipc.h 18 | const ( 19 | ipcPrivate = 0 20 | ipcRmID = 0 21 | ) 22 | 23 | func shmOpen(size int) (shmid uintptr, addr unsafe.Pointer, err error) { 24 | shmid, _, errno0 := syscall.RawSyscall(syscall.SYS_SHMGET, ipcPrivate, uintptr(size), 0666) 25 | if errno0 != 0 { 26 | return 0, unsafe.Pointer(uintptr(0)), fmt.Errorf("shmget: %v", errno0) 27 | } 28 | p, _, errno1 := syscall.RawSyscall(syscall.SYS_SHMAT, shmid, 0, 0) 29 | _, _, errno2 := syscall.RawSyscall(syscall.SYS_SHMCTL, shmid, ipcRmID, 0) 30 | if errno1 != 0 { 31 | return 0, unsafe.Pointer(uintptr(0)), fmt.Errorf("shmat: %v", errno1) 32 | } 33 | if errno2 != 0 { 34 | return 0, unsafe.Pointer(uintptr(0)), fmt.Errorf("shmctl: %v", errno2) 35 | } 36 | return shmid, unsafe.Pointer(p), nil 37 | } 38 | 39 | func shmClose(p unsafe.Pointer) error { 40 | _, _, errno := syscall.RawSyscall(syscall.SYS_SHMDT, uintptr(p), 0, 0) 41 | if errno != 0 { 42 | return fmt.Errorf("shmdt: %v", errno) 43 | } 44 | return nil 45 | } 46 | -------------------------------------------------------------------------------- /vendor/golang.org/x/text/internal/language/tags.go: -------------------------------------------------------------------------------- 1 | // Copyright 2013 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package language 6 | 7 | // MustParse is like Parse, but panics if the given BCP 47 tag cannot be parsed. 8 | // It simplifies safe initialization of Tag values. 9 | func MustParse(s string) Tag { 10 | t, err := Parse(s) 11 | if err != nil { 12 | panic(err) 13 | } 14 | return t 15 | } 16 | 17 | // MustParseBase is like ParseBase, but panics if the given base cannot be parsed. 18 | // It simplifies safe initialization of Base values. 19 | func MustParseBase(s string) Language { 20 | b, err := ParseBase(s) 21 | if err != nil { 22 | panic(err) 23 | } 24 | return b 25 | } 26 | 27 | // MustParseScript is like ParseScript, but panics if the given script cannot be 28 | // parsed. It simplifies safe initialization of Script values. 29 | func MustParseScript(s string) Script { 30 | scr, err := ParseScript(s) 31 | if err != nil { 32 | panic(err) 33 | } 34 | return scr 35 | } 36 | 37 | // MustParseRegion is like ParseRegion, but panics if the given region cannot be 38 | // parsed. It simplifies safe initialization of Region values. 39 | func MustParseRegion(s string) Region { 40 | r, err := ParseRegion(s) 41 | if err != nil { 42 | panic(err) 43 | } 44 | return r 45 | } 46 | 47 | // Und is the root language. 48 | var Und Tag 49 | -------------------------------------------------------------------------------- /vendor/github.com/as/frame/color.go: -------------------------------------------------------------------------------- 1 | package frame 2 | 3 | import ( 4 | "image" 5 | ) 6 | 7 | var ( 8 | // Common uniform colors found in Acme 9 | Black = image.Black 10 | White = image.White 11 | Yellow = uniform(0xfffffdff) 12 | Red = uniform(0xffe8efff) 13 | Green = uniform(0xefffe8ff) 14 | Blue = uniform(0xe8efffff) 15 | 16 | // Other colors 17 | Gray = uniform(0x1c1f26ff) 18 | Peach = uniform(0xfff8e8ff) 19 | Mauve = uniform(0x9090C0ff) 20 | ) 21 | 22 | var ( 23 | // Acme is the color scheme found in the Acme text editor 24 | Acme = Theme(Gray, Yellow, White, Blue) 25 | Mono = Theme(Black, White, White, Black) 26 | A = Theme(Gray, Peach, White, Mauve) 27 | ) 28 | 29 | // Color is constructed from a Palette pair. The Hi Palette describes 30 | // the appearance of highlighted text. 31 | type Color struct { 32 | Palette 33 | Hi Palette 34 | } 35 | 36 | // Pallete contains two images used to paint text and backgrounds 37 | // on the frame. 38 | type Palette struct { 39 | Text, Back image.Image 40 | } 41 | 42 | // Theme returns a Color for the given foreground and background 43 | // images. Two extra colors may be provided to set the highlighted 44 | // foreground and background image palette. 45 | func Theme(fg, bg image.Image, hi ...image.Image) Color { 46 | c := Color{Palette: Palette{Text: fg, Back: bg}} 47 | if len(hi) > 0 { 48 | c.Hi.Text = hi[0] 49 | } 50 | if len(hi) > 1 { 51 | c.Hi.Back = hi[1] 52 | } 53 | return c 54 | } 55 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/chacha20/xor.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found src the LICENSE file. 4 | 5 | package chacha20 6 | 7 | import "runtime" 8 | 9 | // Platforms that have fast unaligned 32-bit little endian accesses. 10 | const unaligned = runtime.GOARCH == "386" || 11 | runtime.GOARCH == "amd64" || 12 | runtime.GOARCH == "arm64" || 13 | runtime.GOARCH == "ppc64le" || 14 | runtime.GOARCH == "s390x" 15 | 16 | // addXor reads a little endian uint32 from src, XORs it with (a + b) and 17 | // places the result in little endian byte order in dst. 18 | func addXor(dst, src []byte, a, b uint32) { 19 | _, _ = src[3], dst[3] // bounds check elimination hint 20 | if unaligned { 21 | // The compiler should optimize this code into 22 | // 32-bit unaligned little endian loads and stores. 23 | // TODO: delete once the compiler does a reliably 24 | // good job with the generic code below. 25 | // See issue #25111 for more details. 26 | v := uint32(src[0]) 27 | v |= uint32(src[1]) << 8 28 | v |= uint32(src[2]) << 16 29 | v |= uint32(src[3]) << 24 30 | v ^= a + b 31 | dst[0] = byte(v) 32 | dst[1] = byte(v >> 8) 33 | dst[2] = byte(v >> 16) 34 | dst[3] = byte(v >> 24) 35 | } else { 36 | a += b 37 | dst[0] = src[0] ^ byte(a) 38 | dst[1] = src[1] ^ byte(a>>8) 39 | dst[2] = src[2] ^ byte(a>>16) 40 | dst[3] = src[3] ^ byte(a>>24) 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /vendor/github.com/go-gl/glfw/v3.3/glfw/time.go: -------------------------------------------------------------------------------- 1 | package glfw 2 | 3 | //#define GLFW_INCLUDE_NONE 4 | //#include "glfw/include/GLFW/glfw3.h" 5 | import "C" 6 | 7 | // GetTime returns the value of the GLFW timer. Unless the timer has been set 8 | // using SetTime, the timer measures time elapsed since GLFW was initialized. 9 | // 10 | // The resolution of the timer is system dependent, but is usually on the order 11 | // of a few micro- or nanoseconds. It uses the highest-resolution monotonic time 12 | // source on each supported platform. 13 | func GetTime() float64 { 14 | ret := float64(C.glfwGetTime()) 15 | panicError() 16 | return ret 17 | } 18 | 19 | // SetTime sets the value of the GLFW timer. It then continues to count up from 20 | // that value. 21 | // 22 | // The resolution of the timer is system dependent, but is usually on the order 23 | // of a few micro- or nanoseconds. It uses the highest-resolution monotonic time 24 | // source on each supported platform. 25 | func SetTime(time float64) { 26 | C.glfwSetTime(C.double(time)) 27 | panicError() 28 | } 29 | 30 | // GetTimerFrequency returns frequency of the timer, in Hz, or zero if an error occurred. 31 | func GetTimerFrequency() uint64 { 32 | ret := uint64(C.glfwGetTimerFrequency()) 33 | panicError() 34 | return ret 35 | } 36 | 37 | // GetTimerValue returns the current value of the raw timer, measured in 1 / frequency seconds. 38 | func GetTimerValue() uint64 { 39 | ret := uint64(C.glfwGetTimerValue()) 40 | panicError() 41 | return ret 42 | } 43 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/env_windows.go: -------------------------------------------------------------------------------- 1 | // Copyright 2010 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Windows environment variables. 6 | 7 | package windows 8 | 9 | import ( 10 | "syscall" 11 | "unsafe" 12 | ) 13 | 14 | func Getenv(key string) (value string, found bool) { 15 | return syscall.Getenv(key) 16 | } 17 | 18 | func Setenv(key, value string) error { 19 | return syscall.Setenv(key, value) 20 | } 21 | 22 | func Clearenv() { 23 | syscall.Clearenv() 24 | } 25 | 26 | func Environ() []string { 27 | return syscall.Environ() 28 | } 29 | 30 | // Returns a default environment associated with the token, rather than the current 31 | // process. If inheritExisting is true, then this environment also inherits the 32 | // environment of the current process. 33 | func (token Token) Environ(inheritExisting bool) (env []string, err error) { 34 | var block *uint16 35 | err = CreateEnvironmentBlock(&block, token, inheritExisting) 36 | if err != nil { 37 | return nil, err 38 | } 39 | defer DestroyEnvironmentBlock(block) 40 | blockp := uintptr(unsafe.Pointer(block)) 41 | for { 42 | entry := UTF16PtrToString((*uint16)(unsafe.Pointer(blockp))) 43 | if len(entry) == 0 { 44 | break 45 | } 46 | env = append(env, entry) 47 | blockp += 2 * (uintptr(len(entry)) + 1) 48 | } 49 | return env, nil 50 | } 51 | 52 | func Unsetenv(key string) error { 53 | return syscall.Unsetenv(key) 54 | } 55 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/windows/mkknownfolderids.bash: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | # Copyright 2019 The Go Authors. All rights reserved. 4 | # Use of this source code is governed by a BSD-style 5 | # license that can be found in the LICENSE file. 6 | 7 | set -e 8 | shopt -s nullglob 9 | 10 | knownfolders="$(printf '%s\n' "/mnt/c/Program Files (x86)/Windows Kits/"/*/Include/*/um/KnownFolders.h | sort -Vr | head -n 1)" 11 | [[ -n $knownfolders ]] || { echo "Unable to find KnownFolders.h" >&2; exit 1; } 12 | 13 | { 14 | echo "// Code generated by 'mkknownfolderids.bash'; DO NOT EDIT." 15 | echo 16 | echo "package windows" 17 | echo "type KNOWNFOLDERID GUID" 18 | echo "var (" 19 | while read -r line; do 20 | [[ $line =~ DEFINE_KNOWN_FOLDER\((FOLDERID_[^,]+),[\t\ ]*(0x[^,]+),[\t\ ]*(0x[^,]+),[\t\ ]*(0x[^,]+),[\t\ ]*(0x[^,]+),[\t\ ]*(0x[^,]+),[\t\ ]*(0x[^,]+),[\t\ ]*(0x[^,]+),[\t\ ]*(0x[^,]+),[\t\ ]*(0x[^,]+),[\t\ ]*(0x[^,]+),[\t\ ]*(0x[^,]+)\) ]] || continue 21 | printf "%s = &KNOWNFOLDERID{0x%08x, 0x%04x, 0x%04x, [8]byte{0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x}}\n" \ 22 | "${BASH_REMATCH[1]}" $(( "${BASH_REMATCH[2]}" )) $(( "${BASH_REMATCH[3]}" )) $(( "${BASH_REMATCH[4]}" )) \ 23 | $(( "${BASH_REMATCH[5]}" )) $(( "${BASH_REMATCH[6]}" )) $(( "${BASH_REMATCH[7]}" )) $(( "${BASH_REMATCH[8]}" )) \ 24 | $(( "${BASH_REMATCH[9]}" )) $(( "${BASH_REMATCH[10]}" )) $(( "${BASH_REMATCH[11]}" )) $(( "${BASH_REMATCH[12]}" )) 25 | done < "$knownfolders" 26 | echo ")" 27 | } | gofmt > "zknownfolderids_windows.go" 28 | -------------------------------------------------------------------------------- /cat/cat.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bufio" 5 | "flag" 6 | "fmt" 7 | "io" 8 | "log" 9 | "os" 10 | 11 | "github.com/as/mute" 12 | ) 13 | 14 | const Prefix = "cat: " 15 | 16 | var args struct { 17 | h, q bool 18 | } 19 | var f *flag.FlagSet 20 | 21 | func init() { 22 | log.SetPrefix(Prefix) 23 | log.SetFlags(0) 24 | f = flag.NewFlagSet("main", flag.ContinueOnError) 25 | f.BoolVar(&args.h, "h", false, "") 26 | f.BoolVar(&args.q, "?", false, "") 27 | err := mute.Parse(f, os.Args[1:]) 28 | ck(err) 29 | if args.h || args.q { 30 | usage() 31 | os.Exit(0) 32 | } 33 | } 34 | 35 | func main() { 36 | 37 | if len(f.Args()) == 0 { 38 | cat("-") 39 | } else { 40 | for _, f := range f.Args() { 41 | cat(f) 42 | } 43 | } 44 | } 45 | 46 | func cat(f string) { 47 | var ( 48 | in io.ReadCloser = os.Stdin 49 | err error 50 | ) 51 | if f != "-" { 52 | in, err = os.OpenFile(f, os.O_RDONLY, 0666) 53 | if err != nil { 54 | ck(err) 55 | return 56 | } 57 | defer in.Close() 58 | } 59 | io.Copy(os.Stdout, bufio.NewReader(in)) 60 | } 61 | 62 | func ck(err error) { 63 | if err != nil { 64 | log.Fatalln(err) 65 | } 66 | } 67 | 68 | func usage() { 69 | fmt.Println(` 70 | NAME 71 | cat - catenate files 72 | 73 | SYNOPSIS 74 | cat [file...] 75 | 76 | DESCRIPTION 77 | Cat writes the contents of each named file to stdout 78 | 79 | EXAMPLE 80 | cat > file1 81 | cat file1 file2 > file3 82 | 83 | BUGS 84 | This leaves you with an empty file1: 85 | cat file1 file2 > file1 86 | `) 87 | } 88 | -------------------------------------------------------------------------------- /vendor/github.com/as/font/gofont.go: -------------------------------------------------------------------------------- 1 | package font 2 | 3 | import ( 4 | "unicode" 5 | 6 | "github.com/as/font/gomedium" 7 | "github.com/as/font/gomono" 8 | "github.com/as/font/goregular" 9 | "github.com/golang/freetype/truetype" 10 | ) 11 | 12 | func notGraphic(r rune) bool { return !unicode.IsGraphic(r) } 13 | 14 | // New returns a GoMedium font that is cached and replaces 15 | // non-printable characters with their hex equivalent encodings 16 | func NewFace(size int) Face { 17 | return NewCache(Replacer(NewGoMedium(size), NewHex(size), nil)) 18 | // return NewCache(Replacer(NewGoMedium(size), NewHex(size), nil)) 19 | // return NewCache(NewRune(NewGoMedium(size))) 20 | // var fn func(size int) Face 21 | // fn = func(size int) Face{ 22 | // return &Resizer{ 23 | // Face: NewCache(Replacer(NewGoMedium(size), NewHex(size), nil)), 24 | // New: fn, 25 | // } 26 | // } 27 | // return fn(size) 28 | } 29 | 30 | func NewGoMedium(size int) Face { 31 | return Open(truetype.NewFace(gomedium.Font, &truetype.Options{ 32 | SubPixelsX: 64, 33 | SubPixelsY: 64, 34 | Size: float64(size), 35 | })) 36 | } 37 | 38 | func NewGoMono(size int) Face { 39 | return Open(truetype.NewFace(gomono.Font, &truetype.Options{ 40 | SubPixelsX: 64, 41 | SubPixelsY: 64, 42 | Size: float64(size), 43 | })) 44 | } 45 | 46 | func NewGoRegular(size int) Face { 47 | return Open(truetype.NewFace(goregular.Font, &truetype.Options{ 48 | SubPixelsX: 64, 49 | SubPixelsY: 64, 50 | Size: float64(size), 51 | })) 52 | } 53 | -------------------------------------------------------------------------------- /vendor/golang.org/x/exp/shiny/driver/x11driver/shm_shmopen_syscall.go: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build (linux || dragonfly) && (amd64 || arm || arm64 || mips64 || mips64le) 6 | // +build linux dragonfly 7 | // +build amd64 arm arm64 mips64 mips64le 8 | 9 | package x11driver 10 | 11 | import ( 12 | "fmt" 13 | "syscall" 14 | "unsafe" 15 | ) 16 | 17 | // These constants are from /usr/include/linux/ipc.h 18 | const ( 19 | ipcPrivate = 0 20 | ipcRmID = 0 21 | ) 22 | 23 | func shmOpen(size int) (shmid uintptr, addr unsafe.Pointer, err error) { 24 | shmid, _, errno0 := syscall.RawSyscall(syscall.SYS_SHMGET, ipcPrivate, uintptr(size), 0600) 25 | if errno0 != 0 { 26 | return 0, unsafe.Pointer(uintptr(0)), fmt.Errorf("shmget: %v", errno0) 27 | } 28 | p, _, errno1 := syscall.RawSyscall(syscall.SYS_SHMAT, shmid, 0, 0) 29 | _, _, errno2 := syscall.RawSyscall(syscall.SYS_SHMCTL, shmid, ipcRmID, 0) 30 | if errno1 != 0 { 31 | return 0, unsafe.Pointer(uintptr(0)), fmt.Errorf("shmat: %v", errno1) 32 | } 33 | if errno2 != 0 { 34 | return 0, unsafe.Pointer(uintptr(0)), fmt.Errorf("shmctl: %v", errno2) 35 | } 36 | return shmid, unsafe.Pointer(p), nil 37 | } 38 | 39 | func shmClose(p unsafe.Pointer) error { 40 | _, _, errno := syscall.RawSyscall(syscall.SYS_SHMDT, uintptr(p), 0, 0) 41 | if errno != 0 { 42 | return fmt.Errorf("shmdt: %v", errno) 43 | } 44 | return nil 45 | } 46 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/hwcap_linux.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package cpu 6 | 7 | import ( 8 | "io/ioutil" 9 | ) 10 | 11 | const ( 12 | _AT_HWCAP = 16 13 | _AT_HWCAP2 = 26 14 | 15 | procAuxv = "/proc/self/auxv" 16 | 17 | uintSize = int(32 << (^uint(0) >> 63)) 18 | ) 19 | 20 | // For those platforms don't have a 'cpuid' equivalent we use HWCAP/HWCAP2 21 | // These are initialized in cpu_$GOARCH.go 22 | // and should not be changed after they are initialized. 23 | var hwCap uint 24 | var hwCap2 uint 25 | 26 | func readHWCAP() error { 27 | buf, err := ioutil.ReadFile(procAuxv) 28 | if err != nil { 29 | // e.g. on android /proc/self/auxv is not accessible, so silently 30 | // ignore the error and leave Initialized = false. On some 31 | // architectures (e.g. arm64) doinit() implements a fallback 32 | // readout and will set Initialized = true again. 33 | return err 34 | } 35 | bo := hostByteOrder() 36 | for len(buf) >= 2*(uintSize/8) { 37 | var tag, val uint 38 | switch uintSize { 39 | case 32: 40 | tag = uint(bo.Uint32(buf[0:])) 41 | val = uint(bo.Uint32(buf[4:])) 42 | buf = buf[8:] 43 | case 64: 44 | tag = uint(bo.Uint64(buf[0:])) 45 | val = uint(bo.Uint64(buf[8:])) 46 | buf = buf[16:] 47 | } 48 | switch tag { 49 | case _AT_HWCAP: 50 | hwCap = val 51 | case _AT_HWCAP2: 52 | hwCap2 = val 53 | } 54 | } 55 | return nil 56 | } 57 | -------------------------------------------------------------------------------- /vendor/github.com/BurntSushi/xgb/STYLE: -------------------------------------------------------------------------------- 1 | I like to keep all my code to 80 columns or less. I have plenty of screen real 2 | estate, but enjoy 80 columns so that I can have multiple code windows open side 3 | to side and not be plagued by the ugly auto-wrapping of a text editor. 4 | 5 | If you don't oblige me, I will fix any patch you submit to abide 80 columns. 6 | 7 | Note that this style restriction does not preclude gofmt, but introduces a few 8 | peculiarities. The first is that gofmt will occasionally add spacing (typically 9 | to comments) that ends up going over 80 columns. Either shorten the comment or 10 | put it on its own line. 11 | 12 | The second and more common hiccup is when a function definition extends beyond 13 | 80 columns. If one adds line breaks to keep it below 80 columns, gofmt will 14 | indent all subsequent lines in a function definition to the same indentation 15 | level of the function body. This results in a less-than-ideal separation 16 | between function definition and function body. To remedy this, simply add a 17 | line break like so: 18 | 19 | func RestackWindowExtra(xu *xgbutil.XUtil, win xproto.Window, stackMode int, 20 | sibling xproto.Window, source int) error { 21 | 22 | return ClientEvent(xu, win, "_NET_RESTACK_WINDOW", source, int(sibling), 23 | stackMode) 24 | } 25 | 26 | Something similar should also be applied to long 'if' or 'for' conditionals, 27 | although it would probably be preferrable to break up the conditional to 28 | smaller chunks with a few helper variables. 29 | 30 | -------------------------------------------------------------------------------- /vendor/github.com/as/worm/logger.go: -------------------------------------------------------------------------------- 1 | // Package worm provides Write-Once Read-Many (WORM) logging semantics for 2 | // sequential log read access and append only write access. It also provides 3 | // a coalescer to compact records in transit to the underlying log. 4 | // 5 | // A log is an record of data defined in github.com/as/event that implements 6 | // the event.Record interface 7 | // 8 | package worm 9 | 10 | import ( 11 | "fmt" 12 | "github.com/as/event" 13 | ) 14 | 15 | type Logger interface{ 16 | // Write appends the record to the log 17 | Write(event.Record) (err error) 18 | 19 | // ReadAt reads and returns log record n 20 | ReadAt(at int64) (event.Record, error) 21 | 22 | // Len returns the number of records 23 | Len() int64 24 | 25 | } 26 | 27 | // NewLogger returns a Write-Once Read-Many (WORM) logger capable of 28 | // serializing an ordered stream of event.Records. 29 | func NewLogger() Logger{ 30 | return &logWORM{} 31 | } 32 | 33 | type logWORM struct { 34 | rec []event.Record 35 | } 36 | 37 | // ReadAt reads and returns log record n 38 | func (l *logWORM) ReadAt(n int64) (event.Record, error){ 39 | if n < 0 || n >= int64(len(l.rec)){ 40 | return nil, fmt.Errorf("bad read offset: %d\n", n) 41 | } 42 | return l.rec[n], nil 43 | } 44 | 45 | // Write writes v to the tail of the log 46 | func (l *logWORM) Write(v event.Record) (err error){ 47 | l.rec = append(l.rec, v) 48 | return nil 49 | } 50 | 51 | // Len returns the number of records stored the log 52 | func (l *logWORM) Len() int64{ 53 | return int64(len(l.rec)) 54 | } 55 | -------------------------------------------------------------------------------- /vendor/github.com/go-gl/glfw/v3.3/glfw/window.c: -------------------------------------------------------------------------------- 1 | #include "_cgo_export.h" 2 | 3 | void glfwSetWindowPosCallbackCB(GLFWwindow *window) { 4 | glfwSetWindowPosCallback(window, (GLFWwindowposfun)goWindowPosCB); 5 | } 6 | 7 | void glfwSetWindowSizeCallbackCB(GLFWwindow *window) { 8 | glfwSetWindowSizeCallback(window, (GLFWwindowsizefun)goWindowSizeCB); 9 | } 10 | 11 | void glfwSetWindowCloseCallbackCB(GLFWwindow *window) { 12 | glfwSetWindowCloseCallback(window, (GLFWwindowclosefun)goWindowCloseCB); 13 | } 14 | 15 | void glfwSetWindowRefreshCallbackCB(GLFWwindow *window) { 16 | glfwSetWindowRefreshCallback(window, (GLFWwindowrefreshfun)goWindowRefreshCB); 17 | } 18 | 19 | void glfwSetWindowFocusCallbackCB(GLFWwindow *window) { 20 | glfwSetWindowFocusCallback(window, (GLFWwindowfocusfun)goWindowFocusCB); 21 | } 22 | 23 | void glfwSetWindowIconifyCallbackCB(GLFWwindow *window) { 24 | glfwSetWindowIconifyCallback(window, (GLFWwindowiconifyfun)goWindowIconifyCB); 25 | } 26 | 27 | void glfwSetFramebufferSizeCallbackCB(GLFWwindow *window) { 28 | glfwSetFramebufferSizeCallback(window, 29 | (GLFWframebuffersizefun)goFramebufferSizeCB); 30 | } 31 | 32 | void glfwSetWindowMaximizeCallbackCB(GLFWwindow *window) { 33 | glfwSetWindowMaximizeCallback(window, 34 | (GLFWwindowmaximizefun)goWindowMaximizeCB); 35 | } 36 | 37 | void glfwSetWindowContentScaleCallbackCB(GLFWwindow *window) { 38 | glfwSetWindowContentScaleCallback( 39 | window, (GLFWwindowcontentscalefun)goWindowContentScaleCB); 40 | } 41 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/cpu/cpu_linux_arm.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package cpu 6 | 7 | func doinit() { 8 | ARM.HasSWP = isSet(hwCap, hwcap_SWP) 9 | ARM.HasHALF = isSet(hwCap, hwcap_HALF) 10 | ARM.HasTHUMB = isSet(hwCap, hwcap_THUMB) 11 | ARM.Has26BIT = isSet(hwCap, hwcap_26BIT) 12 | ARM.HasFASTMUL = isSet(hwCap, hwcap_FAST_MULT) 13 | ARM.HasFPA = isSet(hwCap, hwcap_FPA) 14 | ARM.HasVFP = isSet(hwCap, hwcap_VFP) 15 | ARM.HasEDSP = isSet(hwCap, hwcap_EDSP) 16 | ARM.HasJAVA = isSet(hwCap, hwcap_JAVA) 17 | ARM.HasIWMMXT = isSet(hwCap, hwcap_IWMMXT) 18 | ARM.HasCRUNCH = isSet(hwCap, hwcap_CRUNCH) 19 | ARM.HasTHUMBEE = isSet(hwCap, hwcap_THUMBEE) 20 | ARM.HasNEON = isSet(hwCap, hwcap_NEON) 21 | ARM.HasVFPv3 = isSet(hwCap, hwcap_VFPv3) 22 | ARM.HasVFPv3D16 = isSet(hwCap, hwcap_VFPv3D16) 23 | ARM.HasTLS = isSet(hwCap, hwcap_TLS) 24 | ARM.HasVFPv4 = isSet(hwCap, hwcap_VFPv4) 25 | ARM.HasIDIVA = isSet(hwCap, hwcap_IDIVA) 26 | ARM.HasIDIVT = isSet(hwCap, hwcap_IDIVT) 27 | ARM.HasVFPD32 = isSet(hwCap, hwcap_VFPD32) 28 | ARM.HasLPAE = isSet(hwCap, hwcap_LPAE) 29 | ARM.HasEVTSTRM = isSet(hwCap, hwcap_EVTSTRM) 30 | ARM.HasAES = isSet(hwCap2, hwcap2_AES) 31 | ARM.HasPMULL = isSet(hwCap2, hwcap2_PMULL) 32 | ARM.HasSHA1 = isSet(hwCap2, hwcap2_SHA1) 33 | ARM.HasSHA2 = isSet(hwCap2, hwcap2_SHA2) 34 | ARM.HasCRC32 = isSet(hwCap2, hwcap2_CRC32) 35 | } 36 | 37 | func isSet(hwc uint, value uint) bool { 38 | return hwc&value != 0 39 | } 40 | -------------------------------------------------------------------------------- /vendor/rsc.io/pdf/LICENSE: -------------------------------------------------------------------------------- 1 | Copyright (c) 2009 The Go Authors. All rights reserved. 2 | 3 | Redistribution and use in source and binary forms, with or without 4 | modification, are permitted provided that the following conditions are 5 | met: 6 | 7 | * Redistributions of source code must retain the above copyright 8 | notice, this list of conditions and the following disclaimer. 9 | * Redistributions in binary form must reproduce the above 10 | copyright notice, this list of conditions and the following disclaimer 11 | in the documentation and/or other materials provided with the 12 | distribution. 13 | * Neither the name of Google Inc. nor the names of its 14 | contributors may be used to endorse or promote products derived from 15 | this software without specific prior written permission. 16 | 17 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 18 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 19 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 20 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 21 | OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 22 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 23 | LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 24 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 25 | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 26 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 27 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28 | -------------------------------------------------------------------------------- /vendor/golang.org/x/exp/LICENSE: -------------------------------------------------------------------------------- 1 | Copyright (c) 2009 The Go Authors. All rights reserved. 2 | 3 | Redistribution and use in source and binary forms, with or without 4 | modification, are permitted provided that the following conditions are 5 | met: 6 | 7 | * Redistributions of source code must retain the above copyright 8 | notice, this list of conditions and the following disclaimer. 9 | * Redistributions in binary form must reproduce the above 10 | copyright notice, this list of conditions and the following disclaimer 11 | in the documentation and/or other materials provided with the 12 | distribution. 13 | * Neither the name of Google Inc. nor the names of its 14 | contributors may be used to endorse or promote products derived from 15 | this software without specific prior written permission. 16 | 17 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 18 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 19 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 20 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 21 | OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 22 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 23 | LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 24 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 25 | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 26 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 27 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28 | -------------------------------------------------------------------------------- /vendor/golang.org/x/image/LICENSE: -------------------------------------------------------------------------------- 1 | Copyright (c) 2009 The Go Authors. All rights reserved. 2 | 3 | Redistribution and use in source and binary forms, with or without 4 | modification, are permitted provided that the following conditions are 5 | met: 6 | 7 | * Redistributions of source code must retain the above copyright 8 | notice, this list of conditions and the following disclaimer. 9 | * Redistributions in binary form must reproduce the above 10 | copyright notice, this list of conditions and the following disclaimer 11 | in the documentation and/or other materials provided with the 12 | distribution. 13 | * Neither the name of Google Inc. nor the names of its 14 | contributors may be used to endorse or promote products derived from 15 | this software without specific prior written permission. 16 | 17 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 18 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 19 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 20 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 21 | OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 22 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 23 | LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 24 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 25 | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 26 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 27 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28 | -------------------------------------------------------------------------------- /vendor/golang.org/x/net/LICENSE: -------------------------------------------------------------------------------- 1 | Copyright (c) 2009 The Go Authors. All rights reserved. 2 | 3 | Redistribution and use in source and binary forms, with or without 4 | modification, are permitted provided that the following conditions are 5 | met: 6 | 7 | * Redistributions of source code must retain the above copyright 8 | notice, this list of conditions and the following disclaimer. 9 | * Redistributions in binary form must reproduce the above 10 | copyright notice, this list of conditions and the following disclaimer 11 | in the documentation and/or other materials provided with the 12 | distribution. 13 | * Neither the name of Google Inc. nor the names of its 14 | contributors may be used to endorse or promote products derived from 15 | this software without specific prior written permission. 16 | 17 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 18 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 19 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 20 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 21 | OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 22 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 23 | LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 24 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 25 | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 26 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 27 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28 | -------------------------------------------------------------------------------- /vendor/golang.org/x/sys/LICENSE: -------------------------------------------------------------------------------- 1 | Copyright (c) 2009 The Go Authors. All rights reserved. 2 | 3 | Redistribution and use in source and binary forms, with or without 4 | modification, are permitted provided that the following conditions are 5 | met: 6 | 7 | * Redistributions of source code must retain the above copyright 8 | notice, this list of conditions and the following disclaimer. 9 | * Redistributions in binary form must reproduce the above 10 | copyright notice, this list of conditions and the following disclaimer 11 | in the documentation and/or other materials provided with the 12 | distribution. 13 | * Neither the name of Google Inc. nor the names of its 14 | contributors may be used to endorse or promote products derived from 15 | this software without specific prior written permission. 16 | 17 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 18 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 19 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 20 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 21 | OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 22 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 23 | LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 24 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 25 | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 26 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 27 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28 | -------------------------------------------------------------------------------- /vendor/golang.org/x/text/LICENSE: -------------------------------------------------------------------------------- 1 | Copyright (c) 2009 The Go Authors. All rights reserved. 2 | 3 | Redistribution and use in source and binary forms, with or without 4 | modification, are permitted provided that the following conditions are 5 | met: 6 | 7 | * Redistributions of source code must retain the above copyright 8 | notice, this list of conditions and the following disclaimer. 9 | * Redistributions in binary form must reproduce the above 10 | copyright notice, this list of conditions and the following disclaimer 11 | in the documentation and/or other materials provided with the 12 | distribution. 13 | * Neither the name of Google Inc. nor the names of its 14 | contributors may be used to endorse or promote products derived from 15 | this software without specific prior written permission. 16 | 17 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 18 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 19 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 20 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 21 | OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 22 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 23 | LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 24 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 25 | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 26 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 27 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/LICENSE: -------------------------------------------------------------------------------- 1 | Copyright (c) 2009 The Go Authors. All rights reserved. 2 | 3 | Redistribution and use in source and binary forms, with or without 4 | modification, are permitted provided that the following conditions are 5 | met: 6 | 7 | * Redistributions of source code must retain the above copyright 8 | notice, this list of conditions and the following disclaimer. 9 | * Redistributions in binary form must reproduce the above 10 | copyright notice, this list of conditions and the following disclaimer 11 | in the documentation and/or other materials provided with the 12 | distribution. 13 | * Neither the name of Google Inc. nor the names of its 14 | contributors may be used to endorse or promote products derived from 15 | this software without specific prior written permission. 16 | 17 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 18 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 19 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 20 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 21 | OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 22 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 23 | LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 24 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 25 | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 26 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 27 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/internal/subtle/aliasing_purego.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build purego 6 | // +build purego 7 | 8 | // Package subtle implements functions that are often useful in cryptographic 9 | // code but require careful thought to use correctly. 10 | package subtle // import "golang.org/x/crypto/internal/subtle" 11 | 12 | // This is the Google App Engine standard variant based on reflect 13 | // because the unsafe package and cgo are disallowed. 14 | 15 | import "reflect" 16 | 17 | // AnyOverlap reports whether x and y share memory at any (not necessarily 18 | // corresponding) index. The memory beyond the slice length is ignored. 19 | func AnyOverlap(x, y []byte) bool { 20 | return len(x) > 0 && len(y) > 0 && 21 | reflect.ValueOf(&x[0]).Pointer() <= reflect.ValueOf(&y[len(y)-1]).Pointer() && 22 | reflect.ValueOf(&y[0]).Pointer() <= reflect.ValueOf(&x[len(x)-1]).Pointer() 23 | } 24 | 25 | // InexactOverlap reports whether x and y share memory at any non-corresponding 26 | // index. The memory beyond the slice length is ignored. Note that x and y can 27 | // have different lengths and still not have any inexact overlap. 28 | // 29 | // InexactOverlap can be used to implement the requirements of the crypto/cipher 30 | // AEAD, Block, BlockMode and Stream interfaces. 31 | func InexactOverlap(x, y []byte) bool { 32 | if len(x) == 0 || len(y) == 0 || &x[0] == &y[0] { 33 | return false 34 | } 35 | return AnyOverlap(x, y) 36 | } 37 | -------------------------------------------------------------------------------- /vendor/golang.org/x/mobile/LICENSE: -------------------------------------------------------------------------------- 1 | Copyright (c) 2009 The Go Authors. All rights reserved. 2 | 3 | Redistribution and use in source and binary forms, with or without 4 | modification, are permitted provided that the following conditions are 5 | met: 6 | 7 | * Redistributions of source code must retain the above copyright 8 | notice, this list of conditions and the following disclaimer. 9 | * Redistributions in binary form must reproduce the above 10 | copyright notice, this list of conditions and the following disclaimer 11 | in the documentation and/or other materials provided with the 12 | distribution. 13 | * Neither the name of Google Inc. nor the names of its 14 | contributors may be used to endorse or promote products derived from 15 | this software without specific prior written permission. 16 | 17 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 18 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 19 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 20 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 21 | OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 22 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 23 | LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 24 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 25 | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 26 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 27 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28 | -------------------------------------------------------------------------------- /vendor/dmitri.shuralyov.com/gpu/mtl/LICENSE: -------------------------------------------------------------------------------- 1 | Copyright (c) 2018 The Go Authors. All rights reserved. 2 | 3 | Redistribution and use in source and binary forms, with or without 4 | modification, are permitted provided that the following conditions are 5 | met: 6 | 7 | * Redistributions of source code must retain the above copyright 8 | notice, this list of conditions and the following disclaimer. 9 | * Redistributions in binary form must reproduce the above 10 | copyright notice, this list of conditions and the following disclaimer 11 | in the documentation and/or other materials provided with the 12 | distribution. 13 | * Neither the name of Google Inc. nor the names of its 14 | contributors may be used to endorse or promote products derived from 15 | this software without specific prior written permission. 16 | 17 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 18 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 19 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 20 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 21 | OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 22 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 23 | LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 24 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 25 | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 26 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 27 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28 | -------------------------------------------------------------------------------- /vendor/github.com/go-gl/glfw/v3.3/glfw/LICENSE: -------------------------------------------------------------------------------- 1 | Copyright (c) 2012 The glfw3-go Authors. All rights reserved. 2 | 3 | Redistribution and use in source and binary forms, with or without 4 | modification, are permitted provided that the following conditions are 5 | met: 6 | 7 | * Redistributions of source code must retain the above copyright 8 | notice, this list of conditions and the following disclaimer. 9 | * Redistributions in binary form must reproduce the above 10 | copyright notice, this list of conditions and the following disclaimer 11 | in the documentation and/or other materials provided with the 12 | distribution. 13 | * Neither the name of Google Inc. nor the names of its 14 | contributors may be used to endorse or promote products derived from 15 | this software without specific prior written permission. 16 | 17 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 18 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 19 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 20 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 21 | OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 22 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 23 | LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 24 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 25 | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 26 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 27 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28 | -------------------------------------------------------------------------------- /vendor/golang.org/x/exp/shiny/driver/x11driver/shm_linux_ipc.go: -------------------------------------------------------------------------------- 1 | // Copyright 2016 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //go:build linux && (386 || ppc64 || ppc64le || s390x) 6 | // +build linux 7 | // +build 386 ppc64 ppc64le s390x 8 | 9 | package x11driver 10 | 11 | import ( 12 | "fmt" 13 | "syscall" 14 | "unsafe" 15 | ) 16 | 17 | // These constants are from /usr/include/linux/ipc.h 18 | const ( 19 | ipcPrivate = 0 20 | ipcRmID = 0 21 | 22 | shmAt = 21 23 | shmDt = 22 24 | shmGet = 23 25 | shmCtl = 24 26 | ) 27 | 28 | func shmOpen(size int) (shmid uintptr, addr unsafe.Pointer, err error) { 29 | shmid, _, errno0 := syscall.RawSyscall6(syscall.SYS_IPC, shmGet, ipcPrivate, uintptr(size), 0600, 0, 0) 30 | if errno0 != 0 { 31 | return 0, unsafe.Pointer(uintptr(0)), fmt.Errorf("shmget: %v", errno0) 32 | } 33 | _, _, errno1 := syscall.RawSyscall6(syscall.SYS_IPC, shmAt, shmid, 0, uintptr(unsafe.Pointer(&addr)), 0, 0) 34 | _, _, errno2 := syscall.RawSyscall6(syscall.SYS_IPC, shmCtl, shmid, ipcRmID, 0, 0, 0) 35 | if errno1 != 0 { 36 | return 0, unsafe.Pointer(uintptr(0)), fmt.Errorf("shmat: %v", errno1) 37 | } 38 | if errno2 != 0 { 39 | return 0, unsafe.Pointer(uintptr(0)), fmt.Errorf("shmctl: %v", errno2) 40 | } 41 | return shmid, addr, nil 42 | } 43 | 44 | func shmClose(p unsafe.Pointer) error { 45 | _, _, errno := syscall.RawSyscall6(syscall.SYS_IPC, shmDt, 0, 0, 0, uintptr(p), 0) 46 | if errno != 0 { 47 | return fmt.Errorf("shmdt: %v", errno) 48 | } 49 | return nil 50 | } 51 | -------------------------------------------------------------------------------- /vendor/github.com/as/edit/LICENSE: -------------------------------------------------------------------------------- 1 | BSD 3-Clause License 2 | 3 | Copyright as (c) 2017, 4 | All rights reserved. 5 | 6 | Redistribution and use in source and binary forms, with or without 7 | modification, are permitted provided that the following conditions are met: 8 | 9 | * Redistributions of source code must retain the above copyright notice, this 10 | list of conditions and the following disclaimer. 11 | 12 | * Redistributions in binary form must reproduce the above copyright notice, 13 | this list of conditions and the following disclaimer in the documentation 14 | and/or other materials provided with the distribution. 15 | 16 | * Neither the name of the copyright holder nor the names of its 17 | contributors may be used to endorse or promote products derived from 18 | this software without specific prior written permission. 19 | 20 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 21 | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 22 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 23 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE 24 | FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 25 | DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 26 | SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 27 | CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 28 | OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 29 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -------------------------------------------------------------------------------- /vendor/github.com/as/etch/LICENSE: -------------------------------------------------------------------------------- 1 | BSD 3-Clause License 2 | 3 | Copyright as (c) 2017, 4 | All rights reserved. 5 | 6 | Redistribution and use in source and binary forms, with or without 7 | modification, are permitted provided that the following conditions are met: 8 | 9 | * Redistributions of source code must retain the above copyright notice, this 10 | list of conditions and the following disclaimer. 11 | 12 | * Redistributions in binary form must reproduce the above copyright notice, 13 | this list of conditions and the following disclaimer in the documentation 14 | and/or other materials provided with the distribution. 15 | 16 | * Neither the name of the copyright holder nor the names of its 17 | contributors may be used to endorse or promote products derived from 18 | this software without specific prior written permission. 19 | 20 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 21 | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 22 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 23 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE 24 | FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 25 | DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 26 | SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 27 | CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 28 | OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 29 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -------------------------------------------------------------------------------- /vendor/github.com/as/frame/LICENSE: -------------------------------------------------------------------------------- 1 | BSD 3-Clause License 2 | 3 | Copyright as (c) 2017, 4 | All rights reserved. 5 | 6 | Redistribution and use in source and binary forms, with or without 7 | modification, are permitted provided that the following conditions are met: 8 | 9 | * Redistributions of source code must retain the above copyright notice, this 10 | list of conditions and the following disclaimer. 11 | 12 | * Redistributions in binary form must reproduce the above copyright notice, 13 | this list of conditions and the following disclaimer in the documentation 14 | and/or other materials provided with the distribution. 15 | 16 | * Neither the name of the copyright holder nor the names of its 17 | contributors may be used to endorse or promote products derived from 18 | this software without specific prior written permission. 19 | 20 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 21 | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 22 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 23 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE 24 | FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 25 | DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 26 | SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 27 | CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 28 | OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 29 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE -------------------------------------------------------------------------------- /vendor/github.com/as/event/write.go: -------------------------------------------------------------------------------- 1 | package event 2 | 3 | type Write struct { 4 | Rec 5 | 6 | // A LHS Delete event ready to become another writer. 7 | Residue Record 8 | } 9 | 10 | func (r Write) Record() (p []byte, err error) { 11 | r.Kind = 'w' 12 | return r.Rec.Record() 13 | } 14 | 15 | func (e *Write) Coalesce(v Record) Record { 16 | if e.Residue != nil { 17 | return e.handleResidue(v) 18 | } 19 | switch v := v.(type) { 20 | case *Insert: 21 | //e.Residue =v 22 | return nil 23 | case *Delete: 24 | // If we reach here it means that the 25 | // input was W(D+I)+D. The next event 26 | // determines whether a write occurs 27 | if e.Q1 == v.Q0 { 28 | //e.Q1 = v.Q1 29 | //e.P = append(e.P, v.P...) 30 | e.Residue = v 31 | return e 32 | } 33 | e.Residue = nil 34 | return nil 35 | case *Write: 36 | if e.Q1 == v.Q0 { 37 | e.Q1 = v.Q1 38 | e.P = append(e.P, v.P...) 39 | //e.Residue = nil 40 | return e 41 | } 42 | panic("!") 43 | case interface{}: 44 | panic("bad interface") 45 | } 46 | return nil 47 | } 48 | 49 | func (e *Write) handleResidue(v Record) Record { 50 | if e.Residue == nil { 51 | panic("handleResidue: internal runtime error: no residue") 52 | } 53 | switch v := v.(type) { 54 | case *Insert: 55 | if e.Q1 == v.Q0 { 56 | e.Q1 = v.Q1 57 | e.P = append(e.P, v.P...) 58 | e.Residue = nil 59 | return e 60 | } 61 | return nil 62 | case *Delete: 63 | x := e.Residue.Coalesce(v) 64 | if x == nil { 65 | return nil 66 | } 67 | e.Residue = x 68 | return e 69 | case interface{}: 70 | panic("bad interface") 71 | } 72 | return nil 73 | } 74 | -------------------------------------------------------------------------------- /vendor/github.com/go-gl/glfw/v3.3/glfw/input.c: -------------------------------------------------------------------------------- 1 | #include "_cgo_export.h" 2 | 3 | void glfwSetJoystickCallbackCB() { 4 | glfwSetJoystickCallback((GLFWjoystickfun)goJoystickCB); 5 | } 6 | 7 | void glfwSetKeyCallbackCB(GLFWwindow *window) { 8 | glfwSetKeyCallback(window, (GLFWkeyfun)goKeyCB); 9 | } 10 | 11 | void glfwSetCharCallbackCB(GLFWwindow *window) { 12 | glfwSetCharCallback(window, (GLFWcharfun)goCharCB); 13 | } 14 | 15 | void glfwSetCharModsCallbackCB(GLFWwindow *window) { 16 | glfwSetCharModsCallback(window, (GLFWcharmodsfun)goCharModsCB); 17 | } 18 | 19 | void glfwSetMouseButtonCallbackCB(GLFWwindow *window) { 20 | glfwSetMouseButtonCallback(window, (GLFWmousebuttonfun)goMouseButtonCB); 21 | } 22 | 23 | void glfwSetCursorPosCallbackCB(GLFWwindow *window) { 24 | glfwSetCursorPosCallback(window, (GLFWcursorposfun)goCursorPosCB); 25 | } 26 | 27 | void glfwSetCursorEnterCallbackCB(GLFWwindow *window) { 28 | glfwSetCursorEnterCallback(window, (GLFWcursorenterfun)goCursorEnterCB); 29 | } 30 | 31 | void glfwSetScrollCallbackCB(GLFWwindow *window) { 32 | glfwSetScrollCallback(window, (GLFWscrollfun)goScrollCB); 33 | } 34 | 35 | void glfwSetDropCallbackCB(GLFWwindow *window) { 36 | glfwSetDropCallback(window, (GLFWdropfun)goDropCB); 37 | } 38 | 39 | float GetAxisAtIndex(float *axis, int i) { return axis[i]; } 40 | 41 | unsigned char GetButtonsAtIndex(unsigned char *buttons, int i) { 42 | return buttons[i]; 43 | } 44 | 45 | unsigned char GetGamepadButtonAtIndex(GLFWgamepadstate *gp, int i) { 46 | return gp->buttons[i]; 47 | } 48 | 49 | float GetGamepadAxisAtIndex(GLFWgamepadstate *gp, int i) { return gp->axes[i]; } 50 | -------------------------------------------------------------------------------- /vendor/github.com/as/worm/README.md: -------------------------------------------------------------------------------- 1 | # WORM 2 | 3 | Package worm provides Write-Once Read-Many (WORM) log storage semantics for 4 | ordered read access and append only write access to log records. It also 5 | provides a coalescer for compacting them. 6 | 7 | A `log` is an record of data defined in `github.com/as/event` that 8 | implements the `event.Record` interface 9 | 10 | # TYPES 11 | 12 | ``` 13 | type Coalescer struct { 14 | Logger 15 | // contains filtered or unexported fields 16 | } 17 | Coalescer coalesces logs written to it until the deadband expires. After 18 | expiration, the coalesced log is flushed to the underlying logger upon 19 | the next call to Write(). 20 | 21 | func NewCoalescer(lg Logger, deadband time.Duration) *Coalescer 22 | NewCoalescer wraps the given logger and returns a coalescer 23 | 24 | func (l *Coalescer) Flush() error 25 | Flush flushes the last unwritten log to the underlying logger 26 | 27 | func (l *Coalescer) ReadAt(n int64) (event.Record, error) 28 | ReadAt reads and returns log record n 29 | 30 | func (l *Coalescer) Write(v event.Record) (err error) 31 | Write writes v to the tail of the log 32 | 33 | type Logger interface { 34 | // Write appends the record to the log 35 | Write(event.Record) (err error) 36 | 37 | // ReadAt reads and returns log record n 38 | ReadAt(at int64) (event.Record, error) 39 | 40 | // Len returns the number of records 41 | Len() int64 42 | } 43 | 44 | func NewLogger() Logger 45 | NewLogger returns a Write-Once Read-Many (WORM) logger capable of 46 | serializing an ordered stream of event.Records. 47 | ``` 48 | -------------------------------------------------------------------------------- /vendor/golang.org/x/crypto/ssh/mac.go: -------------------------------------------------------------------------------- 1 | // Copyright 2012 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package ssh 6 | 7 | // Message authentication support 8 | 9 | import ( 10 | "crypto/hmac" 11 | "crypto/sha1" 12 | "crypto/sha256" 13 | "hash" 14 | ) 15 | 16 | type macMode struct { 17 | keySize int 18 | etm bool 19 | new func(key []byte) hash.Hash 20 | } 21 | 22 | // truncatingMAC wraps around a hash.Hash and truncates the output digest to 23 | // a given size. 24 | type truncatingMAC struct { 25 | length int 26 | hmac hash.Hash 27 | } 28 | 29 | func (t truncatingMAC) Write(data []byte) (int, error) { 30 | return t.hmac.Write(data) 31 | } 32 | 33 | func (t truncatingMAC) Sum(in []byte) []byte { 34 | out := t.hmac.Sum(in) 35 | return out[:len(in)+t.length] 36 | } 37 | 38 | func (t truncatingMAC) Reset() { 39 | t.hmac.Reset() 40 | } 41 | 42 | func (t truncatingMAC) Size() int { 43 | return t.length 44 | } 45 | 46 | func (t truncatingMAC) BlockSize() int { return t.hmac.BlockSize() } 47 | 48 | var macModes = map[string]*macMode{ 49 | "hmac-sha2-256-etm@openssh.com": {32, true, func(key []byte) hash.Hash { 50 | return hmac.New(sha256.New, key) 51 | }}, 52 | "hmac-sha2-256": {32, false, func(key []byte) hash.Hash { 53 | return hmac.New(sha256.New, key) 54 | }}, 55 | "hmac-sha1": {20, false, func(key []byte) hash.Hash { 56 | return hmac.New(sha1.New, key) 57 | }}, 58 | "hmac-sha1-96": {20, false, func(key []byte) hash.Hash { 59 | return truncatingMAC{12, hmac.New(sha1.New, key)} 60 | }}, 61 | } 62 | -------------------------------------------------------------------------------- /vendor/github.com/as/text/cor.go: -------------------------------------------------------------------------------- 1 | package text 2 | 3 | // Copy-on Reader 4 | // This bad name will be changed 5 | 6 | import ( 7 | "time" 8 | 9 | "github.com/as/worm" 10 | ) 11 | 12 | // COR processes a stream of event records and writes them to a coalescing logger. 13 | // The event stream is saved to the provided logger for later use. 14 | type COR struct { 15 | ed Editor 16 | rec *Recorder // Transcodes function calls to event Records 17 | co *worm.Coalescer // Batches those records 18 | hist worm.Logger // Stores those records 19 | noi int 20 | nod int 21 | q0, q1 int64 22 | } 23 | 24 | func NewCOR(ed Editor, hist worm.Logger) *COR { 25 | c := &COR{ 26 | ed: ed, 27 | hist: hist, 28 | co: worm.NewCoalescer(hist, time.Second*3), 29 | } 30 | c.rec = NewRecorder(c.co) 31 | return c 32 | } 33 | 34 | func (c *COR) Stats() (int64, int64) { 35 | return int64(c.noi), int64(c.nod) 36 | } 37 | func (c *COR) Len() int64 { 38 | return c.ed.Len() 39 | } 40 | func (c *COR) Bytes() []byte { 41 | return c.ed.Bytes() 42 | } 43 | func (c *COR) Select(q0, q1 int64) { 44 | c.q0 = q0 45 | c.q1 = q1 46 | } 47 | func (c *COR) Dot() (q0, q1 int64) { 48 | q0 = clamp(c.q0, 0, c.ed.Len()) 49 | q1 = clamp(c.q1, 0, c.ed.Len()) 50 | return 51 | } 52 | func (c *COR) Insert(p []byte, q0 int64) int { 53 | n := c.rec.Insert(p, q0) 54 | c.noi += n 55 | return n 56 | } 57 | func (c *COR) Delete(q0, q1 int64) int { 58 | n := c.rec.Delete(q0, q1) 59 | c.nod += n 60 | return n 61 | } 62 | func (c *COR) Close() (err error) { 63 | c.ed = nil 64 | return err 65 | } 66 | func (c *COR) Flush() (err error) { 67 | return c.co.Flush() 68 | } 69 | -------------------------------------------------------------------------------- /vendor/golang.org/x/exp/shiny/driver/internal/swizzle/swizzle_amd64.s: -------------------------------------------------------------------------------- 1 | // Copyright 2015 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | #include "textflag.h" 6 | 7 | // func haveSSSE3() bool 8 | TEXT ·haveSSSE3(SB),NOSPLIT,$0 9 | MOVQ $1, AX 10 | CPUID 11 | SHRQ $9, CX 12 | ANDQ $1, CX 13 | MOVB CX, ret+0(FP) 14 | RET 15 | 16 | // func bgra16(p []byte) 17 | TEXT ·bgra16(SB),NOSPLIT,$0-24 18 | MOVQ p+0(FP), SI 19 | MOVQ len+8(FP), DI 20 | 21 | // Sanity check that len is a multiple of 16. 22 | MOVQ DI, AX 23 | ANDQ $15, AX 24 | JNZ done 25 | 26 | // Make the shuffle control mask (16-byte register X0) look like this, 27 | // where the low order byte comes first: 28 | // 29 | // 02 01 00 03 06 05 04 07 0a 09 08 0b 0e 0d 0c 0f 30 | // 31 | // Load the bottom 8 bytes into X0, the top into X1, then interleave them 32 | // into X0. 33 | MOVQ $0x0704050603000102, AX 34 | MOVQ AX, X0 35 | MOVQ $0x0f0c0d0e0b08090a, AX 36 | MOVQ AX, X1 37 | PUNPCKLQDQ X1, X0 38 | 39 | ADDQ SI, DI 40 | loop: 41 | CMPQ SI, DI 42 | JEQ done 43 | 44 | MOVOU (SI), X1 45 | PSHUFB X0, X1 46 | MOVOU X1, (SI) 47 | 48 | ADDQ $16, SI 49 | JMP loop 50 | done: 51 | RET 52 | 53 | // func bgra4(p []byte) 54 | TEXT ·bgra4(SB),NOSPLIT,$0-24 55 | MOVQ p+0(FP), SI 56 | MOVQ len+8(FP), DI 57 | 58 | // Sanity check that len is a multiple of 4. 59 | MOVQ DI, AX 60 | ANDQ $3, AX 61 | JNZ done 62 | 63 | ADDQ SI, DI 64 | loop: 65 | CMPQ SI, DI 66 | JEQ done 67 | 68 | MOVB 0(SI), AX 69 | MOVB 2(SI), BX 70 | MOVB BX, 0(SI) 71 | MOVB AX, 2(SI) 72 | 73 | ADDQ $4, SI 74 | JMP loop 75 | done: 76 | RET 77 | -------------------------------------------------------------------------------- /vendor/github.com/golang/freetype/CONTRIBUTORS: -------------------------------------------------------------------------------- 1 | # This is the official list of people who can contribute 2 | # (and typically have contributed) code to the Freetype-Go repository. 3 | # The AUTHORS file lists the copyright holders; this file 4 | # lists people. For example, Google employees are listed here 5 | # but not in AUTHORS, because Google holds the copyright. 6 | # 7 | # The submission process automatically checks to make sure 8 | # that people submitting code are listed in this file (by email address). 9 | # 10 | # Names should be added to this file only after verifying that 11 | # the individual or the individual's organization has agreed to 12 | # the appropriate Contributor License Agreement, found here: 13 | # 14 | # http://code.google.com/legal/individual-cla-v1.0.html 15 | # http://code.google.com/legal/corporate-cla-v1.0.html 16 | # 17 | # The agreement for individuals can be filled out on the web. 18 | # 19 | # When adding J Random Contributor's name to this file, 20 | # either J's name or J's organization's name should be 21 | # added to the AUTHORS file, depending on whether the 22 | # individual or corporate CLA was used. 23 | 24 | # Names should be added to this file like so: 25 | # Name 26 | 27 | # Please keep the list sorted. 28 | 29 | Andrew Gerrand 30 | Jeff R. Allen 31 | Maksim Kochkin 32 | Michael Fogleman 33 | Nigel Tao 34 | Rémy Oudompheng 35 | Rob Pike 36 | Roger Peppe 37 | Russ Cox 38 | Steven Edwards 39 | -------------------------------------------------------------------------------- /vendor/github.com/BurntSushi/xgb/CONTRIBUTORS: -------------------------------------------------------------------------------- 1 | Andrew Gallant is the maintainer of this fork. What follows is the original 2 | list of contributors for the x-go-binding. 3 | 4 | # This is the official list of people who can contribute 5 | # (and typically have contributed) code to the XGB repository. 6 | # The AUTHORS file lists the copyright holders; this file 7 | # lists people. For example, Google employees are listed here 8 | # but not in AUTHORS, because Google holds the copyright. 9 | # 10 | # The submission process automatically checks to make sure 11 | # that people submitting code are listed in this file (by email address). 12 | # 13 | # Names should be added to this file only after verifying that 14 | # the individual or the individual's organization has agreed to 15 | # the appropriate Contributor License Agreement, found here: 16 | # 17 | # http://code.google.com/legal/individual-cla-v1.0.html 18 | # http://code.google.com/legal/corporate-cla-v1.0.html 19 | # 20 | # The agreement for individuals can be filled out on the web. 21 | # 22 | # When adding J Random Contributor's name to this file, 23 | # either J's name or J's organization's name should be 24 | # added to the AUTHORS file, depending on whether the 25 | # individual or corporate CLA was used. 26 | 27 | # Names should be added to this file like so: 28 | # Name 29 | 30 | # Please keep the list sorted. 31 | 32 | Anthony Martin 33 | Firmansyah Adiputra 34 | Ian Lance Taylor 35 | Nigel Tao 36 | Robert Griesemer 37 | Russ Cox 38 | Scott Lawrence 39 | Tor Andersson 40 | --------------------------------------------------------------------------------