X-Git-Url: https://git.josue.xyz/?a=blobdiff_plain;f=.config%2Fcoc%2Fextensions%2Fcoc-go-data%2Ftools%2Fpkg%2Fmod%2Fgolang.org%2Fx%2Ftools%40v0.0.0-20201105173854-bc9fc8d8c4bc%2Fgo%2Fssa%2Finterp%2Fexternal.go;fp=.config%2Fcoc%2Fextensions%2Fcoc-go-data%2Ftools%2Fpkg%2Fmod%2Fgolang.org%2Fx%2Ftools%40v0.0.0-20201105173854-bc9fc8d8c4bc%2Fgo%2Fssa%2Finterp%2Fexternal.go;h=735a14d9ce7776dda3ade8299faffad6d94ed429;hb=4d07c77cf4d78cab8639e13ddc3c22495e585b0b;hp=0000000000000000000000000000000000000000;hpb=b3950616b54221c40a7dab9099bda675007e5b6e;p=dotfiles%2F.git diff --git a/.config/coc/extensions/coc-go-data/tools/pkg/mod/golang.org/x/tools@v0.0.0-20201105173854-bc9fc8d8c4bc/go/ssa/interp/external.go b/.config/coc/extensions/coc-go-data/tools/pkg/mod/golang.org/x/tools@v0.0.0-20201105173854-bc9fc8d8c4bc/go/ssa/interp/external.go new file mode 100644 index 00000000..735a14d9 --- /dev/null +++ b/.config/coc/extensions/coc-go-data/tools/pkg/mod/golang.org/x/tools@v0.0.0-20201105173854-bc9fc8d8c4bc/go/ssa/interp/external.go @@ -0,0 +1,290 @@ +// Copyright 2013 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package interp + +// Emulated functions that we cannot interpret because they are +// external or because they use "unsafe" or "reflect" operations. + +import ( + "bytes" + "math" + "os" + "runtime" + "strings" + "time" + "unicode/utf8" +) + +type externalFn func(fr *frame, args []value) value + +// TODO(adonovan): fix: reflect.Value abstracts an lvalue or an +// rvalue; Set() causes mutations that can be observed via aliases. +// We have not captured that correctly here. + +// Key strings are from Function.String(). +var externals = make(map[string]externalFn) + +func init() { + // That little dot Û° is an Arabic zero numeral (U+06F0), categories [Nd]. + for k, v := range map[string]externalFn{ + "(reflect.Value).Bool": extÛ°reflectÛ°ValueÛ°Bool, + "(reflect.Value).CanAddr": extÛ°reflectÛ°ValueÛ°CanAddr, + "(reflect.Value).CanInterface": extÛ°reflectÛ°ValueÛ°CanInterface, + "(reflect.Value).Elem": extÛ°reflectÛ°ValueÛ°Elem, + "(reflect.Value).Field": extÛ°reflectÛ°ValueÛ°Field, + "(reflect.Value).Float": extÛ°reflectÛ°ValueÛ°Float, + "(reflect.Value).Index": extÛ°reflectÛ°ValueÛ°Index, + "(reflect.Value).Int": extÛ°reflectÛ°ValueÛ°Int, + "(reflect.Value).Interface": extÛ°reflectÛ°ValueÛ°Interface, + "(reflect.Value).IsNil": extÛ°reflectÛ°ValueÛ°IsNil, + "(reflect.Value).IsValid": extÛ°reflectÛ°ValueÛ°IsValid, + "(reflect.Value).Kind": extÛ°reflectÛ°ValueÛ°Kind, + "(reflect.Value).Len": extÛ°reflectÛ°ValueÛ°Len, + "(reflect.Value).MapIndex": extÛ°reflectÛ°ValueÛ°MapIndex, + "(reflect.Value).MapKeys": extÛ°reflectÛ°ValueÛ°MapKeys, + "(reflect.Value).NumField": extÛ°reflectÛ°ValueÛ°NumField, + "(reflect.Value).NumMethod": extÛ°reflectÛ°ValueÛ°NumMethod, + "(reflect.Value).Pointer": extÛ°reflectÛ°ValueÛ°Pointer, + "(reflect.Value).Set": extÛ°reflectÛ°ValueÛ°Set, + "(reflect.Value).String": extÛ°reflectÛ°ValueÛ°String, + "(reflect.Value).Type": extÛ°reflectÛ°ValueÛ°Type, + "(reflect.Value).Uint": extÛ°reflectÛ°ValueÛ°Uint, + "(reflect.error).Error": extÛ°reflectÛ°errorÛ°Error, + "(reflect.rtype).Bits": extÛ°reflectÛ°rtypeÛ°Bits, + "(reflect.rtype).Elem": extÛ°reflectÛ°rtypeÛ°Elem, + "(reflect.rtype).Field": extÛ°reflectÛ°rtypeÛ°Field, + "(reflect.rtype).In": extÛ°reflectÛ°rtypeÛ°In, + "(reflect.rtype).Kind": extÛ°reflectÛ°rtypeÛ°Kind, + "(reflect.rtype).NumField": extÛ°reflectÛ°rtypeÛ°NumField, + "(reflect.rtype).NumIn": extÛ°reflectÛ°rtypeÛ°NumIn, + "(reflect.rtype).NumMethod": extÛ°reflectÛ°rtypeÛ°NumMethod, + "(reflect.rtype).NumOut": extÛ°reflectÛ°rtypeÛ°NumOut, + "(reflect.rtype).Out": extÛ°reflectÛ°rtypeÛ°Out, + "(reflect.rtype).Size": extÛ°reflectÛ°rtypeÛ°Size, + "(reflect.rtype).String": extÛ°reflectÛ°rtypeÛ°String, + "bytes.Equal": extÛ°bytesÛ°Equal, + "bytes.IndexByte": extÛ°bytesÛ°IndexByte, + "fmt.Sprint": extÛ°fmtÛ°Sprint, + "math.Abs": extÛ°mathÛ°Abs, + "math.Exp": extÛ°mathÛ°Exp, + "math.Float32bits": extÛ°mathÛ°Float32bits, + "math.Float32frombits": extÛ°mathÛ°Float32frombits, + "math.Float64bits": extÛ°mathÛ°Float64bits, + "math.Float64frombits": extÛ°mathÛ°Float64frombits, + "math.Inf": extÛ°mathÛ°Inf, + "math.IsNaN": extÛ°mathÛ°IsNaN, + "math.Ldexp": extÛ°mathÛ°Ldexp, + "math.Log": extÛ°mathÛ°Log, + "math.Min": extÛ°mathÛ°Min, + "math.NaN": extÛ°mathÛ°NaN, + "os.Exit": extÛ°osÛ°Exit, + "os.Getenv": extÛ°osÛ°Getenv, + "reflect.New": extÛ°reflectÛ°New, + "reflect.SliceOf": extÛ°reflectÛ°SliceOf, + "reflect.TypeOf": extÛ°reflectÛ°TypeOf, + "reflect.ValueOf": extÛ°reflectÛ°ValueOf, + "reflect.Zero": extÛ°reflectÛ°Zero, + "runtime.Breakpoint": extÛ°runtimeÛ°Breakpoint, + "runtime.GC": extÛ°runtimeÛ°GC, + "runtime.GOMAXPROCS": extÛ°runtimeÛ°GOMAXPROCS, + "runtime.GOROOT": extÛ°runtimeÛ°GOROOT, + "runtime.Goexit": extÛ°runtimeÛ°Goexit, + "runtime.Gosched": extÛ°runtimeÛ°Gosched, + "runtime.NumCPU": extÛ°runtimeÛ°NumCPU, + "strings.Count": extÛ°stringsÛ°Count, + "strings.Index": extÛ°stringsÛ°Index, + "strings.IndexByte": extÛ°stringsÛ°IndexByte, + "strings.Replace": extÛ°stringsÛ°Replace, + "time.Sleep": extÛ°timeÛ°Sleep, + "unicode/utf8.DecodeRuneInString": extÛ°unicodeÛ°utf8Û°DecodeRuneInString, + } { + externals[k] = v + } +} + +func extÛ°bytesÛ°Equal(fr *frame, args []value) value { + // func Equal(a, b []byte) bool + a := args[0].([]value) + b := args[1].([]value) + if len(a) != len(b) { + return false + } + for i := range a { + if a[i] != b[i] { + return false + } + } + return true +} + +func extÛ°bytesÛ°IndexByte(fr *frame, args []value) value { + // func IndexByte(s []byte, c byte) int + s := args[0].([]value) + c := args[1].(byte) + for i, b := range s { + if b.(byte) == c { + return i + } + } + return -1 +} + +func extÛ°mathÛ°Float64frombits(fr *frame, args []value) value { + return math.Float64frombits(args[0].(uint64)) +} + +func extÛ°mathÛ°Float64bits(fr *frame, args []value) value { + return math.Float64bits(args[0].(float64)) +} + +func extÛ°mathÛ°Float32frombits(fr *frame, args []value) value { + return math.Float32frombits(args[0].(uint32)) +} + +func extÛ°mathÛ°Abs(fr *frame, args []value) value { + return math.Abs(args[0].(float64)) +} + +func extÛ°mathÛ°Exp(fr *frame, args []value) value { + return math.Exp(args[0].(float64)) +} + +func extÛ°mathÛ°Float32bits(fr *frame, args []value) value { + return math.Float32bits(args[0].(float32)) +} + +func extÛ°mathÛ°Min(fr *frame, args []value) value { + return math.Min(args[0].(float64), args[1].(float64)) +} + +func extÛ°mathÛ°NaN(fr *frame, args []value) value { + return math.NaN() +} + +func extÛ°mathÛ°IsNaN(fr *frame, args []value) value { + return math.IsNaN(args[0].(float64)) +} + +func extÛ°mathÛ°Inf(fr *frame, args []value) value { + return math.Inf(args[0].(int)) +} + +func extÛ°mathÛ°Ldexp(fr *frame, args []value) value { + return math.Ldexp(args[0].(float64), args[1].(int)) +} + +func extÛ°mathÛ°Log(fr *frame, args []value) value { + return math.Log(args[0].(float64)) +} + +func extÛ°runtimeÛ°Breakpoint(fr *frame, args []value) value { + runtime.Breakpoint() + return nil +} + +func extÛ°stringsÛ°Count(fr *frame, args []value) value { + return strings.Count(args[0].(string), args[1].(string)) +} + +func extÛ°stringsÛ°IndexByte(fr *frame, args []value) value { + return strings.IndexByte(args[0].(string), args[1].(byte)) +} + +func extÛ°stringsÛ°Index(fr *frame, args []value) value { + return strings.Index(args[0].(string), args[1].(string)) +} + +func extÛ°stringsÛ°Replace(fr *frame, args []value) value { + // func Replace(s, old, new string, n int) string + s := args[0].(string) + new := args[1].(string) + old := args[2].(string) + n := args[3].(int) + return strings.Replace(s, old, new, n) +} + +func extÛ°runtimeÛ°GOMAXPROCS(fr *frame, args []value) value { + // Ignore args[0]; don't let the interpreted program + // set the interpreter's GOMAXPROCS! + return runtime.GOMAXPROCS(0) +} + +func extÛ°runtimeÛ°Goexit(fr *frame, args []value) value { + // TODO(adonovan): don't kill the interpreter's main goroutine. + runtime.Goexit() + return nil +} + +func extÛ°runtimeÛ°GOROOT(fr *frame, args []value) value { + return runtime.GOROOT() +} + +func extÛ°runtimeÛ°GC(fr *frame, args []value) value { + runtime.GC() + return nil +} + +func extÛ°runtimeÛ°Gosched(fr *frame, args []value) value { + runtime.Gosched() + return nil +} + +func extÛ°runtimeÛ°NumCPU(fr *frame, args []value) value { + return runtime.NumCPU() +} + +func extÛ°timeÛ°Sleep(fr *frame, args []value) value { + time.Sleep(time.Duration(args[0].(int64))) + return nil +} + +func valueToBytes(v value) []byte { + in := v.([]value) + b := make([]byte, len(in)) + for i := range in { + b[i] = in[i].(byte) + } + return b +} + +func extÛ°osÛ°Getenv(fr *frame, args []value) value { + name := args[0].(string) + switch name { + case "GOSSAINTERP": + return "1" + case "GOARCH": + return "amd64" + case "GOOS": + return "linux" + } + return os.Getenv(name) +} + +func extÛ°osÛ°Exit(fr *frame, args []value) value { + panic(exitPanic(args[0].(int))) +} + +func extÛ°unicodeÛ°utf8Û°DecodeRuneInString(fr *frame, args []value) value { + r, n := utf8.DecodeRuneInString(args[0].(string)) + return tuple{r, n} +} + +// A fake function for turning an arbitrary value into a string. +// Handles only the cases needed by the tests. +// Uses same logic as 'print' built-in. +func extÛ°fmtÛ°Sprint(fr *frame, args []value) value { + buf := new(bytes.Buffer) + wasStr := false + for i, arg := range args[0].([]value) { + x := arg.(iface).v + _, isStr := x.(string) + if i > 0 && !wasStr && !isStr { + buf.WriteByte(' ') + } + wasStr = isStr + buf.WriteString(toString(x)) + } + return buf.String() +}