",
},
})
}
func TestEvalStruct0(t *testing.T) {
i := interp.New(interp.Options{})
runTests(t, i, []testCase{
{
desc: "func field in struct",
pre: func() {
eval(t, i, `
type Fromage struct {
Name string
Call func(string) string
}
func f() string {
a := Fromage{}
a.Name = "test"
a.Call = func(s string) string { return s }
return a.Call(a.Name)
}
`)
},
src: "f()",
res: "test",
},
{
desc: "literal func field in struct",
pre: func() {
eval(t, i, `
type Fromage2 struct {
Name string
Call func(string) string
}
func f2() string {
a := Fromage2{
"test",
func(s string) string { return s },
}
return a.Call(a.Name)
}
`)
},
src: "f2()",
res: "test",
},
})
}
func TestEvalStruct1(t *testing.T) {
i := interp.New(interp.Options{})
eval(t, i, `
type Fromage struct {
Name string
Call func(string) string
}
func f() string {
a := Fromage{
"test",
func(s string) string { return s },
}
return a.Call(a.Name)
}
`)
v := eval(t, i, `f()`)
if v.Interface().(string) != "test" {
t.Fatalf("got %v, want test", v)
}
}
func TestEvalComposite0(t *testing.T) {
i := interp.New(interp.Options{})
eval(t, i, `
type T struct {
a, b, c, d, e, f, g, h, i, j, k, l, m, n string
o map[string]int
p []string
}
var a = T{
o: map[string]int{"truc": 1, "machin": 2},
p: []string{"hello", "world"},
}
`)
v := eval(t, i, `a.p[1]`)
if v.Interface().(string) != "world" {
t.Fatalf("got %v, want word", v)
}
}
func TestEvalCompositeBin0(t *testing.T) {
i := interp.New(interp.Options{})
if err := i.Use(stdlib.Symbols); err != nil {
t.Fatal(err)
}
eval(t, i, `
import (
"fmt"
"net/http"
"time"
)
func Foo() {
http.DefaultClient = &http.Client{Timeout: 2 * time.Second}
}
`)
http.DefaultClient = &http.Client{}
eval(t, i, `Foo()`)
if http.DefaultClient.Timeout != 2*time.Second {
t.Fatalf("got %v, want 2s", http.DefaultClient.Timeout)
}
}
func TestEvalComparison(t *testing.T) {
i := interp.New(interp.Options{})
runTests(t, i, []testCase{
{src: `2 > 1`, res: "true"},
{src: `1.2 > 1.1`, res: "true"},
{src: `"hhh" > "ggg"`, res: "true"},
{src: `a, b, c := 1, 1, false; if a == b { c = true }; c`, res: "true"},
{src: `a, b, c := 1, 2, false; if a != b { c = true }; c`, res: "true"},
{
desc: "mismatched types equality",
src: `
type Foo string
type Bar string
var a = Foo("test")
var b = Bar("test")
var c = a == b
`,
err: "7:13: invalid operation: mismatched types main.Foo and main.Bar",
},
{
desc: "mismatched types less than",
src: `
type Foo string
type Bar string
var a = Foo("test")
var b = Bar("test")
var c = a < b
`,
err: "7:13: invalid operation: mismatched types main.Foo and main.Bar",
},
{src: `1 > _`, err: "1:28: cannot use _ as value"},
{src: `(_) > 1`, err: "1:28: cannot use _ as value"},
{src: `v := interface{}(2); v == 2`, res: "true"},
{src: `v := interface{}(2); v > 1`, err: "1:49: invalid operation: operator > not defined on interface{}"},
{src: `v := interface{}(int64(2)); v == 2`, res: "false"},
{src: `v := interface{}(int64(2)); v != 2`, res: "true"},
{src: `v := interface{}(2.3); v == 2.3`, res: "true"},
{src: `v := interface{}(float32(2.3)); v != 2.3`, res: "true"},
{src: `v := interface{}("hello"); v == "hello"`, res: "true"},
{src: `v := interface{}("hello"); v < "hellp"`, err: "1:55: invalid operation: operator < not defined on interface{}"},
})
}
func TestEvalCompositeArray(t *testing.T) {
i := interp.New(interp.Options{})
eval(t, i, `const l = 10`)
runTests(t, i, []testCase{
{src: "a := []int{1, 2, 7: 20, 30}", res: "[1 2 0 0 0 0 0 20 30]"},
{src: `a := []int{1, 1.2}`, err: "1:42: 6/5 truncated to int"},
{src: `a := []int{0:1, 0:1}`, err: "1:46: duplicate index 0 in array or slice literal"},
{src: `a := []int{1.1:1, 1.2:"test"}`, err: "1:39: index untyped float must be integer constant"},
{src: `a := [2]int{1, 1.2}`, err: "1:43: 6/5 truncated to int"},
{src: `a := [1]int{1, 2}`, err: "1:43: index 1 is out of bounds (>= 1)"},
{src: `b := [l]int{1, 2}`, res: "[1 2 0 0 0 0 0 0 0 0]"},
{src: `i := 10; a := [i]int{1, 2}`, err: "1:43: non-constant array bound \"i\""},
{src: `c := [...]float64{1, 3: 3.4, 5}`, res: "[1 0 0 3.4 5]"},
})
}
func TestEvalCompositeMap(t *testing.T) {
i := interp.New(interp.Options{})
runTests(t, i, []testCase{
{src: `a := map[string]int{"one":1, "two":2}`, res: "map[one:1 two:2]"},
{src: `a := map[string]int{1:1, 2:2}`, err: "1:48: cannot convert 1 to string"},
{src: `a := map[string]int{"one":1, "two":2.2}`, err: "1:63: 11/5 truncated to int"},
{src: `a := map[string]int{1, "two":2}`, err: "1:48: missing key in map literal"},
{src: `a := map[string]int{"one":1, "one":2}`, err: "1:57: duplicate key one in map literal"},
})
}
func TestEvalCompositeStruct(t *testing.T) {
i := interp.New(interp.Options{})
runTests(t, i, []testCase{
{src: `a := struct{A,B,C int}{}`, res: "{0 0 0}"},
{src: `a := struct{A,B,C int}{1,2,3}`, res: "{1 2 3}"},
{src: `a := struct{A,B,C int}{1,2.2,3}`, err: "1:53: 11/5 truncated to int"},
{src: `a := struct{A,B,C int}{1,2}`, err: "1:53: too few values in struct literal"},
{src: `a := struct{A,B,C int}{1,2,3,4}`, err: "1:57: too many values in struct literal"},
{src: `a := struct{A,B,C int}{1,B:2,3}`, err: "1:53: mixture of field:value and value elements in struct literal"},
{src: `a := struct{A,B,C int}{A:1,B:2,C:3}`, res: "{1 2 3}"},
{src: `a := struct{A,B,C int}{B:2}`, res: "{0 2 0}"},
{src: `a := struct{A,B,C int}{A:1,D:2,C:3}`, err: "1:55: unknown field D in struct literal"},
{src: `a := struct{A,B,C int}{A:1,A:2,C:3}`, err: "1:55: duplicate field name A in struct literal"},
{src: `a := struct{A,B,C int}{A:1,B:2.2,C:3}`, err: "1:57: 11/5 truncated to int"},
{src: `a := struct{A,B,C int}{A:1,2,C:3}`, err: "1:55: mixture of field:value and value elements in struct literal"},
{src: `a := struct{A,B,C int}{1,2,_}`, err: "1:33: cannot use _ as value"},
{src: `a := struct{A,B,C int}{B: _}`, err: "1:51: cannot use _ as value"},
})
}
func TestEvalSliceExpression(t *testing.T) {
i := interp.New(interp.Options{})
runTests(t, i, []testCase{
{src: `a := []int{0,1,2}[1:3]`, res: "[1 2]"},
{src: `a := []int{0,1,2}[:3]`, res: "[0 1 2]"},
{src: `a := []int{0,1,2}[:]`, res: "[0 1 2]"},
{src: `a := []int{0,1,2,3}[1:3:4]`, res: "[1 2]"},
{src: `a := []int{0,1,2,3}[:3:4]`, res: "[0 1 2]"},
{src: `ar := [3]int{0,1,2}; a := ar[1:3]`, res: "[1 2]"},
{src: `a := (&[3]int{0,1,2})[1:3]`, res: "[1 2]"},
{src: `a := (&[3]int{0,1,2})[1:3]`, res: "[1 2]"},
{src: `s := "hello"[1:3]`, res: "el"},
{src: `str := "hello"; s := str[1:3]`, res: "el"},
{src: `a := int(1)[0:1]`, err: "1:33: cannot slice type int"},
{src: `a := (&[]int{0,1,2,3})[1:3]`, err: "1:33: cannot slice type *[]int"},
{src: `a := "hello"[1:3:4]`, err: "1:45: invalid operation: 3-index slice of string"},
{src: `ar := [3]int{0,1,2}; a := ar[:4]`, err: "1:58: index int is out of bounds"},
{src: `a := []int{0,1,2,3}[1::4]`, err: "index required in 3-index slice"},
{src: `a := []int{0,1,2,3}[1:3:]`, err: "index required in 3-index slice"},
{src: `a := []int{0,1,2}[3:1]`, err: "invalid index values, must be low <= high <= max"},
{pre: func() { eval(t, i, `type Str = string; var r Str = "truc"`) }, src: `r[1]`, res: "114"},
{src: `_[12]`, err: "1:28: cannot use _ as value"},
{src: `b := []int{0,1,2}[_:4]`, err: "1:33: cannot use _ as value"},
})
}
func TestEvalConversion(t *testing.T) {
i := interp.New(interp.Options{})
runTests(t, i, []testCase{
{src: `a := uint64(1)`, res: "1"},
{src: `i := 1.1; a := uint64(i)`, res: "1"},
{src: `b := string(49)`, res: "1"},
{src: `c := uint64(1.1)`, err: "1:40: cannot convert expression of type untyped float to type uint64"},
{src: `int(_)`, err: "1:28: cannot use _ as value"},
})
}
func TestEvalUnary(t *testing.T) {
i := interp.New(interp.Options{})
runTests(t, i, []testCase{
{src: "a := -1", res: "-1"},
{src: "b := +1", res: "1", skip: "BUG"},
{src: "c := !false", res: "true"},
{src: "_ = 2; _++", err: "1:35: cannot use _ as value"},
{src: "_ = false; !_ == true", err: "1:39: cannot use _ as value"},
{src: "!((((_))))", err: "1:28: cannot use _ as value"},
})
}
func TestEvalMethod(t *testing.T) {
i := interp.New(interp.Options{})
eval(t, i, `
type Root struct {
Name string
}
type One struct {
Root
}
type Hi interface {
Hello() string
}
type Hey interface {
Hello() string
}
func (r *Root) Hello() string { return "Hello " + r.Name }
var r = Root{"R"}
var o = One{r}
// TODO(mpl): restore empty interfaces when type assertions work (again) on them.
// var root interface{} = &Root{Name: "test1"}
// var one interface{} = &One{Root{Name: "test2"}}
var root Hey = &Root{Name: "test1"}
var one Hey = &One{Root{Name: "test2"}}
`)
runTests(t, i, []testCase{
{src: "r.Hello()", res: "Hello R"},
{src: "(&r).Hello()", res: "Hello R"},
{src: "o.Hello()", res: "Hello R"},
{src: "(&o).Hello()", res: "Hello R"},
{src: "root.(Hi).Hello()", res: "Hello test1"},
{src: "one.(Hi).Hello()", res: "Hello test2"},
})
}
func TestEvalChan(t *testing.T) {
i := interp.New(interp.Options{})
runTests(t, i, []testCase{
{
src: `(func () string {
messages := make(chan string)
go func() { messages <- "ping" }()
msg := <-messages
return msg
})()`, res: "ping",
},
{
src: `(func () bool {
messages := make(chan string)
go func() { messages <- "ping" }()
msg, ok := <-messages
return ok && msg == "ping"
})()`, res: "true",
},
{
src: `(func () bool {
messages := make(chan string)
go func() { messages <- "ping" }()
var msg string
var ok bool
msg, ok = <-messages
return ok && msg == "ping"
})()`, res: "true",
},
{src: `a :=5; a <- 4`, err: "cannot send to non-channel int"},
{src: `a :=5; b := <-a`, err: "cannot receive from non-channel int"},
})
}
func TestEvalFunctionCallWithFunctionParam(t *testing.T) {
i := interp.New(interp.Options{})
eval(t, i, `
func Bar(s string, fn func(string)string) string { return fn(s) }
`)
v := eval(t, i, "Bar")
bar := v.Interface().(func(string, func(string) string) string)
got := bar("hello ", func(s string) string {
return s + "world!"
})
want := "hello world!"
if got != want {
t.Errorf("unexpected result of function eval: got %q, want %q", got, want)
}
}
func TestEvalCall(t *testing.T) {
i := interp.New(interp.Options{})
runTests(t, i, []testCase{
{src: ` test := func(a int, b float64) int { return a }
a := test(1, 2.3)`, res: "1"},
{src: ` test := func(a int, b float64) int { return a }
a := test(1)`, err: "2:10: not enough arguments in call to test"},
{src: ` test := func(a int, b float64) int { return a }
s := "test"
a := test(1, s)`, err: "3:18: cannot use type string as type float64"},
{src: ` test := func(a ...int) int { return 1 }
a := test([]int{1}...)`, res: "1"},
{src: ` test := func(a ...int) int { return 1 }
a := test()`, res: "1"},
{src: ` test := func(a ...int) int { return 1 }
blah := func() []int { return []int{1,1} }
a := test(blah()...)`, res: "1"},
{src: ` test := func(a ...int) int { return 1 }
a := test([]string{"1"}...)`, err: "2:15: cannot use []string as type []int"},
{src: ` test := func(a ...int) int { return 1 }
i := 1
a := test(i...)`, err: "3:15: cannot use int as type []int"},
{src: ` test := func(a int) int { return a }
a := test([]int{1}...)`, err: "2:10: invalid use of ..., corresponding parameter is non-variadic"},
{src: ` test := func(a ...int) int { return 1 }
blah := func() (int, int) { return 1, 1 }
a := test(blah()...)`, err: "3:15: cannot use ... with 2-valued func() (int,int)"},
{src: ` test := func(a, b int) int { return a }
blah := func() (int, int) { return 1, 1 }
a := test(blah())`, res: "1"},
{src: ` test := func(a, b int) int { return a }
blah := func() int { return 1 }
a := test(blah(), blah())`, res: "1"},
{src: ` test := func(a, b, c, d int) int { return a }
blah := func() (int, int) { return 1, 1 }
a := test(blah(), blah())`, err: "3:15: cannot use func() (int,int) as type int"},
{src: ` test := func(a, b int) int { return a }
blah := func() (int, float64) { return 1, 1.1 }
a := test(blah())`, err: "3:15: cannot use func() (int,float64) as type (int,int)"},
{src: "func f()", err: "missing function body"},
})
}
func TestEvalBinCall(t *testing.T) {
i := interp.New(interp.Options{})
if err := i.Use(stdlib.Symbols); err != nil {
t.Fatal(err)
}
if _, err := i.Eval(`import "fmt"`); err != nil {
t.Fatal(err)
}
runTests(t, i, []testCase{
{src: `a := fmt.Sprint(1, 2.3)`, res: "1 2.3"},
{src: `a := fmt.Sprintf()`, err: "1:33: not enough arguments in call to fmt.Sprintf"},
{src: `i := 1
a := fmt.Sprintf(i)`, err: "2:24: cannot use type int as type string"},
{src: `a := fmt.Sprint()`, res: ""},
})
}
func TestEvalReflect(t *testing.T) {
i := interp.New(interp.Options{})
if err := i.Use(stdlib.Symbols); err != nil {
t.Fatal(err)
}
if _, err := i.Eval(`
import (
"net/url"
"reflect"
)
type Encoder interface {
EncodeValues(key string, v *url.Values) error
}
`); err != nil {
t.Fatal(err)
}
runTests(t, i, []testCase{
{src: "reflect.TypeOf(new(Encoder)).Elem()", res: "interp.valueInterface"},
})
}
func TestEvalMissingSymbol(t *testing.T) {
defer func() {
r := recover()
if r != nil {
t.Errorf("unexpected panic: %v", r)
}
}()
type S2 struct{}
type S1 struct {
F S2
}
i := interp.New(interp.Options{})
if err := i.Use(interp.Exports{"p/p": map[string]reflect.Value{
"S1": reflect.Zero(reflect.TypeOf(&S1{})),
}}); err != nil {
t.Fatal(err)
}
_, err := i.Eval(`import "p"`)
if err != nil {
t.Fatalf("failed to import package: %v", err)
}
_, err = i.Eval(`p.S1{F: p.S2{}}`)
if err == nil {
t.Error("unexpected nil error for expression with undefined type")
}
}
func TestEvalWithContext(t *testing.T) {
tests := []testCase{
{
desc: "for {}",
src: `(func() {
for {}
})()`,
},
{
desc: "select {}",
src: `(func() {
select {}
})()`,
},
{
desc: "blocked chan send",
src: `(func() {
c := make(chan int)
c <- 1
})()`,
},
{
desc: "blocked chan recv",
src: `(func() {
c := make(chan int)
<-c
})()`,
},
{
desc: "blocked chan recv2",
src: `(func() {
c := make(chan int)
_, _ = <-c
})()`,
},
{
desc: "blocked range chan",
src: `(func() {
c := make(chan int)
for range c {}
})()`,
},
{
desc: "double lock",
src: `(func() {
var mu sync.Mutex
mu.Lock()
mu.Lock()
})()`,
},
}
for _, test := range tests {
done := make(chan struct{})
src := test.src
go func() {
defer close(done)
i := interp.New(interp.Options{})
if err := i.Use(stdlib.Symbols); err != nil {
t.Error(err)
}
_, err := i.Eval(`import "sync"`)
if err != nil {
t.Errorf(`failed to import "sync": %v`, err)
return
}
ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
defer cancel()
_, err = i.EvalWithContext(ctx, src)
switch err {
case context.DeadlineExceeded:
// Successful cancellation.
// Check we can still execute an expression.
v, err := i.EvalWithContext(context.Background(), "1+1\n")
if err != nil {
t.Errorf("failed to evaluate expression after cancellation: %v", err)
}
got := v.Interface()
if got != 2 {
t.Errorf("unexpected result of eval(1+1): got %v, want 2", got)
}
case nil:
t.Errorf("unexpected success evaluating expression %q", test.desc)
default:
t.Errorf("failed to evaluate expression %q: %v", test.desc, err)
}
}()
select {
case <-time.After(time.Second):
t.Errorf("timeout failed to terminate execution of %q", test.desc)
case <-done:
}
}
}
func runTests(t *testing.T, i *interp.Interpreter, tests []testCase) {
t.Helper()
for _, test := range tests {
t.Run(test.desc, func(t *testing.T) {
if test.skip != "" {
t.Skip(test.skip)
}
if test.pre != nil {
test.pre()
}
if test.src != "" {
assertEval(t, i, test.src, test.err, test.res)
}
})
}
}
func eval(t *testing.T, i *interp.Interpreter, src string) reflect.Value {
t.Helper()
res, err := i.Eval(src)
if err != nil {
t.Logf("Error: %v", err)
if e, ok := err.(interp.Panic); ok {
t.Log(string(e.Stack))
}
t.FailNow()
}
return res
}
func assertEval(t *testing.T, i *interp.Interpreter, src, expectedError, expectedRes string) {
t.Helper()
res, err := i.Eval(src)
if expectedError != "" {
if err == nil || !strings.Contains(err.Error(), expectedError) {
t.Fatalf("got %v, want %s", err, expectedError)
}
return
}
if err != nil {
t.Logf("got an error: %v", err)
if e, ok := err.(interp.Panic); ok {
t.Log(string(e.Stack))
}
t.FailNow()
}
if fmt.Sprintf("%v", res) != expectedRes {
t.Fatalf("got %v, want %s", res, expectedRes)
}
}
func TestMultiEval(t *testing.T) {
t.Skip("fail in CI only ?")
// catch stdout
backupStdout := os.Stdout
defer func() {
os.Stdout = backupStdout
}()
r, w, _ := os.Pipe()
os.Stdout = w
i := interp.New(interp.Options{})
if err := i.Use(stdlib.Symbols); err != nil {
t.Fatal(err)
}
f, err := os.Open(filepath.Join("testdata", "multi", "731"))
if err != nil {
t.Fatal(err)
}
names, err := f.Readdirnames(-1)
if err != nil {
t.Fatal(err)
}
for _, v := range names {
if _, err := i.EvalPath(filepath.Join(f.Name(), v)); err != nil {
t.Fatal(err)
}
}
// read stdout
if err = w.Close(); err != nil {
t.Fatal(err)
}
outInterp, err := io.ReadAll(r)
if err != nil {
t.Fatal(err)
}
// restore Stdout
os.Stdout = backupStdout
want := "A\nB\n"
got := string(outInterp)
if got != want {
t.Fatalf("unexpected output: got %v, wanted %v", got, want)
}
}
func TestMultiEvalNoName(t *testing.T) {
t.Skip("fail in CI only ?")
i := interp.New(interp.Options{})
if err := i.Use(stdlib.Symbols); err != nil {
t.Fatal(err)
}
f, err := os.Open(filepath.Join("testdata", "multi", "731"))
if err != nil {
t.Fatal(err)
}
names, err := f.Readdirnames(-1)
if err != nil {
t.Fatal(err)
}
for k, v := range names {
data, err := os.ReadFile(filepath.Join(f.Name(), v))
if err != nil {
t.Fatal(err)
}
_, err = i.Eval(string(data))
if k == 1 {
expectedErr := fmt.Errorf("3:8: fmt/%s redeclared in this block", interp.DefaultSourceName)
if err == nil || err.Error() != expectedErr.Error() {
t.Fatalf("unexpected result; wanted error %v, got %v", expectedErr, err)
}
return
}
if err != nil {
t.Fatal(err)
}
}
}
const goMinorVersionTest = 16
func TestHasIOFS(t *testing.T) {
code := `
// +build go1.18
package main
import (
"errors"
"io/fs"
)
func main() {
pe := fs.PathError{}
pe.Op = "nothing"
pe.Path = "/nowhere"
pe.Err = errors.New("an error")
println(pe.Error())
}
// Output:
// nothing /nowhere: an error
`
var buf bytes.Buffer
i := interp.New(interp.Options{Stdout: &buf})
if err := i.Use(interp.Symbols); err != nil {
t.Fatal(err)
}
if err := i.Use(stdlib.Symbols); err != nil {
t.Fatal(err)
}
if _, err := i.Eval(code); err != nil {
t.Fatal(err)
}
var expectedOutput string
var minor int
var err error
version := runtime.Version()
version = strings.Replace(version, "beta", ".", 1)
version = strings.Replace(version, "rc", ".", 1)
fields := strings.Fields(version)
// Go stable
if len(fields) == 1 {
v := strings.Split(version, ".")
if len(v) < 2 {
t.Fatalf("unexpected: %v", version)
}
minor, err = strconv.Atoi(v[1])
if err != nil {
t.Fatal(err)
}
} else {
// Go devel
if fields[0] != "devel" {
t.Fatalf("unexpected: %v", fields[0])
}
parts := strings.Split(fields[1], "-")
if len(parts) != 2 {
t.Fatalf("unexpected: %v", fields[1])
}
minor, err = strconv.Atoi(strings.TrimPrefix(parts[0], "go1."))
if err != nil {
t.Fatal(err)
}
}
if minor >= goMinorVersionTest {
expectedOutput = "nothing /nowhere: an error\n"
}
output := buf.String()
if buf.String() != expectedOutput {
t.Fatalf("got: %v, wanted: %v", output, expectedOutput)
}
}
func TestImportPathIsKey(t *testing.T) {
// FIXME(marc): support of stdlib generic packages like "cmp", "maps", "slices" has changed
// the scope layout by introducing new source packages when stdlib is used.
// The logic of the following test doesn't apply anymore.
t.Skip("This test needs to be reworked.")
// No need to check the results of Eval, as TestFile already does it.
i := interp.New(interp.Options{GoPath: filepath.FromSlash("../_test/testdata/redeclaration-global7")})
if err := i.Use(stdlib.Symbols); err != nil {
t.Fatal(err)
}
filePath := filepath.Join("..", "_test", "ipp_as_key.go")
if _, err := i.EvalPath(filePath); err != nil {
t.Fatal(err)
}
wantScopes := map[string][]string{
"main": {
"titi/ipp_as_key.go",
"tutu/ipp_as_key.go",
"main",
},
"guthib.com/toto": {
"quux/titi.go",
"Quux",
},
"guthib.com/bar": {
"Quux",
},
"guthib.com/tata": {
"quux/tutu.go",
"Quux",
},
"guthib.com/baz": {
"Quux",
},
}
wantPackages := map[string]string{
"guthib.com/baz": "quux",
"guthib.com/tata": "tutu",
"main": "main",
"guthib.com/bar": "quux",
"guthib.com/toto": "titi",
}
scopes := i.Scopes()
if len(scopes) != len(wantScopes) {
t.Fatalf("want %d, got %d", len(wantScopes), len(scopes))
}
for k, v := range scopes {
wantSym := wantScopes[k]
if len(v) != len(wantSym) {
t.Fatalf("want %d, got %d", len(wantSym), len(v))
}
for _, sym := range wantSym {
if _, ok := v[sym]; !ok {
t.Fatalf("symbol %s not found in scope %s", sym, k)
}
}
}
packages := i.Packages()
for k, v := range wantPackages {
pkg := packages[k]
if pkg != v {
t.Fatalf("for import path %s, want %s, got %s", k, v, pkg)
}
}
}
// The code in hello1.go and hello2.go spawns a "long-running" goroutine, which
// means each call to EvalPath actually terminates before the evaled code is done
// running. So this test demonstrates:
// 1) That two sequential calls to EvalPath don't see their "compilation phases"
// collide (no data race on the fields of the interpreter), which is somewhat
// obvious since the calls (and hence the "compilation phases") are sequential too.
// 2) That two concurrent goroutine runs spawned by the same interpreter do not
// collide either.
func TestConcurrentEvals(t *testing.T) {
if testing.Short() {
return
}
pin, pout := io.Pipe()
defer func() {
_ = pin.Close()
_ = pout.Close()
}()
interpr := interp.New(interp.Options{Stdout: pout})
if err := interpr.Use(stdlib.Symbols); err != nil {
t.Fatal(err)
}
if _, err := interpr.EvalPath("testdata/concurrent/hello1.go"); err != nil {
t.Fatal(err)
}
if _, err := interpr.EvalPath("testdata/concurrent/hello2.go"); err != nil {
t.Fatal(err)
}
c := make(chan error)
go func() {
hello1, hello2 := false, false
sc := bufio.NewScanner(pin)
for sc.Scan() {
l := sc.Text()
switch l {
case "hello world1":
hello1 = true
case "hello world2":
hello2 = true
case "hello world1hello world2", "hello world2hello world1":
hello1 = true
hello2 = true
default:
c <- fmt.Errorf("unexpected output: %v", l)
return
}
if hello1 && hello2 {
break
}
}
c <- nil
}()
timeout := time.NewTimer(5 * time.Second)
select {
case <-timeout.C:
t.Fatal("timeout")
case err := <-c:
if err != nil {
t.Fatal(err)
}
}
}
// TestConcurrentEvals2 shows that even though EvalWithContext calls Eval in a
// goroutine, it indeed waits for Eval to terminate, and that therefore the code
// called by EvalWithContext is sequential. And that there is no data race for the
// interp package global vars or the interpreter fields in this case.
func TestConcurrentEvals2(t *testing.T) {
if testing.Short() {
return
}
pin, pout := io.Pipe()
defer func() {
_ = pin.Close()
_ = pout.Close()
}()
interpr := interp.New(interp.Options{Stdout: pout})
if err := interpr.Use(stdlib.Symbols); err != nil {
t.Fatal(err)
}
done := make(chan error)
go func() {
hello1 := false
sc := bufio.NewScanner(pin)
for sc.Scan() {
l := sc.Text()
if hello1 {
if l == "hello world2" {
break
}
done <- fmt.Errorf("unexpected output: %v", l)
return
}
if l == "hello world1" {
hello1 = true
} else {
done <- fmt.Errorf("unexpected output: %v", l)
return
}
}
done <- nil
}()
ctx := context.Background()
if _, err := interpr.EvalWithContext(ctx, `import "time"`); err != nil {
t.Fatal(err)
}
if _, err := interpr.EvalWithContext(ctx, `time.Sleep(time.Second); println("hello world1")`); err != nil {
t.Fatal(err)
}
if _, err := interpr.EvalWithContext(ctx, `time.Sleep(time.Second); println("hello world2")`); err != nil {
t.Fatal(err)
}
timeout := time.NewTimer(5 * time.Second)
select {
case <-timeout.C:
t.Fatal("timeout")
case err := <-done:
if err != nil {
t.Fatal(err)
}
}
}
// TestConcurrentEvals3 makes sure that we don't regress into data races at the package level, i.e from:
// - global vars, which should obviously not be mutated.
// - when calling Interpreter.Use, the symbols given as argument should be
// copied when being inserted into interp.binPkg, and not directly used as-is.
func TestConcurrentEvals3(t *testing.T) {
if testing.Short() {
return
}
allDone := make(chan bool)
runREPL := func() {
done := make(chan error)
pinin, poutin := io.Pipe()
pinout, poutout := io.Pipe()
i := interp.New(interp.Options{Stdin: pinin, Stdout: poutout})
if err := i.Use(stdlib.Symbols); err != nil {
t.Fatal(err)
}
go func() {
_, _ = i.REPL()
}()
input := []string{
`hello one`,
`hello two`,
`hello three`,
}
go func() {
sc := bufio.NewScanner(pinout)
k := 0
for sc.Scan() {
l := sc.Text()
if l != input[k] {
done <- fmt.Errorf("unexpected output, want %q, got %q", input[k], l)
return
}
k++
if k > 2 {
break
}
}
done <- nil
}()
for _, v := range input {
in := strings.NewReader(fmt.Sprintf("println(%q)\n", v))
if _, err := io.Copy(poutin, in); err != nil {
t.Fatal(err)
}
time.Sleep(time.Second)
}
if err := <-done; err != nil {
t.Fatal(err)
}
_ = pinin.Close()
_ = poutin.Close()
_ = pinout.Close()
_ = poutout.Close()
allDone <- true
}
for i := 0; i < 2; i++ {
go func() {
runREPL()
}()
}
timeout := time.NewTimer(10 * time.Second)
for i := 0; i < 2; i++ {
select {
case <-allDone:
case <-timeout.C:
t.Fatal("timeout")
}
}
}
func TestConcurrentComposite1(t *testing.T) {
testConcurrentComposite(t, "./testdata/concurrent/composite/composite_lit.go")
}
func TestConcurrentComposite2(t *testing.T) {
testConcurrentComposite(t, "./testdata/concurrent/composite/composite_sparse.go")
}
func testConcurrentComposite(t *testing.T, filePath string) {
t.Helper()
if testing.Short() {
return
}
pin, pout := io.Pipe()
i := interp.New(interp.Options{Stdout: pout})
if err := i.Use(stdlib.Symbols); err != nil {
t.Fatal(err)
}
errc := make(chan error)
var output string
go func() {
sc := bufio.NewScanner(pin)
k := 0
for sc.Scan() {
output += sc.Text()
k++
if k > 1 {
break
}
}
errc <- nil
}()
if _, err := i.EvalPath(filePath); err != nil {
t.Fatal(err)
}
_ = pin.Close()
_ = pout.Close()
if err := <-errc; err != nil {
t.Fatal(err)
}
expected := "{hello}{hello}"
if output != expected {
t.Fatalf("unexpected output, want %q, got %q", expected, output)
}
}
func TestEvalREPL(t *testing.T) {
if testing.Short() {
return
}
type testCase struct {
desc string
src []string
errorLine int
}
tests := []testCase{
{
desc: "no error",
src: []string{
`func main() {`,
`println("foo")`,
`}`,
},
errorLine: -1,
},
{
desc: "no parsing error, but block error",
src: []string{
`func main() {`,
`println(foo)`,
`}`,
},
errorLine: 2,
},
{
desc: "parsing error",
src: []string{
`func main() {`,
`println(/foo)`,
`}`,
},
errorLine: 1,
},
{
desc: "multi-line string literal",
src: []string{
"var a = `hello",
"there, how",
"are you?`",
},
errorLine: -1,
},
{
desc: "multi-line comma operand",
src: []string{
`println(2,`,
`3)`,
},
errorLine: -1,
},
{
desc: "multi-line arithmetic operand",
src: []string{
`println(2. /`,
`3.)`,
},
errorLine: -1,
},
{
desc: "anonymous func call with no assignment",
src: []string{
`func() { println(3) }()`,
},
errorLine: -1,
},
{
// to make sure that special handling of the above anonymous, does not break this general case.
desc: "just func",
src: []string{
`func foo() { println(3) }`,
},
errorLine: -1,
},
{
// to make sure that special handling of the above anonymous, does not break this general case.
desc: "just method",
src: []string{
`type bar string`,
`func (b bar) foo() { println(3) }`,
},
errorLine: -1,
},
{
desc: "define a label",
src: []string{
`a:`,
},
errorLine: -1,
},
}
runREPL := func(t *testing.T, test testCase) {
// TODO(mpl): use a pipe for the output as well, just as in TestConcurrentEvals5
var stdout bytes.Buffer
safeStdout := &safeBuffer{buf: &stdout}
var stderr bytes.Buffer
safeStderr := &safeBuffer{buf: &stderr}
pin, pout := io.Pipe()
i := interp.New(interp.Options{Stdin: pin, Stdout: safeStdout, Stderr: safeStderr})
defer func() {
// Closing the pipe also takes care of making i.REPL terminate,
// hence freeing its goroutine.
_ = pin.Close()
_ = pout.Close()
}()
go func() {
_, _ = i.REPL()
}()
for k, v := range test.src {
if _, err := pout.Write([]byte(v + "\n")); err != nil {
t.Error(err)
}
Sleep(100 * time.Millisecond)
errMsg := safeStderr.String()
if k == test.errorLine {
if errMsg == "" {
t.Fatalf("test %q: statement %q should have produced an error", test.desc, v)
}
break
}
if errMsg != "" {
t.Fatalf("test %q: unexpected error: %v", test.desc, errMsg)
}
}
}
for _, test := range tests {
runREPL(t, test)
}
}
type safeBuffer struct {
mu sync.RWMutex
buf *bytes.Buffer
}
func (sb *safeBuffer) Read(p []byte) (int, error) {
return sb.buf.Read(p)
}
func (sb *safeBuffer) String() string {
sb.mu.RLock()
defer sb.mu.RUnlock()
return sb.buf.String()
}
func (sb *safeBuffer) Write(p []byte) (int, error) {
sb.mu.Lock()
defer sb.mu.Unlock()
return sb.buf.Write(p)
}
const (
// CITimeoutMultiplier is the multiplier for all timeouts in the CI.
CITimeoutMultiplier = 3
)
// Sleep pauses the current goroutine for at least the duration d.
func Sleep(d time.Duration) {
d = applyCIMultiplier(d)
time.Sleep(d)
}
func applyCIMultiplier(timeout time.Duration) time.Duration {
ci := os.Getenv("CI")
if ci == "" {
return timeout
}
b, err := strconv.ParseBool(ci)
if err != nil || !b {
return timeout
}
return time.Duration(float64(timeout) * CITimeoutMultiplier)
}
func TestREPLCommands(t *testing.T) {
if testing.Short() {
return
}
t.Setenv("YAEGI_PROMPT", "1") // To force prompts over non-tty streams
allDone := make(chan bool)
runREPL := func() {
done := make(chan error)
pinin, poutin := io.Pipe()
pinout, poutout := io.Pipe()
i := interp.New(interp.Options{Stdin: pinin, Stdout: poutout})
if err := i.Use(stdlib.Symbols); err != nil {
t.Fatal(err)
}
go func() {
_, _ = i.REPL()
}()
defer func() {
_ = pinin.Close()
_ = poutin.Close()
_ = pinout.Close()
_ = poutout.Close()
allDone <- true
}()
input := []string{
`1/1`,
`7/3`,
`16/5`,
`3./2`, // float
`reflect.TypeOf(math_rand.Int)`,
`reflect.TypeOf(crypto_rand.Int)`,
}
output := []string{
`1`,
`2`,
`3`,
`1.5`,
`func() int`,
`func(io.Reader, *big.Int) (*big.Int, error)`,
}
go func() {
sc := bufio.NewScanner(pinout)
k := 0
for sc.Scan() {
l := sc.Text()
if l != "> : "+output[k] {
done <- fmt.Errorf("unexpected output, want %q, got %q", output[k], l)
return
}
k++
if k > 3 {
break
}
}
done <- nil
}()
for _, v := range input {
in := strings.NewReader(v + "\n")
if _, err := io.Copy(poutin, in); err != nil {
t.Fatal(err)
}
select {
case err := <-done:
if err != nil {
t.Fatal(err)
}
return
default:
time.Sleep(time.Second)
}
}
if err := <-done; err != nil {
t.Fatal(err)
}
}
go func() {
runREPL()
}()
timeout := time.NewTimer(10 * time.Second)
select {
case <-allDone:
case <-timeout.C:
t.Fatal("timeout")
}
}
func TestStdio(t *testing.T) {
i := interp.New(interp.Options{})
if err := i.Use(stdlib.Symbols); err != nil {
t.Fatal(err)
}
i.ImportUsed()
if _, err := i.Eval(`var x = os.Stdout`); err != nil {
t.Fatal(err)
}
v, _ := i.Eval(`x`)
if _, ok := v.Interface().(*os.File); !ok {
t.Fatalf("%v not *os.file", v.Interface())
}
}
func TestNoGoFiles(t *testing.T) {
i := interp.New(interp.Options{GoPath: build.Default.GOPATH})
_, err := i.Eval(`import "github.com/traefik/yaegi/_test/p3"`)
if strings.Contains(err.Error(), "no Go files in") {
return
}
t.Fatalf("failed to detect no Go files: %v", err)
}
func TestIssue1142(t *testing.T) {
i := interp.New(interp.Options{})
runTests(t, i, []testCase{
{src: "a := 1; // foo bar", res: "1"},
})
}
type Issue1149Array [3]float32
func (v Issue1149Array) Foo() string { return "foo" }
func (v *Issue1149Array) Bar() string { return "foo" }
func TestIssue1149(t *testing.T) {
i := interp.New(interp.Options{})
if err := i.Use(interp.Exports{
"pkg/pkg": map[string]reflect.Value{
"Type": reflect.ValueOf((*Issue1149Array)(nil)),
},
}); err != nil {
t.Fatal(err)
}
i.ImportUsed()
_, err := i.Eval(`
type Type = pkg.Type
`)
if err != nil {
t.Fatal(err)
}
runTests(t, i, []testCase{
{src: "Type{1, 2, 3}.Foo()", res: "foo"},
{src: "Type{1, 2, 3}.Bar()", res: "foo"},
})
}
func TestIssue1150(t *testing.T) {
i := interp.New(interp.Options{})
_, err := i.Eval(`
type ArrayT [3]float32
type SliceT []float32
type StructT struct { A, B, C float32 }
type StructT2 struct { A, B, C float32 }
type FooerT interface { Foo() string }
func (v ArrayT) Foo() string { return "foo" }
func (v SliceT) Foo() string { return "foo" }
func (v StructT) Foo() string { return "foo" }
func (v *StructT2) Foo() string { return "foo" }
type Array = ArrayT
type Slice = SliceT
type Struct = StructT
type Struct2 = StructT2
type Fooer = FooerT
`)
if err != nil {
t.Fatal(err)
}
runTests(t, i, []testCase{
{desc: "array", src: "Array{1, 2, 3}.Foo()", res: "foo"},
{desc: "slice", src: "Slice{1, 2, 3}.Foo()", res: "foo"},
{desc: "struct", src: "Struct{1, 2, 3}.Foo()", res: "foo"},
{desc: "*struct", src: "Struct2{1, 2, 3}.Foo()", res: "foo"},
{desc: "interface", src: "v := Fooer(Array{1, 2, 3}); v.Foo()", res: "foo"},
})
}
func TestIssue1151(t *testing.T) {
type pkgStruct struct{ X int }
type pkgArray [1]int
i := interp.New(interp.Options{})
if err := i.Use(interp.Exports{
"pkg/pkg": map[string]reflect.Value{
"Struct": reflect.ValueOf((*pkgStruct)(nil)),
"Array": reflect.ValueOf((*pkgArray)(nil)),
},
}); err != nil {
t.Fatal(err)
}
i.ImportUsed()
runTests(t, i, []testCase{
{src: "x := pkg.Struct{1}", res: "{1}"},
{src: "x := pkg.Array{1}", res: "[1]"},
})
}
func TestPassArgs(t *testing.T) {
i := interp.New(interp.Options{Args: []string{"arg0", "arg1"}})
if err := i.Use(stdlib.Symbols); err != nil {
t.Fatal(err)
}
i.ImportUsed()
runTests(t, i, []testCase{
{src: "os.Args", res: "[arg0 arg1]"},
})
}
func TestRestrictedEnv(t *testing.T) {
i := interp.New(interp.Options{Env: []string{"foo=bar"}})
if err := i.Use(stdlib.Symbols); err != nil {
t.Fatal(err)
}
i.ImportUsed()
runTests(t, i, []testCase{
{src: `os.Getenv("foo")`, res: "bar"},
{src: `s, ok := os.LookupEnv("foo"); s`, res: "bar"},
{src: `s, ok := os.LookupEnv("foo"); ok`, res: "true"},
{src: `s, ok := os.LookupEnv("PATH"); s`, res: ""},
{src: `s, ok := os.LookupEnv("PATH"); ok`, res: "false"},
{src: `os.Setenv("foo", "baz"); os.Environ()`, res: "[foo=baz]"},
{src: `os.ExpandEnv("foo is ${foo}")`, res: "foo is baz"},
{src: `os.Unsetenv("foo"); os.Environ()`, res: "[]"},
{src: `os.Setenv("foo", "baz"); os.Environ()`, res: "[foo=baz]"},
{src: `os.Clearenv(); os.Environ()`, res: "[]"},
{src: `os.Setenv("foo", "baz"); os.Environ()`, res: "[foo=baz]"},
})
if s, ok := os.LookupEnv("foo"); ok {
t.Fatal("expected \"\", got " + s)
}
}
func TestIssue1388(t *testing.T) {
i := interp.New(interp.Options{Env: []string{"foo=bar"}})
err := i.Use(stdlib.Symbols)
if err != nil {
t.Fatal(err)
}
_, err = i.Eval(`x := errors.New("")`)
if err == nil {
t.Fatal("Expected an error")
}
_, err = i.Eval(`import "errors"`)
if err != nil {
t.Fatal(err)
}
_, err = i.Eval(`x := errors.New("")`)
if err != nil {
t.Fatal(err)
}
}
func TestIssue1383(t *testing.T) {
const src = `
package main
func main() {
fmt.Println("Hello")
}
`
i := interp.New(interp.Options{})
err := i.Use(stdlib.Symbols)
if err != nil {
t.Fatal(err)
}
_, err = i.Eval(`import "fmt"`)
if err != nil {
t.Fatal(err)
}
ast, err := parser.ParseFile(i.FileSet(), "_.go", src, parser.DeclarationErrors)
if err != nil {
t.Fatal(err)
}
prog, err := i.CompileAST(ast)
if err != nil {
t.Fatal(err)
}
_, err = i.Execute(prog)
if err != nil {
t.Fatal(err)
}
}
func TestIssue1623(t *testing.T) {
var f float64
var j int
var s string = "foo"
i := interp.New(interp.Options{})
if err := i.Use(interp.Exports{
"pkg/pkg": map[string]reflect.Value{
"F": reflect.ValueOf(&f).Elem(),
"J": reflect.ValueOf(&j).Elem(),
"S": reflect.ValueOf(&s).Elem(),
},
}); err != nil {
t.Fatal(err)
}
i.ImportUsed()
runTests(t, i, []testCase{
{desc: "pkg.F = 2.0", src: "pkg.F = 2.0; pkg.F", res: "2"},
{desc: "pkg.J = 3", src: "pkg.J = 3; pkg.J", res: "3"},
{desc: `pkg.S = "bar"`, src: `pkg.S = "bar"; pkg.S`, res: "bar"},
})
}
================================================
FILE: interp/interp_export_test.go
================================================
package interp_test
import (
"reflect"
"testing"
"github.com/traefik/yaegi/interp"
)
type Helloer interface {
Hello()
}
func Hi(h Helloer) {
println("In Hi:")
h.Hello()
}
// A Wrap represents the wrapper which allows to use objects created by
// the interpreter as Go interfaces (despite limitations in reflect which
// forbid dynamic method creation).
//
// All the struct fields are functions, where the fied name corresponds to
// the method name prefixed by "Do". The function signature must be the
// same as the interface one.
//
// A corresponding Wrap method Xyz which satisfies the interface must exist and
// must invoke the DoXyz function.
//
// To be usable, the interpreter should return a Wrap instance with the relevant
// function fields filled. The application can then invoke methods on it.
// The method calls will be forwarded to the interpreter.
//
// Only the Wrap type definition needs to be exported to the interpreter (not
// the interfaces and methods definitions).
type Wrap struct {
DoHello func() // related to the Hello() method.
// Other interface method wrappers...
}
func (w Wrap) Hello() { w.DoHello() }
func TestExportsSemantics(t *testing.T) {
Foo := &struct{}{}
t.Run("Correct", func(t *testing.T) {
t.Skip()
i := interp.New(interp.Options{})
err := i.Use(interp.Exports{
"foo/foo": {"Foo": reflect.ValueOf(Foo)},
})
if err != nil {
t.Fatal(err)
}
i.ImportUsed()
res, err := i.Eval("foo.Foo")
if err != nil {
t.Fatal(err)
}
if res.Interface() != Foo {
t.Fatalf("expected foo.Foo to equal local Foo")
}
})
t.Run("Incorrect", func(t *testing.T) {
i := interp.New(interp.Options{})
err := i.Use(interp.Exports{
"foo": {"Foo": reflect.ValueOf(Foo)},
})
if err == nil {
t.Fatal("expected error for incorrect Use semantics")
}
})
}
func TestInterface(t *testing.T) {
i := interp.New(interp.Options{})
// export the Wrap type to the interpreter under virtual "wrap" package
err := i.Use(interp.Exports{
"wrap/wrap": {
"Wrap": reflect.ValueOf((*Wrap)(nil)),
},
})
if err != nil {
t.Fatal(err)
}
eval(t, i, `
import "wrap"
type MyInt int
func (m MyInt) Hello() { println("hello from Myint", m) }
func NewMyInt(i int) wrap.Wrap {
m := MyInt(i)
return wrap.Wrap{DoHello: m.Hello}
}
`)
NewMyInt := eval(t, i, "NewMyInt").Interface().(func(int) Wrap)
w := NewMyInt(4)
Hi(w)
}
type T struct{}
func (t T) Bar(s ...string) {}
func TestCallBinVariadicMethod(t *testing.T) {
i := interp.New(interp.Options{})
err := i.Use(interp.Exports{
"mypkg/mypkg": {
"T": reflect.ValueOf((*T)(nil)),
},
})
if err != nil {
t.Fatal(err)
}
eval(t, i, `
package p
import "mypkg"
func Foo(x mypkg.T) { x.Bar("s") }
`)
v := eval(t, i, "p.Foo")
bar := v.Interface().(func(t T))
bar(T{})
}
================================================
FILE: interp/interp_file_test.go
================================================
package interp_test
import (
"bytes"
"go/build"
"go/parser"
"go/token"
"os"
"path/filepath"
"runtime"
"strings"
"testing"
"github.com/traefik/yaegi/interp"
"github.com/traefik/yaegi/stdlib"
"github.com/traefik/yaegi/stdlib/unsafe"
)
// The following tests sometimes (not always) crash with go1.21 but not with go1.20 or go1.22.
// The reason of failure is not obvious, maybe due to the runtime itself, and will be investigated separately.
// Also, the closure tests depend on an incompatible language change in go1.22, where `for` variables are now
// defined in body (thus reallocated at each loop). This is now the behavior in yaegi, so 1.21 produces
// different results.
var testsToSkipGo121 = map[string]bool{"cli6.go": true, "cli7.go": true, "issue-1276.go": true, "issue-1330.go": true, "struct11.go": true, "closure9.go": true, "closure10.go": true, "closure11.go": true, "closure12.go": true, "closure15.go": true, "closure16.go": true, "closure17.go": true, "closure18.go": true, "closure20.go": true, "for17.go": true, "for18.go": true, "for19.go": true}
var go121 = strings.HasPrefix(runtime.Version(), "go1.21")
func TestFile(t *testing.T) {
filePath := "../_test/str.go"
runCheck(t, filePath)
t.Setenv("YAEGI_SPECIAL_STDIO", "1")
baseDir := filepath.Join("..", "_test")
files, err := os.ReadDir(baseDir)
if err != nil {
t.Fatal(err)
}
for _, file := range files {
if filepath.Ext(file.Name()) != ".go" {
continue
}
// Skip some tests which are problematic in go1.21 only.
if go121 && testsToSkipGo121[file.Name()] {
continue
}
file := file
t.Run(file.Name(), func(t *testing.T) {
runCheck(t, filepath.Join(baseDir, file.Name()))
})
}
}
func runCheck(t *testing.T, p string) {
t.Helper()
wanted, goPath, errWanted := wantedFromComment(p)
if wanted == "" {
t.Skip(p, "has no comment 'Output:' or 'Error:'")
}
wanted = strings.TrimSpace(wanted)
if goPath == "" {
goPath = build.Default.GOPATH
}
var stdout, stderr bytes.Buffer
i := interp.New(interp.Options{GoPath: goPath, Stdout: &stdout, Stderr: &stderr})
if err := i.Use(interp.Symbols); err != nil {
t.Fatal(err)
}
if err := i.Use(stdlib.Symbols); err != nil {
t.Fatal(err)
}
if err := i.Use(unsafe.Symbols); err != nil {
t.Fatal(err)
}
_, err := i.EvalPath(p)
if errWanted {
if err == nil {
t.Fatalf("got nil error, want: %q", wanted)
}
if res := strings.TrimSpace(err.Error()); !strings.Contains(res, wanted) {
t.Errorf("got %q, want: %q", res, wanted)
}
return
}
if err != nil {
t.Fatal(err)
}
res := strings.TrimSpace(stdout.String())
// Remove path in output, to have results independent of location.
res = strings.ReplaceAll(res, filepath.ToSlash(p)+":", "")
if res != wanted {
t.Errorf("\ngot: %q,\nwant: %q", res, wanted)
}
}
func wantedFromComment(p string) (res string, goPath string, err bool) {
fset := token.NewFileSet()
f, _ := parser.ParseFile(fset, p, nil, parser.ParseComments)
if len(f.Comments) == 0 {
return
}
text := f.Comments[len(f.Comments)-1].Text()
if strings.HasPrefix(text, "GOPATH:") {
parts := strings.SplitN(text, "\n", 2)
text = parts[1]
wd, err := os.Getwd()
if err != nil {
panic(err)
}
goPath = filepath.Join(wd, "..", "_test", strings.TrimPrefix(parts[0], "GOPATH:"))
}
if strings.HasPrefix(text, "Output:\n") {
return strings.TrimPrefix(text, "Output:\n"), goPath, false
}
if strings.HasPrefix(text, "Error:\n") {
return strings.TrimPrefix(text, "Error:\n"), goPath, true
}
return
}
================================================
FILE: interp/interp_issue_1634_test.go
================================================
package interp
import (
"bytes"
"io"
"os"
"reflect"
"testing"
)
func TestExportClosureArg(t *testing.T) {
outExp := []byte("0\n1\n2\n")
// catch stdout
backupStdout := os.Stdout
defer func() {
os.Stdout = backupStdout
}()
r, w, _ := os.Pipe()
os.Stdout = w
i := New(Options{})
err := i.Use(Exports{
"tmp/tmp": map[string]reflect.Value{
"Func": reflect.ValueOf(func(s *[]func(), f func()) { *s = append(*s, f) }),
},
})
if err != nil {
t.Error(err)
}
i.ImportUsed()
_, err = i.Eval(`
func main() {
fs := []func(){}
for i := 0; i < 3; i++ {
i := i
tmp.Func(&fs, func() { println(i) })
}
for _, f := range fs {
f()
}
}
`)
if err != nil {
t.Error(err)
}
// read stdout
if err = w.Close(); err != nil {
t.Fatal(err)
}
outInterp, err := io.ReadAll(r)
if err != nil {
t.Fatal(err)
}
if !bytes.Equal(outInterp, outExp) {
t.Errorf("\nGot: %q,\n want: %q", string(outInterp), string(outExp))
}
}
================================================
FILE: interp/interp_test.go
================================================
package interp
import (
"go/constant"
"log"
"reflect"
"testing"
"github.com/traefik/yaegi/stdlib"
)
func init() { log.SetFlags(log.Lshortfile) }
func TestIsNatural(t *testing.T) {
tests := []struct {
desc string
n *node
expected bool
}{
{
desc: "positive uint var",
n: &node{
typ: &itype{
rtype: func() reflect.Type {
var a uint = 3
return reflect.TypeOf(a)
}(),
},
rval: func() reflect.Value {
var a uint = 3
return reflect.ValueOf(a)
}(),
},
expected: true,
},
{
desc: "positive untyped var",
n: &node{
typ: &itype{
rtype: func() reflect.Type {
a := 3
return reflect.TypeOf(a)
}(),
},
rval: func() reflect.Value {
a := 3
return reflect.ValueOf(a)
}(),
},
expected: true,
},
{
desc: "positive int var",
n: &node{
typ: &itype{
rtype: func() reflect.Type {
var a int = 3
return reflect.TypeOf(a)
}(),
},
rval: func() reflect.Value {
var a int = 3
return reflect.ValueOf(a)
}(),
},
expected: true,
},
{
desc: "positive float var, null decimal",
n: &node{
typ: &itype{
rtype: func() reflect.Type {
var a float64 = 3.0
return reflect.TypeOf(a)
}(),
},
rval: func() reflect.Value {
var a float64 = 3.0
return reflect.ValueOf(a)
}(),
},
expected: true,
},
{
desc: "positive float var, with decimal",
n: &node{
typ: &itype{
rtype: func() reflect.Type {
var a float64 = 3.14
return reflect.TypeOf(a)
}(),
},
rval: func() reflect.Value {
var a float64 = 3.14
return reflect.ValueOf(a)
}(),
},
expected: false,
},
{
desc: "negative int var",
n: &node{
typ: &itype{
rtype: func() reflect.Type {
var a int = -3
return reflect.TypeOf(a)
}(),
},
rval: func() reflect.Value {
var a int = -3
return reflect.ValueOf(a)
}(),
},
expected: false,
},
{
desc: "positive typed const",
n: &node{
typ: &itype{
rtype: func() reflect.Type {
const a uint = 3
return reflect.TypeOf(a)
}(),
},
rval: func() reflect.Value {
const a uint = 3
return reflect.ValueOf(a)
}(),
},
expected: true,
},
{
desc: "positive untyped const",
n: &node{
typ: &itype{
rtype: func() reflect.Type {
const a = 3
return reflect.TypeOf(a)
}(),
},
rval: func() reflect.Value {
const a = 3
return reflect.ValueOf(a)
}(),
},
expected: true,
},
{
desc: "positive untyped const (iota)",
n: &node{
typ: &itype{
rtype: func() reflect.Type {
const (
zero = iota
a
)
return reflect.TypeOf(a)
}(),
},
rval: func() reflect.Value {
const (
zero = iota
a
)
return reflect.ValueOf(a)
}(),
},
expected: true,
},
{
desc: "negative const",
n: &node{
typ: &itype{
rtype: func() reflect.Type {
const a = -3
return reflect.TypeOf(a)
}(),
},
rval: func() reflect.Value {
const a = -3
return reflect.ValueOf(a)
}(),
},
expected: false,
},
}
for _, test := range tests {
got := test.n.isNatural()
if test.expected != got {
t.Fatalf("%s: got %v, wanted %v", test.desc, got, test.expected)
}
}
}
func TestGlobals(t *testing.T) {
i := New(Options{})
if err := i.Use(stdlib.Symbols); err != nil {
t.Fatal(err)
}
if _, err := i.Eval("var a = 1"); err != nil {
t.Fatal(err)
}
if _, err := i.Eval("b := 2"); err != nil {
t.Fatal(err)
}
if _, err := i.Eval("const c = 3"); err != nil {
t.Fatal(err)
}
g := i.Globals()
a := g["a"]
if !a.IsValid() {
t.Fatal("a not found")
}
if a := a.Interface(); a != 1 {
t.Fatalf("wrong a: want (%[1]T) %[1]v, have (%[2]T) %[2]v", 1, a)
}
b := g["b"]
if !b.IsValid() {
t.Fatal("b not found")
}
if b := b.Interface(); b != 2 {
t.Fatalf("wrong b: want (%[1]T) %[1]v, have (%[2]T) %[2]v", 2, b)
}
c := g["c"]
if !c.IsValid() {
t.Fatal("c not found")
}
if cc, ok := c.Interface().(constant.Value); ok && constant.MakeInt64(3) != cc {
t.Fatalf("wrong c: want (%[1]T) %[1]v, have (%[2]T) %[2]v", constant.MakeInt64(3), cc)
}
}
================================================
FILE: interp/op.go
================================================
package interp
// Code generated by 'go run ../internal/cmd/genop/genop.go'. DO NOT EDIT.
import (
"go/constant"
"go/token"
"reflect"
)
// Arithmetic operators
func add(n *node) {
next := getExec(n.tnext)
typ := n.typ.concrete().TypeOf()
isInterface := n.typ.TypeOf().Kind() == reflect.Interface
dest := genValueOutput(n, typ)
c0, c1 := n.child[0], n.child[1]
switch typ.Kind() {
case reflect.String:
switch {
case isInterface:
v0 := genValue(c0)
v1 := genValue(c1)
n.exec = func(f *frame) bltn {
dest(f).Set(reflect.ValueOf(v0(f).String() + v1(f).String()).Convert(typ))
return next
}
case c0.rval.IsValid():
s0 := vString(c0.rval)
v1 := genValue(c1)
n.exec = func(f *frame) bltn {
dest(f).SetString(s0 + v1(f).String())
return next
}
case c1.rval.IsValid():
v0 := genValue(c0)
s1 := vString(c1.rval)
n.exec = func(f *frame) bltn {
dest(f).SetString(v0(f).String() + s1)
return next
}
default:
v0 := genValue(c0)
v1 := genValue(c1)
n.exec = func(f *frame) bltn {
dest(f).SetString(v0(f).String() + v1(f).String())
return next
}
}
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
switch {
case isInterface:
v0 := genValueInt(c0)
v1 := genValueInt(c1)
n.exec = func(f *frame) bltn {
_, i := v0(f)
_, j := v1(f)
dest(f).Set(reflect.ValueOf(i + j).Convert(typ))
return next
}
case c0.rval.IsValid():
i := vInt(c0.rval)
v1 := genValueInt(c1)
n.exec = func(f *frame) bltn {
_, j := v1(f)
dest(f).SetInt(i + j)
return next
}
case c1.rval.IsValid():
v0 := genValueInt(c0)
j := vInt(c1.rval)
n.exec = func(f *frame) bltn {
_, i := v0(f)
dest(f).SetInt(i + j)
return next
}
default:
v0 := genValueInt(c0)
v1 := genValueInt(c1)
n.exec = func(f *frame) bltn {
_, i := v0(f)
_, j := v1(f)
dest(f).SetInt(i + j)
return next
}
}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
switch {
case isInterface:
v0 := genValueUint(c0)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
_, i := v0(f)
_, j := v1(f)
dest(f).Set(reflect.ValueOf(i + j).Convert(typ))
return next
}
case c0.rval.IsValid():
i := vUint(c0.rval)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
_, j := v1(f)
dest(f).SetUint(i + j)
return next
}
case c1.rval.IsValid():
j := vUint(c1.rval)
v0 := genValueUint(c0)
n.exec = func(f *frame) bltn {
_, i := v0(f)
dest(f).SetUint(i + j)
return next
}
default:
v0 := genValueUint(c0)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
_, i := v0(f)
_, j := v1(f)
dest(f).SetUint(i + j)
return next
}
}
case reflect.Float32, reflect.Float64:
switch {
case isInterface:
v0 := genValueFloat(c0)
v1 := genValueFloat(c1)
n.exec = func(f *frame) bltn {
_, i := v0(f)
_, j := v1(f)
dest(f).Set(reflect.ValueOf(i + j).Convert(typ))
return next
}
case c0.rval.IsValid():
i := vFloat(c0.rval)
v1 := genValueFloat(c1)
n.exec = func(f *frame) bltn {
_, j := v1(f)
dest(f).SetFloat(i + j)
return next
}
case c1.rval.IsValid():
j := vFloat(c1.rval)
v0 := genValueFloat(c0)
n.exec = func(f *frame) bltn {
_, i := v0(f)
dest(f).SetFloat(i + j)
return next
}
default:
v0 := genValueFloat(c0)
v1 := genValueFloat(c1)
n.exec = func(f *frame) bltn {
_, i := v0(f)
_, j := v1(f)
dest(f).SetFloat(i + j)
return next
}
}
case reflect.Complex64, reflect.Complex128:
switch {
case isInterface:
v0 := genComplex(c0)
v1 := genComplex(c1)
n.exec = func(f *frame) bltn {
dest(f).Set(reflect.ValueOf(v0(f) + v1(f)).Convert(typ))
return next
}
case c0.rval.IsValid():
r0 := vComplex(c0.rval)
v1 := genComplex(c1)
n.exec = func(f *frame) bltn {
dest(f).SetComplex(r0 + v1(f))
return next
}
case c1.rval.IsValid():
r1 := vComplex(c1.rval)
v0 := genComplex(c0)
n.exec = func(f *frame) bltn {
dest(f).SetComplex(v0(f) + r1)
return next
}
default:
v0 := genComplex(c0)
v1 := genComplex(c1)
n.exec = func(f *frame) bltn {
dest(f).SetComplex(v0(f) + v1(f))
return next
}
}
}
}
func addConst(n *node) {
v0, v1 := n.child[0].rval, n.child[1].rval
isConst := (v0.IsValid() && isConstantValue(v0.Type())) && (v1.IsValid() && isConstantValue(v1.Type()))
t := n.typ.rtype
if isConst {
t = constVal
}
n.rval = reflect.New(t).Elem()
switch {
case isConst:
v := constant.BinaryOp(vConstantValue(v0), token.ADD, vConstantValue(v1))
n.rval.Set(reflect.ValueOf(v))
case isString(t):
n.rval.SetString(vString(v0) + vString(v1))
case isComplex(t):
n.rval.SetComplex(vComplex(v0) + vComplex(v1))
case isFloat(t):
n.rval.SetFloat(vFloat(v0) + vFloat(v1))
case isUint(t):
n.rval.SetUint(vUint(v0) + vUint(v1))
case isInt(t):
n.rval.SetInt(vInt(v0) + vInt(v1))
}
}
func and(n *node) {
next := getExec(n.tnext)
typ := n.typ.concrete().TypeOf()
isInterface := n.typ.TypeOf().Kind() == reflect.Interface
dest := genValueOutput(n, typ)
c0, c1 := n.child[0], n.child[1]
switch typ.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
switch {
case isInterface:
v0 := genValueInt(c0)
v1 := genValueInt(c1)
n.exec = func(f *frame) bltn {
_, i := v0(f)
_, j := v1(f)
dest(f).Set(reflect.ValueOf(i & j).Convert(typ))
return next
}
case c0.rval.IsValid():
i := vInt(c0.rval)
v1 := genValueInt(c1)
n.exec = func(f *frame) bltn {
_, j := v1(f)
dest(f).SetInt(i & j)
return next
}
case c1.rval.IsValid():
v0 := genValueInt(c0)
j := vInt(c1.rval)
n.exec = func(f *frame) bltn {
_, i := v0(f)
dest(f).SetInt(i & j)
return next
}
default:
v0 := genValueInt(c0)
v1 := genValueInt(c1)
n.exec = func(f *frame) bltn {
_, i := v0(f)
_, j := v1(f)
dest(f).SetInt(i & j)
return next
}
}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
switch {
case isInterface:
v0 := genValueUint(c0)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
_, i := v0(f)
_, j := v1(f)
dest(f).Set(reflect.ValueOf(i & j).Convert(typ))
return next
}
case c0.rval.IsValid():
i := vUint(c0.rval)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
_, j := v1(f)
dest(f).SetUint(i & j)
return next
}
case c1.rval.IsValid():
j := vUint(c1.rval)
v0 := genValueUint(c0)
n.exec = func(f *frame) bltn {
_, i := v0(f)
dest(f).SetUint(i & j)
return next
}
default:
v0 := genValueUint(c0)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
_, i := v0(f)
_, j := v1(f)
dest(f).SetUint(i & j)
return next
}
}
}
}
func andConst(n *node) {
v0, v1 := n.child[0].rval, n.child[1].rval
isConst := (v0.IsValid() && isConstantValue(v0.Type())) && (v1.IsValid() && isConstantValue(v1.Type()))
t := n.typ.rtype
if isConst {
t = constVal
}
n.rval = reflect.New(t).Elem()
switch {
case isConst:
v := constant.BinaryOp(constant.ToInt(vConstantValue(v0)), token.AND, constant.ToInt(vConstantValue(v1)))
n.rval.Set(reflect.ValueOf(v))
case isUint(t):
n.rval.SetUint(vUint(v0) & vUint(v1))
case isInt(t):
n.rval.SetInt(vInt(v0) & vInt(v1))
}
}
func andNot(n *node) {
next := getExec(n.tnext)
typ := n.typ.concrete().TypeOf()
isInterface := n.typ.TypeOf().Kind() == reflect.Interface
dest := genValueOutput(n, typ)
c0, c1 := n.child[0], n.child[1]
switch typ.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
switch {
case isInterface:
v0 := genValueInt(c0)
v1 := genValueInt(c1)
n.exec = func(f *frame) bltn {
_, i := v0(f)
_, j := v1(f)
dest(f).Set(reflect.ValueOf(i &^ j).Convert(typ))
return next
}
case c0.rval.IsValid():
i := vInt(c0.rval)
v1 := genValueInt(c1)
n.exec = func(f *frame) bltn {
_, j := v1(f)
dest(f).SetInt(i &^ j)
return next
}
case c1.rval.IsValid():
v0 := genValueInt(c0)
j := vInt(c1.rval)
n.exec = func(f *frame) bltn {
_, i := v0(f)
dest(f).SetInt(i &^ j)
return next
}
default:
v0 := genValueInt(c0)
v1 := genValueInt(c1)
n.exec = func(f *frame) bltn {
_, i := v0(f)
_, j := v1(f)
dest(f).SetInt(i &^ j)
return next
}
}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
switch {
case isInterface:
v0 := genValueUint(c0)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
_, i := v0(f)
_, j := v1(f)
dest(f).Set(reflect.ValueOf(i &^ j).Convert(typ))
return next
}
case c0.rval.IsValid():
i := vUint(c0.rval)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
_, j := v1(f)
dest(f).SetUint(i &^ j)
return next
}
case c1.rval.IsValid():
j := vUint(c1.rval)
v0 := genValueUint(c0)
n.exec = func(f *frame) bltn {
_, i := v0(f)
dest(f).SetUint(i &^ j)
return next
}
default:
v0 := genValueUint(c0)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
_, i := v0(f)
_, j := v1(f)
dest(f).SetUint(i &^ j)
return next
}
}
}
}
func andNotConst(n *node) {
v0, v1 := n.child[0].rval, n.child[1].rval
isConst := (v0.IsValid() && isConstantValue(v0.Type())) && (v1.IsValid() && isConstantValue(v1.Type()))
t := n.typ.rtype
if isConst {
t = constVal
}
n.rval = reflect.New(t).Elem()
switch {
case isConst:
v := constant.BinaryOp(constant.ToInt(vConstantValue(v0)), token.AND_NOT, constant.ToInt(vConstantValue(v1)))
n.rval.Set(reflect.ValueOf(v))
case isUint(t):
n.rval.SetUint(vUint(v0) &^ vUint(v1))
case isInt(t):
n.rval.SetInt(vInt(v0) &^ vInt(v1))
}
}
func mul(n *node) {
next := getExec(n.tnext)
typ := n.typ.concrete().TypeOf()
isInterface := n.typ.TypeOf().Kind() == reflect.Interface
dest := genValueOutput(n, typ)
c0, c1 := n.child[0], n.child[1]
switch typ.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
switch {
case isInterface:
v0 := genValueInt(c0)
v1 := genValueInt(c1)
n.exec = func(f *frame) bltn {
_, i := v0(f)
_, j := v1(f)
dest(f).Set(reflect.ValueOf(i * j).Convert(typ))
return next
}
case c0.rval.IsValid():
i := vInt(c0.rval)
v1 := genValueInt(c1)
n.exec = func(f *frame) bltn {
_, j := v1(f)
dest(f).SetInt(i * j)
return next
}
case c1.rval.IsValid():
v0 := genValueInt(c0)
j := vInt(c1.rval)
n.exec = func(f *frame) bltn {
_, i := v0(f)
dest(f).SetInt(i * j)
return next
}
default:
v0 := genValueInt(c0)
v1 := genValueInt(c1)
n.exec = func(f *frame) bltn {
_, i := v0(f)
_, j := v1(f)
dest(f).SetInt(i * j)
return next
}
}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
switch {
case isInterface:
v0 := genValueUint(c0)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
_, i := v0(f)
_, j := v1(f)
dest(f).Set(reflect.ValueOf(i * j).Convert(typ))
return next
}
case c0.rval.IsValid():
i := vUint(c0.rval)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
_, j := v1(f)
dest(f).SetUint(i * j)
return next
}
case c1.rval.IsValid():
j := vUint(c1.rval)
v0 := genValueUint(c0)
n.exec = func(f *frame) bltn {
_, i := v0(f)
dest(f).SetUint(i * j)
return next
}
default:
v0 := genValueUint(c0)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
_, i := v0(f)
_, j := v1(f)
dest(f).SetUint(i * j)
return next
}
}
case reflect.Float32, reflect.Float64:
switch {
case isInterface:
v0 := genValueFloat(c0)
v1 := genValueFloat(c1)
n.exec = func(f *frame) bltn {
_, i := v0(f)
_, j := v1(f)
dest(f).Set(reflect.ValueOf(i * j).Convert(typ))
return next
}
case c0.rval.IsValid():
i := vFloat(c0.rval)
v1 := genValueFloat(c1)
n.exec = func(f *frame) bltn {
_, j := v1(f)
dest(f).SetFloat(i * j)
return next
}
case c1.rval.IsValid():
j := vFloat(c1.rval)
v0 := genValueFloat(c0)
n.exec = func(f *frame) bltn {
_, i := v0(f)
dest(f).SetFloat(i * j)
return next
}
default:
v0 := genValueFloat(c0)
v1 := genValueFloat(c1)
n.exec = func(f *frame) bltn {
_, i := v0(f)
_, j := v1(f)
dest(f).SetFloat(i * j)
return next
}
}
case reflect.Complex64, reflect.Complex128:
switch {
case isInterface:
v0 := genComplex(c0)
v1 := genComplex(c1)
n.exec = func(f *frame) bltn {
dest(f).Set(reflect.ValueOf(v0(f) * v1(f)).Convert(typ))
return next
}
case c0.rval.IsValid():
r0 := vComplex(c0.rval)
v1 := genComplex(c1)
n.exec = func(f *frame) bltn {
dest(f).SetComplex(r0 * v1(f))
return next
}
case c1.rval.IsValid():
r1 := vComplex(c1.rval)
v0 := genComplex(c0)
n.exec = func(f *frame) bltn {
dest(f).SetComplex(v0(f) * r1)
return next
}
default:
v0 := genComplex(c0)
v1 := genComplex(c1)
n.exec = func(f *frame) bltn {
dest(f).SetComplex(v0(f) * v1(f))
return next
}
}
}
}
func mulConst(n *node) {
v0, v1 := n.child[0].rval, n.child[1].rval
isConst := (v0.IsValid() && isConstantValue(v0.Type())) && (v1.IsValid() && isConstantValue(v1.Type()))
t := n.typ.rtype
if isConst {
t = constVal
}
n.rval = reflect.New(t).Elem()
switch {
case isConst:
v := constant.BinaryOp(vConstantValue(v0), token.MUL, vConstantValue(v1))
n.rval.Set(reflect.ValueOf(v))
case isComplex(t):
n.rval.SetComplex(vComplex(v0) * vComplex(v1))
case isFloat(t):
n.rval.SetFloat(vFloat(v0) * vFloat(v1))
case isUint(t):
n.rval.SetUint(vUint(v0) * vUint(v1))
case isInt(t):
n.rval.SetInt(vInt(v0) * vInt(v1))
}
}
func or(n *node) {
next := getExec(n.tnext)
typ := n.typ.concrete().TypeOf()
isInterface := n.typ.TypeOf().Kind() == reflect.Interface
dest := genValueOutput(n, typ)
c0, c1 := n.child[0], n.child[1]
switch typ.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
switch {
case isInterface:
v0 := genValueInt(c0)
v1 := genValueInt(c1)
n.exec = func(f *frame) bltn {
_, i := v0(f)
_, j := v1(f)
dest(f).Set(reflect.ValueOf(i | j).Convert(typ))
return next
}
case c0.rval.IsValid():
i := vInt(c0.rval)
v1 := genValueInt(c1)
n.exec = func(f *frame) bltn {
_, j := v1(f)
dest(f).SetInt(i | j)
return next
}
case c1.rval.IsValid():
v0 := genValueInt(c0)
j := vInt(c1.rval)
n.exec = func(f *frame) bltn {
_, i := v0(f)
dest(f).SetInt(i | j)
return next
}
default:
v0 := genValueInt(c0)
v1 := genValueInt(c1)
n.exec = func(f *frame) bltn {
_, i := v0(f)
_, j := v1(f)
dest(f).SetInt(i | j)
return next
}
}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
switch {
case isInterface:
v0 := genValueUint(c0)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
_, i := v0(f)
_, j := v1(f)
dest(f).Set(reflect.ValueOf(i | j).Convert(typ))
return next
}
case c0.rval.IsValid():
i := vUint(c0.rval)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
_, j := v1(f)
dest(f).SetUint(i | j)
return next
}
case c1.rval.IsValid():
j := vUint(c1.rval)
v0 := genValueUint(c0)
n.exec = func(f *frame) bltn {
_, i := v0(f)
dest(f).SetUint(i | j)
return next
}
default:
v0 := genValueUint(c0)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
_, i := v0(f)
_, j := v1(f)
dest(f).SetUint(i | j)
return next
}
}
}
}
func orConst(n *node) {
v0, v1 := n.child[0].rval, n.child[1].rval
isConst := (v0.IsValid() && isConstantValue(v0.Type())) && (v1.IsValid() && isConstantValue(v1.Type()))
t := n.typ.rtype
if isConst {
t = constVal
}
n.rval = reflect.New(t).Elem()
switch {
case isConst:
v := constant.BinaryOp(constant.ToInt(vConstantValue(v0)), token.OR, constant.ToInt(vConstantValue(v1)))
n.rval.Set(reflect.ValueOf(v))
case isUint(t):
n.rval.SetUint(vUint(v0) | vUint(v1))
case isInt(t):
n.rval.SetInt(vInt(v0) | vInt(v1))
}
}
func quo(n *node) {
next := getExec(n.tnext)
typ := n.typ.concrete().TypeOf()
isInterface := n.typ.TypeOf().Kind() == reflect.Interface
dest := genValueOutput(n, typ)
c0, c1 := n.child[0], n.child[1]
switch typ.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
switch {
case isInterface:
v0 := genValueInt(c0)
v1 := genValueInt(c1)
n.exec = func(f *frame) bltn {
_, i := v0(f)
_, j := v1(f)
dest(f).Set(reflect.ValueOf(i / j).Convert(typ))
return next
}
case c0.rval.IsValid():
i := vInt(c0.rval)
v1 := genValueInt(c1)
n.exec = func(f *frame) bltn {
_, j := v1(f)
dest(f).SetInt(i / j)
return next
}
case c1.rval.IsValid():
v0 := genValueInt(c0)
j := vInt(c1.rval)
n.exec = func(f *frame) bltn {
_, i := v0(f)
dest(f).SetInt(i / j)
return next
}
default:
v0 := genValueInt(c0)
v1 := genValueInt(c1)
n.exec = func(f *frame) bltn {
_, i := v0(f)
_, j := v1(f)
dest(f).SetInt(i / j)
return next
}
}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
switch {
case isInterface:
v0 := genValueUint(c0)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
_, i := v0(f)
_, j := v1(f)
dest(f).Set(reflect.ValueOf(i / j).Convert(typ))
return next
}
case c0.rval.IsValid():
i := vUint(c0.rval)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
_, j := v1(f)
dest(f).SetUint(i / j)
return next
}
case c1.rval.IsValid():
j := vUint(c1.rval)
v0 := genValueUint(c0)
n.exec = func(f *frame) bltn {
_, i := v0(f)
dest(f).SetUint(i / j)
return next
}
default:
v0 := genValueUint(c0)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
_, i := v0(f)
_, j := v1(f)
dest(f).SetUint(i / j)
return next
}
}
case reflect.Float32, reflect.Float64:
switch {
case isInterface:
v0 := genValueFloat(c0)
v1 := genValueFloat(c1)
n.exec = func(f *frame) bltn {
_, i := v0(f)
_, j := v1(f)
dest(f).Set(reflect.ValueOf(i / j).Convert(typ))
return next
}
case c0.rval.IsValid():
i := vFloat(c0.rval)
v1 := genValueFloat(c1)
n.exec = func(f *frame) bltn {
_, j := v1(f)
dest(f).SetFloat(i / j)
return next
}
case c1.rval.IsValid():
j := vFloat(c1.rval)
v0 := genValueFloat(c0)
n.exec = func(f *frame) bltn {
_, i := v0(f)
dest(f).SetFloat(i / j)
return next
}
default:
v0 := genValueFloat(c0)
v1 := genValueFloat(c1)
n.exec = func(f *frame) bltn {
_, i := v0(f)
_, j := v1(f)
dest(f).SetFloat(i / j)
return next
}
}
case reflect.Complex64, reflect.Complex128:
switch {
case isInterface:
v0 := genComplex(c0)
v1 := genComplex(c1)
n.exec = func(f *frame) bltn {
dest(f).Set(reflect.ValueOf(v0(f) / v1(f)).Convert(typ))
return next
}
case c0.rval.IsValid():
r0 := vComplex(c0.rval)
v1 := genComplex(c1)
n.exec = func(f *frame) bltn {
dest(f).SetComplex(r0 / v1(f))
return next
}
case c1.rval.IsValid():
r1 := vComplex(c1.rval)
v0 := genComplex(c0)
n.exec = func(f *frame) bltn {
dest(f).SetComplex(v0(f) / r1)
return next
}
default:
v0 := genComplex(c0)
v1 := genComplex(c1)
n.exec = func(f *frame) bltn {
dest(f).SetComplex(v0(f) / v1(f))
return next
}
}
}
}
func quoConst(n *node) {
v0, v1 := n.child[0].rval, n.child[1].rval
isConst := (v0.IsValid() && isConstantValue(v0.Type())) && (v1.IsValid() && isConstantValue(v1.Type()))
t := n.typ.rtype
if isConst {
t = constVal
}
n.rval = reflect.New(t).Elem()
switch {
case isConst:
var operator token.Token
// When the result of the operation is expected to be an int (because both
// operands are ints), we want to force the type of the whole expression to be an
// int (and not a float), which is achieved by using the QUO_ASSIGN operator.
if n.typ.untyped && isInt(n.typ.rtype) {
operator = token.QUO_ASSIGN
} else {
operator = token.QUO
}
v := constant.BinaryOp(vConstantValue(v0), operator, vConstantValue(v1))
n.rval.Set(reflect.ValueOf(v))
case isComplex(t):
n.rval.SetComplex(vComplex(v0) / vComplex(v1))
case isFloat(t):
n.rval.SetFloat(vFloat(v0) / vFloat(v1))
case isUint(t):
n.rval.SetUint(vUint(v0) / vUint(v1))
case isInt(t):
n.rval.SetInt(vInt(v0) / vInt(v1))
}
}
func rem(n *node) {
next := getExec(n.tnext)
typ := n.typ.concrete().TypeOf()
isInterface := n.typ.TypeOf().Kind() == reflect.Interface
dest := genValueOutput(n, typ)
c0, c1 := n.child[0], n.child[1]
switch typ.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
switch {
case isInterface:
v0 := genValueInt(c0)
v1 := genValueInt(c1)
n.exec = func(f *frame) bltn {
_, i := v0(f)
_, j := v1(f)
dest(f).Set(reflect.ValueOf(i % j).Convert(typ))
return next
}
case c0.rval.IsValid():
i := vInt(c0.rval)
v1 := genValueInt(c1)
n.exec = func(f *frame) bltn {
_, j := v1(f)
dest(f).SetInt(i % j)
return next
}
case c1.rval.IsValid():
v0 := genValueInt(c0)
j := vInt(c1.rval)
n.exec = func(f *frame) bltn {
_, i := v0(f)
dest(f).SetInt(i % j)
return next
}
default:
v0 := genValueInt(c0)
v1 := genValueInt(c1)
n.exec = func(f *frame) bltn {
_, i := v0(f)
_, j := v1(f)
dest(f).SetInt(i % j)
return next
}
}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
switch {
case isInterface:
v0 := genValueUint(c0)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
_, i := v0(f)
_, j := v1(f)
dest(f).Set(reflect.ValueOf(i % j).Convert(typ))
return next
}
case c0.rval.IsValid():
i := vUint(c0.rval)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
_, j := v1(f)
dest(f).SetUint(i % j)
return next
}
case c1.rval.IsValid():
j := vUint(c1.rval)
v0 := genValueUint(c0)
n.exec = func(f *frame) bltn {
_, i := v0(f)
dest(f).SetUint(i % j)
return next
}
default:
v0 := genValueUint(c0)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
_, i := v0(f)
_, j := v1(f)
dest(f).SetUint(i % j)
return next
}
}
}
}
func remConst(n *node) {
v0, v1 := n.child[0].rval, n.child[1].rval
isConst := (v0.IsValid() && isConstantValue(v0.Type())) && (v1.IsValid() && isConstantValue(v1.Type()))
t := n.typ.rtype
if isConst {
t = constVal
}
n.rval = reflect.New(t).Elem()
switch {
case isConst:
v := constant.BinaryOp(constant.ToInt(vConstantValue(v0)), token.REM, constant.ToInt(vConstantValue(v1)))
n.rval.Set(reflect.ValueOf(v))
case isUint(t):
n.rval.SetUint(vUint(v0) % vUint(v1))
case isInt(t):
n.rval.SetInt(vInt(v0) % vInt(v1))
}
}
func shl(n *node) {
next := getExec(n.tnext)
typ := n.typ.concrete().TypeOf()
isInterface := n.typ.TypeOf().Kind() == reflect.Interface
dest := genValueOutput(n, typ)
c0, c1 := n.child[0], n.child[1]
switch typ.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
switch {
case isInterface:
v0 := genValueInt(c0)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
_, i := v0(f)
_, j := v1(f)
dest(f).Set(reflect.ValueOf(i << j).Convert(typ))
return next
}
case c0.rval.IsValid():
i := vInt(c0.rval)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
_, j := v1(f)
dest(f).SetInt(i << j)
return next
}
case c1.rval.IsValid():
v0 := genValueInt(c0)
j := vUint(c1.rval)
n.exec = func(f *frame) bltn {
_, i := v0(f)
dest(f).SetInt(i << j)
return next
}
default:
v0 := genValueInt(c0)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
_, i := v0(f)
_, j := v1(f)
dest(f).SetInt(i << j)
return next
}
}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
switch {
case isInterface:
v0 := genValueUint(c0)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
_, i := v0(f)
_, j := v1(f)
dest(f).Set(reflect.ValueOf(i << j).Convert(typ))
return next
}
case c0.rval.IsValid():
i := vUint(c0.rval)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
_, j := v1(f)
dest(f).SetUint(i << j)
return next
}
case c1.rval.IsValid():
j := vUint(c1.rval)
v0 := genValueUint(c0)
n.exec = func(f *frame) bltn {
_, i := v0(f)
dest(f).SetUint(i << j)
return next
}
default:
v0 := genValueUint(c0)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
_, i := v0(f)
_, j := v1(f)
dest(f).SetUint(i << j)
return next
}
}
}
}
func shlConst(n *node) {
v0, v1 := n.child[0].rval, n.child[1].rval
isConst := (v0.IsValid() && isConstantValue(v0.Type()))
t := n.typ.rtype
if isConst {
t = constVal
}
n.rval = reflect.New(t).Elem()
switch {
case isConst:
v := constant.Shift(vConstantValue(v0), token.SHL, uint(vUint(v1)))
n.rval.Set(reflect.ValueOf(v))
case isUint(t):
n.rval.SetUint(vUint(v0) << vUint(v1))
case isInt(t):
n.rval.SetInt(vInt(v0) << vUint(v1))
}
}
func shr(n *node) {
next := getExec(n.tnext)
typ := n.typ.concrete().TypeOf()
isInterface := n.typ.TypeOf().Kind() == reflect.Interface
dest := genValueOutput(n, typ)
c0, c1 := n.child[0], n.child[1]
switch typ.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
switch {
case isInterface:
v0 := genValueInt(c0)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
_, i := v0(f)
_, j := v1(f)
dest(f).Set(reflect.ValueOf(i >> j).Convert(typ))
return next
}
case c0.rval.IsValid():
i := vInt(c0.rval)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
_, j := v1(f)
dest(f).SetInt(i >> j)
return next
}
case c1.rval.IsValid():
v0 := genValueInt(c0)
j := vUint(c1.rval)
n.exec = func(f *frame) bltn {
_, i := v0(f)
dest(f).SetInt(i >> j)
return next
}
default:
v0 := genValueInt(c0)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
_, i := v0(f)
_, j := v1(f)
dest(f).SetInt(i >> j)
return next
}
}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
switch {
case isInterface:
v0 := genValueUint(c0)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
_, i := v0(f)
_, j := v1(f)
dest(f).Set(reflect.ValueOf(i >> j).Convert(typ))
return next
}
case c0.rval.IsValid():
i := vUint(c0.rval)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
_, j := v1(f)
dest(f).SetUint(i >> j)
return next
}
case c1.rval.IsValid():
j := vUint(c1.rval)
v0 := genValueUint(c0)
n.exec = func(f *frame) bltn {
_, i := v0(f)
dest(f).SetUint(i >> j)
return next
}
default:
v0 := genValueUint(c0)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
_, i := v0(f)
_, j := v1(f)
dest(f).SetUint(i >> j)
return next
}
}
}
}
func shrConst(n *node) {
v0, v1 := n.child[0].rval, n.child[1].rval
isConst := (v0.IsValid() && isConstantValue(v0.Type()))
t := n.typ.rtype
if isConst {
t = constVal
}
n.rval = reflect.New(t).Elem()
switch {
case isConst:
v := constant.Shift(vConstantValue(v0), token.SHR, uint(vUint(v1)))
n.rval.Set(reflect.ValueOf(v))
case isUint(t):
n.rval.SetUint(vUint(v0) >> vUint(v1))
case isInt(t):
n.rval.SetInt(vInt(v0) >> vUint(v1))
}
}
func sub(n *node) {
next := getExec(n.tnext)
typ := n.typ.concrete().TypeOf()
isInterface := n.typ.TypeOf().Kind() == reflect.Interface
dest := genValueOutput(n, typ)
c0, c1 := n.child[0], n.child[1]
switch typ.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
switch {
case isInterface:
v0 := genValueInt(c0)
v1 := genValueInt(c1)
n.exec = func(f *frame) bltn {
_, i := v0(f)
_, j := v1(f)
dest(f).Set(reflect.ValueOf(i - j).Convert(typ))
return next
}
case c0.rval.IsValid():
i := vInt(c0.rval)
v1 := genValueInt(c1)
n.exec = func(f *frame) bltn {
_, j := v1(f)
dest(f).SetInt(i - j)
return next
}
case c1.rval.IsValid():
v0 := genValueInt(c0)
j := vInt(c1.rval)
n.exec = func(f *frame) bltn {
_, i := v0(f)
dest(f).SetInt(i - j)
return next
}
default:
v0 := genValueInt(c0)
v1 := genValueInt(c1)
n.exec = func(f *frame) bltn {
_, i := v0(f)
_, j := v1(f)
dest(f).SetInt(i - j)
return next
}
}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
switch {
case isInterface:
v0 := genValueUint(c0)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
_, i := v0(f)
_, j := v1(f)
dest(f).Set(reflect.ValueOf(i - j).Convert(typ))
return next
}
case c0.rval.IsValid():
i := vUint(c0.rval)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
_, j := v1(f)
dest(f).SetUint(i - j)
return next
}
case c1.rval.IsValid():
j := vUint(c1.rval)
v0 := genValueUint(c0)
n.exec = func(f *frame) bltn {
_, i := v0(f)
dest(f).SetUint(i - j)
return next
}
default:
v0 := genValueUint(c0)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
_, i := v0(f)
_, j := v1(f)
dest(f).SetUint(i - j)
return next
}
}
case reflect.Float32, reflect.Float64:
switch {
case isInterface:
v0 := genValueFloat(c0)
v1 := genValueFloat(c1)
n.exec = func(f *frame) bltn {
_, i := v0(f)
_, j := v1(f)
dest(f).Set(reflect.ValueOf(i - j).Convert(typ))
return next
}
case c0.rval.IsValid():
i := vFloat(c0.rval)
v1 := genValueFloat(c1)
n.exec = func(f *frame) bltn {
_, j := v1(f)
dest(f).SetFloat(i - j)
return next
}
case c1.rval.IsValid():
j := vFloat(c1.rval)
v0 := genValueFloat(c0)
n.exec = func(f *frame) bltn {
_, i := v0(f)
dest(f).SetFloat(i - j)
return next
}
default:
v0 := genValueFloat(c0)
v1 := genValueFloat(c1)
n.exec = func(f *frame) bltn {
_, i := v0(f)
_, j := v1(f)
dest(f).SetFloat(i - j)
return next
}
}
case reflect.Complex64, reflect.Complex128:
switch {
case isInterface:
v0 := genComplex(c0)
v1 := genComplex(c1)
n.exec = func(f *frame) bltn {
dest(f).Set(reflect.ValueOf(v0(f) - v1(f)).Convert(typ))
return next
}
case c0.rval.IsValid():
r0 := vComplex(c0.rval)
v1 := genComplex(c1)
n.exec = func(f *frame) bltn {
dest(f).SetComplex(r0 - v1(f))
return next
}
case c1.rval.IsValid():
r1 := vComplex(c1.rval)
v0 := genComplex(c0)
n.exec = func(f *frame) bltn {
dest(f).SetComplex(v0(f) - r1)
return next
}
default:
v0 := genComplex(c0)
v1 := genComplex(c1)
n.exec = func(f *frame) bltn {
dest(f).SetComplex(v0(f) - v1(f))
return next
}
}
}
}
func subConst(n *node) {
v0, v1 := n.child[0].rval, n.child[1].rval
isConst := (v0.IsValid() && isConstantValue(v0.Type())) && (v1.IsValid() && isConstantValue(v1.Type()))
t := n.typ.rtype
if isConst {
t = constVal
}
n.rval = reflect.New(t).Elem()
switch {
case isConst:
v := constant.BinaryOp(vConstantValue(v0), token.SUB, vConstantValue(v1))
n.rval.Set(reflect.ValueOf(v))
case isComplex(t):
n.rval.SetComplex(vComplex(v0) - vComplex(v1))
case isFloat(t):
n.rval.SetFloat(vFloat(v0) - vFloat(v1))
case isUint(t):
n.rval.SetUint(vUint(v0) - vUint(v1))
case isInt(t):
n.rval.SetInt(vInt(v0) - vInt(v1))
}
}
func xor(n *node) {
next := getExec(n.tnext)
typ := n.typ.concrete().TypeOf()
isInterface := n.typ.TypeOf().Kind() == reflect.Interface
dest := genValueOutput(n, typ)
c0, c1 := n.child[0], n.child[1]
switch typ.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
switch {
case isInterface:
v0 := genValueInt(c0)
v1 := genValueInt(c1)
n.exec = func(f *frame) bltn {
_, i := v0(f)
_, j := v1(f)
dest(f).Set(reflect.ValueOf(i ^ j).Convert(typ))
return next
}
case c0.rval.IsValid():
i := vInt(c0.rval)
v1 := genValueInt(c1)
n.exec = func(f *frame) bltn {
_, j := v1(f)
dest(f).SetInt(i ^ j)
return next
}
case c1.rval.IsValid():
v0 := genValueInt(c0)
j := vInt(c1.rval)
n.exec = func(f *frame) bltn {
_, i := v0(f)
dest(f).SetInt(i ^ j)
return next
}
default:
v0 := genValueInt(c0)
v1 := genValueInt(c1)
n.exec = func(f *frame) bltn {
_, i := v0(f)
_, j := v1(f)
dest(f).SetInt(i ^ j)
return next
}
}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
switch {
case isInterface:
v0 := genValueUint(c0)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
_, i := v0(f)
_, j := v1(f)
dest(f).Set(reflect.ValueOf(i ^ j).Convert(typ))
return next
}
case c0.rval.IsValid():
i := vUint(c0.rval)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
_, j := v1(f)
dest(f).SetUint(i ^ j)
return next
}
case c1.rval.IsValid():
j := vUint(c1.rval)
v0 := genValueUint(c0)
n.exec = func(f *frame) bltn {
_, i := v0(f)
dest(f).SetUint(i ^ j)
return next
}
default:
v0 := genValueUint(c0)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
_, i := v0(f)
_, j := v1(f)
dest(f).SetUint(i ^ j)
return next
}
}
}
}
func xorConst(n *node) {
v0, v1 := n.child[0].rval, n.child[1].rval
isConst := (v0.IsValid() && isConstantValue(v0.Type())) && (v1.IsValid() && isConstantValue(v1.Type()))
t := n.typ.rtype
if isConst {
t = constVal
}
n.rval = reflect.New(t).Elem()
switch {
case isConst:
v := constant.BinaryOp(constant.ToInt(vConstantValue(v0)), token.XOR, constant.ToInt(vConstantValue(v1)))
n.rval.Set(reflect.ValueOf(v))
case isUint(t):
n.rval.SetUint(vUint(v0) ^ vUint(v1))
case isInt(t):
n.rval.SetInt(vInt(v0) ^ vInt(v1))
}
}
// Assign operators
func addAssign(n *node) {
next := getExec(n.tnext)
typ := n.typ.TypeOf()
c0, c1 := n.child[0], n.child[1]
setMap := isMapEntry(c0)
var mapValue, indexValue func(*frame) reflect.Value
if setMap {
mapValue = genValue(c0.child[0])
indexValue = genValue(c0.child[1])
}
if c1.rval.IsValid() {
switch typ.Kind() {
case reflect.String:
v0 := genValueString(c0)
v1 := vString(c1.rval)
n.exec = func(f *frame) bltn {
v, s := v0(f)
v.SetString(s + v1)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
v0 := genValueInt(c0)
j := vInt(c1.rval)
n.exec = func(f *frame) bltn {
v, i := v0(f)
v.SetInt(i + j)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
v0 := genValueUint(c0)
j := vUint(c1.rval)
n.exec = func(f *frame) bltn {
v, i := v0(f)
v.SetUint(i + j)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
case reflect.Float32, reflect.Float64:
v0 := genValueFloat(c0)
j := vFloat(c1.rval)
n.exec = func(f *frame) bltn {
v, i := v0(f)
v.SetFloat(i + j)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
case reflect.Complex64, reflect.Complex128:
v0 := genValue(c0)
v1 := vComplex(c1.rval)
n.exec = func(f *frame) bltn {
v := v0(f)
v.SetComplex(v.Complex() + v1)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
}
} else {
switch typ.Kind() {
case reflect.String:
v0 := genValueString(c0)
v1 := genValue(c1)
n.exec = func(f *frame) bltn {
v, s := v0(f)
v.SetString(s + v1(f).String())
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
v0 := genValueInt(c0)
v1 := genValueInt(c1)
n.exec = func(f *frame) bltn {
v, i := v0(f)
_, j := v1(f)
v.SetInt(i + j)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
v0 := genValueUint(c0)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
v, i := v0(f)
_, j := v1(f)
v.SetUint(i + j)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
case reflect.Float32, reflect.Float64:
v0 := genValueFloat(c0)
v1 := genValueFloat(c1)
n.exec = func(f *frame) bltn {
v, i := v0(f)
_, j := v1(f)
v.SetFloat(i + j)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
case reflect.Complex64, reflect.Complex128:
v0 := genValue(c0)
v1 := genValue(c1)
n.exec = func(f *frame) bltn {
v := v0(f)
v.SetComplex(v.Complex() + v1(f).Complex())
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
}
}
}
func andAssign(n *node) {
next := getExec(n.tnext)
typ := n.typ.TypeOf()
c0, c1 := n.child[0], n.child[1]
setMap := isMapEntry(c0)
var mapValue, indexValue func(*frame) reflect.Value
if setMap {
mapValue = genValue(c0.child[0])
indexValue = genValue(c0.child[1])
}
if c1.rval.IsValid() {
switch typ.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
v0 := genValueInt(c0)
j := vInt(c1.rval)
n.exec = func(f *frame) bltn {
v, i := v0(f)
v.SetInt(i & j)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
v0 := genValueUint(c0)
j := vUint(c1.rval)
n.exec = func(f *frame) bltn {
v, i := v0(f)
v.SetUint(i & j)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
}
} else {
switch typ.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
v0 := genValueInt(c0)
v1 := genValueInt(c1)
n.exec = func(f *frame) bltn {
v, i := v0(f)
_, j := v1(f)
v.SetInt(i & j)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
v0 := genValueUint(c0)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
v, i := v0(f)
_, j := v1(f)
v.SetUint(i & j)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
}
}
}
func andNotAssign(n *node) {
next := getExec(n.tnext)
typ := n.typ.TypeOf()
c0, c1 := n.child[0], n.child[1]
setMap := isMapEntry(c0)
var mapValue, indexValue func(*frame) reflect.Value
if setMap {
mapValue = genValue(c0.child[0])
indexValue = genValue(c0.child[1])
}
if c1.rval.IsValid() {
switch typ.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
v0 := genValueInt(c0)
j := vInt(c1.rval)
n.exec = func(f *frame) bltn {
v, i := v0(f)
v.SetInt(i &^ j)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
v0 := genValueUint(c0)
j := vUint(c1.rval)
n.exec = func(f *frame) bltn {
v, i := v0(f)
v.SetUint(i &^ j)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
}
} else {
switch typ.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
v0 := genValueInt(c0)
v1 := genValueInt(c1)
n.exec = func(f *frame) bltn {
v, i := v0(f)
_, j := v1(f)
v.SetInt(i &^ j)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
v0 := genValueUint(c0)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
v, i := v0(f)
_, j := v1(f)
v.SetUint(i &^ j)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
}
}
}
func mulAssign(n *node) {
next := getExec(n.tnext)
typ := n.typ.TypeOf()
c0, c1 := n.child[0], n.child[1]
setMap := isMapEntry(c0)
var mapValue, indexValue func(*frame) reflect.Value
if setMap {
mapValue = genValue(c0.child[0])
indexValue = genValue(c0.child[1])
}
if c1.rval.IsValid() {
switch typ.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
v0 := genValueInt(c0)
j := vInt(c1.rval)
n.exec = func(f *frame) bltn {
v, i := v0(f)
v.SetInt(i * j)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
v0 := genValueUint(c0)
j := vUint(c1.rval)
n.exec = func(f *frame) bltn {
v, i := v0(f)
v.SetUint(i * j)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
case reflect.Float32, reflect.Float64:
v0 := genValueFloat(c0)
j := vFloat(c1.rval)
n.exec = func(f *frame) bltn {
v, i := v0(f)
v.SetFloat(i * j)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
case reflect.Complex64, reflect.Complex128:
v0 := genValue(c0)
v1 := vComplex(c1.rval)
n.exec = func(f *frame) bltn {
v := v0(f)
v.SetComplex(v.Complex() * v1)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
}
} else {
switch typ.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
v0 := genValueInt(c0)
v1 := genValueInt(c1)
n.exec = func(f *frame) bltn {
v, i := v0(f)
_, j := v1(f)
v.SetInt(i * j)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
v0 := genValueUint(c0)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
v, i := v0(f)
_, j := v1(f)
v.SetUint(i * j)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
case reflect.Float32, reflect.Float64:
v0 := genValueFloat(c0)
v1 := genValueFloat(c1)
n.exec = func(f *frame) bltn {
v, i := v0(f)
_, j := v1(f)
v.SetFloat(i * j)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
case reflect.Complex64, reflect.Complex128:
v0 := genValue(c0)
v1 := genValue(c1)
n.exec = func(f *frame) bltn {
v := v0(f)
v.SetComplex(v.Complex() * v1(f).Complex())
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
}
}
}
func orAssign(n *node) {
next := getExec(n.tnext)
typ := n.typ.TypeOf()
c0, c1 := n.child[0], n.child[1]
setMap := isMapEntry(c0)
var mapValue, indexValue func(*frame) reflect.Value
if setMap {
mapValue = genValue(c0.child[0])
indexValue = genValue(c0.child[1])
}
if c1.rval.IsValid() {
switch typ.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
v0 := genValueInt(c0)
j := vInt(c1.rval)
n.exec = func(f *frame) bltn {
v, i := v0(f)
v.SetInt(i | j)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
v0 := genValueUint(c0)
j := vUint(c1.rval)
n.exec = func(f *frame) bltn {
v, i := v0(f)
v.SetUint(i | j)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
}
} else {
switch typ.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
v0 := genValueInt(c0)
v1 := genValueInt(c1)
n.exec = func(f *frame) bltn {
v, i := v0(f)
_, j := v1(f)
v.SetInt(i | j)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
v0 := genValueUint(c0)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
v, i := v0(f)
_, j := v1(f)
v.SetUint(i | j)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
}
}
}
func quoAssign(n *node) {
next := getExec(n.tnext)
typ := n.typ.TypeOf()
c0, c1 := n.child[0], n.child[1]
setMap := isMapEntry(c0)
var mapValue, indexValue func(*frame) reflect.Value
if setMap {
mapValue = genValue(c0.child[0])
indexValue = genValue(c0.child[1])
}
if c1.rval.IsValid() {
switch typ.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
v0 := genValueInt(c0)
j := vInt(c1.rval)
n.exec = func(f *frame) bltn {
v, i := v0(f)
v.SetInt(i / j)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
v0 := genValueUint(c0)
j := vUint(c1.rval)
n.exec = func(f *frame) bltn {
v, i := v0(f)
v.SetUint(i / j)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
case reflect.Float32, reflect.Float64:
v0 := genValueFloat(c0)
j := vFloat(c1.rval)
n.exec = func(f *frame) bltn {
v, i := v0(f)
v.SetFloat(i / j)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
case reflect.Complex64, reflect.Complex128:
v0 := genValue(c0)
v1 := vComplex(c1.rval)
n.exec = func(f *frame) bltn {
v := v0(f)
v.SetComplex(v.Complex() / v1)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
}
} else {
switch typ.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
v0 := genValueInt(c0)
v1 := genValueInt(c1)
n.exec = func(f *frame) bltn {
v, i := v0(f)
_, j := v1(f)
v.SetInt(i / j)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
v0 := genValueUint(c0)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
v, i := v0(f)
_, j := v1(f)
v.SetUint(i / j)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
case reflect.Float32, reflect.Float64:
v0 := genValueFloat(c0)
v1 := genValueFloat(c1)
n.exec = func(f *frame) bltn {
v, i := v0(f)
_, j := v1(f)
v.SetFloat(i / j)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
case reflect.Complex64, reflect.Complex128:
v0 := genValue(c0)
v1 := genValue(c1)
n.exec = func(f *frame) bltn {
v := v0(f)
v.SetComplex(v.Complex() / v1(f).Complex())
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
}
}
}
func remAssign(n *node) {
next := getExec(n.tnext)
typ := n.typ.TypeOf()
c0, c1 := n.child[0], n.child[1]
setMap := isMapEntry(c0)
var mapValue, indexValue func(*frame) reflect.Value
if setMap {
mapValue = genValue(c0.child[0])
indexValue = genValue(c0.child[1])
}
if c1.rval.IsValid() {
switch typ.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
v0 := genValueInt(c0)
j := vInt(c1.rval)
n.exec = func(f *frame) bltn {
v, i := v0(f)
v.SetInt(i % j)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
v0 := genValueUint(c0)
j := vUint(c1.rval)
n.exec = func(f *frame) bltn {
v, i := v0(f)
v.SetUint(i % j)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
}
} else {
switch typ.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
v0 := genValueInt(c0)
v1 := genValueInt(c1)
n.exec = func(f *frame) bltn {
v, i := v0(f)
_, j := v1(f)
v.SetInt(i % j)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
v0 := genValueUint(c0)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
v, i := v0(f)
_, j := v1(f)
v.SetUint(i % j)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
}
}
}
func shlAssign(n *node) {
next := getExec(n.tnext)
typ := n.typ.TypeOf()
c0, c1 := n.child[0], n.child[1]
setMap := isMapEntry(c0)
var mapValue, indexValue func(*frame) reflect.Value
if setMap {
mapValue = genValue(c0.child[0])
indexValue = genValue(c0.child[1])
}
if c1.rval.IsValid() {
switch typ.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
v0 := genValueInt(c0)
j := vUint(c1.rval)
n.exec = func(f *frame) bltn {
v, i := v0(f)
v.SetInt(i << j)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
v0 := genValueUint(c0)
j := vUint(c1.rval)
n.exec = func(f *frame) bltn {
v, i := v0(f)
v.SetUint(i << j)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
}
} else {
switch typ.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
v0 := genValueInt(c0)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
v, i := v0(f)
_, j := v1(f)
v.SetInt(i << j)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
v0 := genValueUint(c0)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
v, i := v0(f)
_, j := v1(f)
v.SetUint(i << j)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
}
}
}
func shrAssign(n *node) {
next := getExec(n.tnext)
typ := n.typ.TypeOf()
c0, c1 := n.child[0], n.child[1]
setMap := isMapEntry(c0)
var mapValue, indexValue func(*frame) reflect.Value
if setMap {
mapValue = genValue(c0.child[0])
indexValue = genValue(c0.child[1])
}
if c1.rval.IsValid() {
switch typ.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
v0 := genValueInt(c0)
j := vUint(c1.rval)
n.exec = func(f *frame) bltn {
v, i := v0(f)
v.SetInt(i >> j)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
v0 := genValueUint(c0)
j := vUint(c1.rval)
n.exec = func(f *frame) bltn {
v, i := v0(f)
v.SetUint(i >> j)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
}
} else {
switch typ.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
v0 := genValueInt(c0)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
v, i := v0(f)
_, j := v1(f)
v.SetInt(i >> j)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
v0 := genValueUint(c0)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
v, i := v0(f)
_, j := v1(f)
v.SetUint(i >> j)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
}
}
}
func subAssign(n *node) {
next := getExec(n.tnext)
typ := n.typ.TypeOf()
c0, c1 := n.child[0], n.child[1]
setMap := isMapEntry(c0)
var mapValue, indexValue func(*frame) reflect.Value
if setMap {
mapValue = genValue(c0.child[0])
indexValue = genValue(c0.child[1])
}
if c1.rval.IsValid() {
switch typ.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
v0 := genValueInt(c0)
j := vInt(c1.rval)
n.exec = func(f *frame) bltn {
v, i := v0(f)
v.SetInt(i - j)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
v0 := genValueUint(c0)
j := vUint(c1.rval)
n.exec = func(f *frame) bltn {
v, i := v0(f)
v.SetUint(i - j)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
case reflect.Float32, reflect.Float64:
v0 := genValueFloat(c0)
j := vFloat(c1.rval)
n.exec = func(f *frame) bltn {
v, i := v0(f)
v.SetFloat(i - j)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
case reflect.Complex64, reflect.Complex128:
v0 := genValue(c0)
v1 := vComplex(c1.rval)
n.exec = func(f *frame) bltn {
v := v0(f)
v.SetComplex(v.Complex() - v1)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
}
} else {
switch typ.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
v0 := genValueInt(c0)
v1 := genValueInt(c1)
n.exec = func(f *frame) bltn {
v, i := v0(f)
_, j := v1(f)
v.SetInt(i - j)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
v0 := genValueUint(c0)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
v, i := v0(f)
_, j := v1(f)
v.SetUint(i - j)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
case reflect.Float32, reflect.Float64:
v0 := genValueFloat(c0)
v1 := genValueFloat(c1)
n.exec = func(f *frame) bltn {
v, i := v0(f)
_, j := v1(f)
v.SetFloat(i - j)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
case reflect.Complex64, reflect.Complex128:
v0 := genValue(c0)
v1 := genValue(c1)
n.exec = func(f *frame) bltn {
v := v0(f)
v.SetComplex(v.Complex() - v1(f).Complex())
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
}
}
}
func xorAssign(n *node) {
next := getExec(n.tnext)
typ := n.typ.TypeOf()
c0, c1 := n.child[0], n.child[1]
setMap := isMapEntry(c0)
var mapValue, indexValue func(*frame) reflect.Value
if setMap {
mapValue = genValue(c0.child[0])
indexValue = genValue(c0.child[1])
}
if c1.rval.IsValid() {
switch typ.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
v0 := genValueInt(c0)
j := vInt(c1.rval)
n.exec = func(f *frame) bltn {
v, i := v0(f)
v.SetInt(i ^ j)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
v0 := genValueUint(c0)
j := vUint(c1.rval)
n.exec = func(f *frame) bltn {
v, i := v0(f)
v.SetUint(i ^ j)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
}
} else {
switch typ.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
v0 := genValueInt(c0)
v1 := genValueInt(c1)
n.exec = func(f *frame) bltn {
v, i := v0(f)
_, j := v1(f)
v.SetInt(i ^ j)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
v0 := genValueUint(c0)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
v, i := v0(f)
_, j := v1(f)
v.SetUint(i ^ j)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
}
}
}
func dec(n *node) {
next := getExec(n.tnext)
typ := n.typ.TypeOf()
c0 := n.child[0]
setMap := isMapEntry(c0)
var mapValue, indexValue func(*frame) reflect.Value
if setMap {
mapValue = genValue(c0.child[0])
indexValue = genValue(c0.child[1])
}
switch typ.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
v0 := genValueInt(c0)
n.exec = func(f *frame) bltn {
v, i := v0(f)
v.SetInt(i - 1)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
v0 := genValueUint(c0)
n.exec = func(f *frame) bltn {
v, i := v0(f)
v.SetUint(i - 1)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
case reflect.Float32, reflect.Float64:
v0 := genValueFloat(c0)
n.exec = func(f *frame) bltn {
v, i := v0(f)
v.SetFloat(i - 1)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
case reflect.Complex64, reflect.Complex128:
v0 := genValue(c0)
n.exec = func(f *frame) bltn {
v := v0(f)
v.SetComplex(v.Complex() - 1)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
}
}
func inc(n *node) {
next := getExec(n.tnext)
typ := n.typ.TypeOf()
c0 := n.child[0]
setMap := isMapEntry(c0)
var mapValue, indexValue func(*frame) reflect.Value
if setMap {
mapValue = genValue(c0.child[0])
indexValue = genValue(c0.child[1])
}
switch typ.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
v0 := genValueInt(c0)
n.exec = func(f *frame) bltn {
v, i := v0(f)
v.SetInt(i + 1)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
v0 := genValueUint(c0)
n.exec = func(f *frame) bltn {
v, i := v0(f)
v.SetUint(i + 1)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
case reflect.Float32, reflect.Float64:
v0 := genValueFloat(c0)
n.exec = func(f *frame) bltn {
v, i := v0(f)
v.SetFloat(i + 1)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
case reflect.Complex64, reflect.Complex128:
v0 := genValue(c0)
n.exec = func(f *frame) bltn {
v := v0(f)
v.SetComplex(v.Complex() + 1)
if setMap {
mapValue(f).SetMapIndex(indexValue(f), v)
}
return next
}
}
}
func bitNotConst(n *node) {
v0 := n.child[0].rval
isConst := v0.IsValid() && isConstantValue(v0.Type())
t := n.typ.rtype
if isConst {
t = constVal
}
n.rval = reflect.New(t).Elem()
switch {
case isConst:
v := constant.UnaryOp(token.XOR, vConstantValue(v0), 0)
n.rval.Set(reflect.ValueOf(v))
case isUint(t):
n.rval.SetUint(^v0.Uint())
case isInt(t):
n.rval.SetInt(^v0.Int())
}
}
func negConst(n *node) {
v0 := n.child[0].rval
isConst := v0.IsValid() && isConstantValue(v0.Type())
t := n.typ.rtype
if isConst {
t = constVal
}
n.rval = reflect.New(t).Elem()
switch {
case isConst:
v := constant.UnaryOp(token.SUB, vConstantValue(v0), 0)
n.rval.Set(reflect.ValueOf(v))
case isUint(t):
n.rval.SetUint(-v0.Uint())
case isInt(t):
n.rval.SetInt(-v0.Int())
case isFloat(t):
n.rval.SetFloat(-v0.Float())
case isComplex(t):
n.rval.SetComplex(-v0.Complex())
}
}
func notConst(n *node) {
v0 := n.child[0].rval
isConst := v0.IsValid() && isConstantValue(v0.Type())
t := n.typ.rtype
if isConst {
t = constVal
}
n.rval = reflect.New(t).Elem()
if isConst {
v := constant.UnaryOp(token.NOT, vConstantValue(v0), 0)
n.rval.Set(reflect.ValueOf(v))
} else {
n.rval.SetBool(!v0.Bool())
}
}
func posConst(n *node) {
v0 := n.child[0].rval
isConst := v0.IsValid() && isConstantValue(v0.Type())
t := n.typ.rtype
if isConst {
t = constVal
}
n.rval = reflect.New(t).Elem()
switch {
case isConst:
v := constant.UnaryOp(token.ADD, vConstantValue(v0), 0)
n.rval.Set(reflect.ValueOf(v))
case isUint(t):
n.rval.SetUint(+v0.Uint())
case isInt(t):
n.rval.SetInt(+v0.Int())
case isFloat(t):
n.rval.SetFloat(+v0.Float())
case isComplex(t):
n.rval.SetComplex(+v0.Complex())
}
}
func equal(n *node) {
tnext := getExec(n.tnext)
dest := genValueOutput(n, reflect.TypeOf(true))
typ := n.typ.concrete().TypeOf()
isInterface := n.typ.TypeOf().Kind() == reflect.Interface
c0, c1 := n.child[0], n.child[1]
t0, t1 := c0.typ.TypeOf(), c1.typ.TypeOf()
if c0.typ.cat == linkedT || c1.typ.cat == linkedT {
switch {
case isInterface:
v0 := genValue(c0)
v1 := genValue(c1)
dest := genValue(n)
n.exec = func(f *frame) bltn {
i0 := v0(f).Interface()
i1 := v1(f).Interface()
dest(f).Set(reflect.ValueOf(i0 == i1).Convert(typ))
return tnext
}
case c0.rval.IsValid():
i0 := c0.rval.Interface()
v1 := genValue(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
i1 := v1(f).Interface()
if i0 == i1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
i1 := v1(f).Interface()
dest(f).SetBool(i0 == i1)
return tnext
}
}
case c1.rval.IsValid():
i1 := c1.rval.Interface()
v0 := genValue(c0)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
i0 := v0(f).Interface()
if i0 == i1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
i0 := v0(f).Interface()
dest(f).SetBool(i0 == i1)
return tnext
}
}
default:
v0 := genValue(c0)
v1 := genValue(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
i0 := v0(f).Interface()
i1 := v1(f).Interface()
if i0 == i1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
i0 := v0(f).Interface()
i1 := v1(f).Interface()
dest(f).SetBool(i0 == i1)
return tnext
}
}
}
return
}
// Do not attempt to optimize '==' or '!=' if an operand is an interface.
// This will preserve proper dynamic type checking at runtime. For static types,
// type checks are already performed, so bypass them if possible.
if t0.Kind() == reflect.Interface || t1.Kind() == reflect.Interface {
v0 := genValue(c0)
v1 := genValue(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
i0 := v0(f).Interface()
i1 := v1(f).Interface()
if i0 == i1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
i0 := v0(f).Interface()
i1 := v1(f).Interface()
dest(f).SetBool(i0 == i1)
return tnext
}
}
return
}
switch {
case isString(t0) || isString(t1):
switch {
case isInterface:
v0 := genValueString(c0)
v1 := genValueString(c1)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
dest(f).Set(reflect.ValueOf(s0 == s1).Convert(typ))
return tnext
}
case c0.rval.IsValid():
s0 := vString(c0.rval)
v1 := genValueString(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s1 := v1(f)
if s0 == s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
n.exec = func(f *frame) bltn {
_, s1 := v1(f)
dest(f).SetBool(s0 == s1)
return tnext
}
}
case c1.rval.IsValid():
s1 := vString(c1.rval)
v0 := genValueString(c0)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
if s0 == s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
dest(f).SetBool(s0 == s1)
return tnext
}
}
default:
v0 := genValueString(c0)
v1 := genValueString(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
if s0 == s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
dest(f).SetBool(s0 == s1)
return tnext
}
}
}
case isFloat(t0) || isFloat(t1):
switch {
case isInterface:
v0 := genValueFloat(c0)
v1 := genValueFloat(c1)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
dest(f).Set(reflect.ValueOf(s0 == s1).Convert(typ))
return tnext
}
case c0.rval.IsValid():
s0 := vFloat(c0.rval)
v1 := genValueFloat(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s1 := v1(f)
if s0 == s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
n.exec = func(f *frame) bltn {
_, s1 := v1(f)
dest(f).SetBool(s0 == s1)
return tnext
}
}
case c1.rval.IsValid():
s1 := vFloat(c1.rval)
v0 := genValueFloat(c0)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
if s0 == s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
dest(f).SetBool(s0 == s1)
return tnext
}
}
default:
v0 := genValueFloat(c0)
v1 := genValueFloat(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
if s0 == s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
dest(f).SetBool(s0 == s1)
return tnext
}
}
}
case isUint(t0) || isUint(t1):
switch {
case isInterface:
v0 := genValueUint(c0)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
dest(f).Set(reflect.ValueOf(s0 == s1).Convert(typ))
return tnext
}
case c0.rval.IsValid():
s0 := vUint(c0.rval)
v1 := genValueUint(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s1 := v1(f)
if s0 == s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
_, s1 := v1(f)
dest(f).SetBool(s0 == s1)
return tnext
}
}
case c1.rval.IsValid():
s1 := vUint(c1.rval)
v0 := genValueUint(c0)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
if s0 == s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
dest(f).SetBool(s0 == s1)
return tnext
}
}
default:
v0 := genValueUint(c0)
v1 := genValueUint(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
if s0 == s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
dest(f).SetBool(s0 == s1)
return tnext
}
}
}
case isInt(t0) || isInt(t1):
switch {
case isInterface:
v0 := genValueInt(c0)
v1 := genValueInt(c1)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
dest(f).Set(reflect.ValueOf(s0 == s1).Convert(typ))
return tnext
}
case c0.rval.IsValid():
s0 := vInt(c0.rval)
v1 := genValueInt(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s1 := v1(f)
if s0 == s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
_, s1 := v1(f)
dest(f).SetBool(s0 == s1)
return tnext
}
}
case c1.rval.IsValid():
s1 := vInt(c1.rval)
v0 := genValueInt(c0)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
if s0 == s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
dest(f).SetBool(s0 == s1)
return tnext
}
}
default:
v0 := genValueInt(c0)
v1 := genValueInt(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
if s0 == s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
dest(f).SetBool(s0 == s1)
return tnext
}
}
}
case isComplex(t0) || isComplex(t1):
switch {
case isInterface:
v0 := genComplex(c0)
v1 := genComplex(c1)
n.exec = func(f *frame) bltn {
s0 := v0(f)
s1 := v1(f)
dest(f).Set(reflect.ValueOf(s0 == s1).Convert(typ))
return tnext
}
case c0.rval.IsValid():
s0 := vComplex(c0.rval)
v1 := genComplex(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
s1 := v1(f)
if s0 == s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
n.exec = func(f *frame) bltn {
s1 := v1(f)
dest(f).SetBool(s0 == s1)
return tnext
}
}
case c1.rval.IsValid():
s1 := vComplex(c1.rval)
v0 := genComplex(c0)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
s0 := v0(f)
if s0 == s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
s0 := v0(f)
dest(f).SetBool(s0 == s1)
return tnext
}
}
default:
v0 := genComplex(c0)
v1 := genComplex(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
s0 := v0(f)
s1 := v1(f)
if s0 == s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
n.exec = func(f *frame) bltn {
s0 := v0(f)
s1 := v1(f)
dest(f).SetBool(s0 == s1)
return tnext
}
}
}
default:
switch {
case isInterface:
v0 := genValue(c0)
v1 := genValue(c1)
n.exec = func(f *frame) bltn {
i0 := v0(f).Interface()
i1 := v1(f).Interface()
dest(f).Set(reflect.ValueOf(i0 == i1).Convert(typ))
return tnext
}
case c0.rval.IsValid():
i0 := c0.rval.Interface()
v1 := genValue(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
i1 := v1(f).Interface()
if i0 == i1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
i1 := v1(f).Interface()
dest(f).SetBool(i0 == i1)
return tnext
}
}
case c1.rval.IsValid():
i1 := c1.rval.Interface()
v0 := genValue(c0)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
i0 := v0(f).Interface()
if i0 == i1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
i0 := v0(f).Interface()
dest(f).SetBool(i0 == i1)
return tnext
}
}
default:
v0 := genValue(c0)
v1 := genValue(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
i0 := v0(f).Interface()
i1 := v1(f).Interface()
if i0 == i1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
i0 := v0(f).Interface()
i1 := v1(f).Interface()
dest(f).SetBool(i0 == i1)
return tnext
}
}
}
}
}
func greater(n *node) {
tnext := getExec(n.tnext)
dest := genValueOutput(n, reflect.TypeOf(true))
typ := n.typ.concrete().TypeOf()
isInterface := n.typ.TypeOf().Kind() == reflect.Interface
c0, c1 := n.child[0], n.child[1]
t0, t1 := c0.typ.TypeOf(), c1.typ.TypeOf()
switch {
case isString(t0) || isString(t1):
switch {
case isInterface:
v0 := genValueString(c0)
v1 := genValueString(c1)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
dest(f).Set(reflect.ValueOf(s0 > s1).Convert(typ))
return tnext
}
case c0.rval.IsValid():
s0 := vString(c0.rval)
v1 := genValueString(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s1 := v1(f)
if s0 > s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
n.exec = func(f *frame) bltn {
_, s1 := v1(f)
dest(f).SetBool(s0 > s1)
return tnext
}
}
case c1.rval.IsValid():
s1 := vString(c1.rval)
v0 := genValueString(c0)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
if s0 > s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
dest(f).SetBool(s0 > s1)
return tnext
}
}
default:
v0 := genValueString(c0)
v1 := genValueString(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
if s0 > s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
dest(f).SetBool(s0 > s1)
return tnext
}
}
}
case isFloat(t0) || isFloat(t1):
switch {
case isInterface:
v0 := genValueFloat(c0)
v1 := genValueFloat(c1)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
dest(f).Set(reflect.ValueOf(s0 > s1).Convert(typ))
return tnext
}
case c0.rval.IsValid():
s0 := vFloat(c0.rval)
v1 := genValueFloat(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s1 := v1(f)
if s0 > s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
n.exec = func(f *frame) bltn {
_, s1 := v1(f)
dest(f).SetBool(s0 > s1)
return tnext
}
}
case c1.rval.IsValid():
s1 := vFloat(c1.rval)
v0 := genValueFloat(c0)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
if s0 > s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
dest(f).SetBool(s0 > s1)
return tnext
}
}
default:
v0 := genValueFloat(c0)
v1 := genValueFloat(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
if s0 > s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
dest(f).SetBool(s0 > s1)
return tnext
}
}
}
case isUint(t0) || isUint(t1):
switch {
case isInterface:
v0 := genValueUint(c0)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
dest(f).Set(reflect.ValueOf(s0 > s1).Convert(typ))
return tnext
}
case c0.rval.IsValid():
s0 := vUint(c0.rval)
v1 := genValueUint(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s1 := v1(f)
if s0 > s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
_, s1 := v1(f)
dest(f).SetBool(s0 > s1)
return tnext
}
}
case c1.rval.IsValid():
s1 := vUint(c1.rval)
v0 := genValueUint(c0)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
if s0 > s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
dest(f).SetBool(s0 > s1)
return tnext
}
}
default:
v0 := genValueUint(c0)
v1 := genValueUint(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
if s0 > s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
dest(f).SetBool(s0 > s1)
return tnext
}
}
}
case isInt(t0) || isInt(t1):
switch {
case isInterface:
v0 := genValueInt(c0)
v1 := genValueInt(c1)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
dest(f).Set(reflect.ValueOf(s0 > s1).Convert(typ))
return tnext
}
case c0.rval.IsValid():
s0 := vInt(c0.rval)
v1 := genValueInt(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s1 := v1(f)
if s0 > s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
_, s1 := v1(f)
dest(f).SetBool(s0 > s1)
return tnext
}
}
case c1.rval.IsValid():
s1 := vInt(c1.rval)
v0 := genValueInt(c0)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
if s0 > s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
dest(f).SetBool(s0 > s1)
return tnext
}
}
default:
v0 := genValueInt(c0)
v1 := genValueInt(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
if s0 > s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
dest(f).SetBool(s0 > s1)
return tnext
}
}
}
}
}
func greaterEqual(n *node) {
tnext := getExec(n.tnext)
dest := genValueOutput(n, reflect.TypeOf(true))
typ := n.typ.concrete().TypeOf()
isInterface := n.typ.TypeOf().Kind() == reflect.Interface
c0, c1 := n.child[0], n.child[1]
t0, t1 := c0.typ.TypeOf(), c1.typ.TypeOf()
switch {
case isString(t0) || isString(t1):
switch {
case isInterface:
v0 := genValueString(c0)
v1 := genValueString(c1)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
dest(f).Set(reflect.ValueOf(s0 >= s1).Convert(typ))
return tnext
}
case c0.rval.IsValid():
s0 := vString(c0.rval)
v1 := genValueString(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s1 := v1(f)
if s0 >= s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
n.exec = func(f *frame) bltn {
_, s1 := v1(f)
dest(f).SetBool(s0 >= s1)
return tnext
}
}
case c1.rval.IsValid():
s1 := vString(c1.rval)
v0 := genValueString(c0)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
if s0 >= s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
dest(f).SetBool(s0 >= s1)
return tnext
}
}
default:
v0 := genValueString(c0)
v1 := genValueString(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
if s0 >= s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
dest(f).SetBool(s0 >= s1)
return tnext
}
}
}
case isFloat(t0) || isFloat(t1):
switch {
case isInterface:
v0 := genValueFloat(c0)
v1 := genValueFloat(c1)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
dest(f).Set(reflect.ValueOf(s0 >= s1).Convert(typ))
return tnext
}
case c0.rval.IsValid():
s0 := vFloat(c0.rval)
v1 := genValueFloat(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s1 := v1(f)
if s0 >= s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
n.exec = func(f *frame) bltn {
_, s1 := v1(f)
dest(f).SetBool(s0 >= s1)
return tnext
}
}
case c1.rval.IsValid():
s1 := vFloat(c1.rval)
v0 := genValueFloat(c0)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
if s0 >= s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
dest(f).SetBool(s0 >= s1)
return tnext
}
}
default:
v0 := genValueFloat(c0)
v1 := genValueFloat(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
if s0 >= s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
dest(f).SetBool(s0 >= s1)
return tnext
}
}
}
case isUint(t0) || isUint(t1):
switch {
case isInterface:
v0 := genValueUint(c0)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
dest(f).Set(reflect.ValueOf(s0 >= s1).Convert(typ))
return tnext
}
case c0.rval.IsValid():
s0 := vUint(c0.rval)
v1 := genValueUint(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s1 := v1(f)
if s0 >= s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
_, s1 := v1(f)
dest(f).SetBool(s0 >= s1)
return tnext
}
}
case c1.rval.IsValid():
s1 := vUint(c1.rval)
v0 := genValueUint(c0)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
if s0 >= s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
dest(f).SetBool(s0 >= s1)
return tnext
}
}
default:
v0 := genValueUint(c0)
v1 := genValueUint(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
if s0 >= s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
dest(f).SetBool(s0 >= s1)
return tnext
}
}
}
case isInt(t0) || isInt(t1):
switch {
case isInterface:
v0 := genValueInt(c0)
v1 := genValueInt(c1)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
dest(f).Set(reflect.ValueOf(s0 >= s1).Convert(typ))
return tnext
}
case c0.rval.IsValid():
s0 := vInt(c0.rval)
v1 := genValueInt(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s1 := v1(f)
if s0 >= s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
_, s1 := v1(f)
dest(f).SetBool(s0 >= s1)
return tnext
}
}
case c1.rval.IsValid():
s1 := vInt(c1.rval)
v0 := genValueInt(c0)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
if s0 >= s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
dest(f).SetBool(s0 >= s1)
return tnext
}
}
default:
v0 := genValueInt(c0)
v1 := genValueInt(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
if s0 >= s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
dest(f).SetBool(s0 >= s1)
return tnext
}
}
}
}
}
func lower(n *node) {
tnext := getExec(n.tnext)
dest := genValueOutput(n, reflect.TypeOf(true))
typ := n.typ.concrete().TypeOf()
isInterface := n.typ.TypeOf().Kind() == reflect.Interface
c0, c1 := n.child[0], n.child[1]
t0, t1 := c0.typ.TypeOf(), c1.typ.TypeOf()
switch {
case isString(t0) || isString(t1):
switch {
case isInterface:
v0 := genValueString(c0)
v1 := genValueString(c1)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
dest(f).Set(reflect.ValueOf(s0 < s1).Convert(typ))
return tnext
}
case c0.rval.IsValid():
s0 := vString(c0.rval)
v1 := genValueString(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s1 := v1(f)
if s0 < s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
n.exec = func(f *frame) bltn {
_, s1 := v1(f)
dest(f).SetBool(s0 < s1)
return tnext
}
}
case c1.rval.IsValid():
s1 := vString(c1.rval)
v0 := genValueString(c0)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
if s0 < s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
dest(f).SetBool(s0 < s1)
return tnext
}
}
default:
v0 := genValueString(c0)
v1 := genValueString(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
if s0 < s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
dest(f).SetBool(s0 < s1)
return tnext
}
}
}
case isFloat(t0) || isFloat(t1):
switch {
case isInterface:
v0 := genValueFloat(c0)
v1 := genValueFloat(c1)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
dest(f).Set(reflect.ValueOf(s0 < s1).Convert(typ))
return tnext
}
case c0.rval.IsValid():
s0 := vFloat(c0.rval)
v1 := genValueFloat(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s1 := v1(f)
if s0 < s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
n.exec = func(f *frame) bltn {
_, s1 := v1(f)
dest(f).SetBool(s0 < s1)
return tnext
}
}
case c1.rval.IsValid():
s1 := vFloat(c1.rval)
v0 := genValueFloat(c0)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
if s0 < s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
dest(f).SetBool(s0 < s1)
return tnext
}
}
default:
v0 := genValueFloat(c0)
v1 := genValueFloat(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
if s0 < s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
dest(f).SetBool(s0 < s1)
return tnext
}
}
}
case isUint(t0) || isUint(t1):
switch {
case isInterface:
v0 := genValueUint(c0)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
dest(f).Set(reflect.ValueOf(s0 < s1).Convert(typ))
return tnext
}
case c0.rval.IsValid():
s0 := vUint(c0.rval)
v1 := genValueUint(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s1 := v1(f)
if s0 < s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
_, s1 := v1(f)
dest(f).SetBool(s0 < s1)
return tnext
}
}
case c1.rval.IsValid():
s1 := vUint(c1.rval)
v0 := genValueUint(c0)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
if s0 < s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
dest(f).SetBool(s0 < s1)
return tnext
}
}
default:
v0 := genValueUint(c0)
v1 := genValueUint(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
if s0 < s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
dest(f).SetBool(s0 < s1)
return tnext
}
}
}
case isInt(t0) || isInt(t1):
switch {
case isInterface:
v0 := genValueInt(c0)
v1 := genValueInt(c1)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
dest(f).Set(reflect.ValueOf(s0 < s1).Convert(typ))
return tnext
}
case c0.rval.IsValid():
s0 := vInt(c0.rval)
v1 := genValueInt(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s1 := v1(f)
if s0 < s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
_, s1 := v1(f)
dest(f).SetBool(s0 < s1)
return tnext
}
}
case c1.rval.IsValid():
s1 := vInt(c1.rval)
v0 := genValueInt(c0)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
if s0 < s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
dest(f).SetBool(s0 < s1)
return tnext
}
}
default:
v0 := genValueInt(c0)
v1 := genValueInt(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
if s0 < s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
dest(f).SetBool(s0 < s1)
return tnext
}
}
}
}
}
func lowerEqual(n *node) {
tnext := getExec(n.tnext)
dest := genValueOutput(n, reflect.TypeOf(true))
typ := n.typ.concrete().TypeOf()
isInterface := n.typ.TypeOf().Kind() == reflect.Interface
c0, c1 := n.child[0], n.child[1]
t0, t1 := c0.typ.TypeOf(), c1.typ.TypeOf()
switch {
case isString(t0) || isString(t1):
switch {
case isInterface:
v0 := genValueString(c0)
v1 := genValueString(c1)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
dest(f).Set(reflect.ValueOf(s0 <= s1).Convert(typ))
return tnext
}
case c0.rval.IsValid():
s0 := vString(c0.rval)
v1 := genValueString(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s1 := v1(f)
if s0 <= s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
n.exec = func(f *frame) bltn {
_, s1 := v1(f)
dest(f).SetBool(s0 <= s1)
return tnext
}
}
case c1.rval.IsValid():
s1 := vString(c1.rval)
v0 := genValueString(c0)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
if s0 <= s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
dest(f).SetBool(s0 <= s1)
return tnext
}
}
default:
v0 := genValueString(c0)
v1 := genValueString(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
if s0 <= s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
dest(f).SetBool(s0 <= s1)
return tnext
}
}
}
case isFloat(t0) || isFloat(t1):
switch {
case isInterface:
v0 := genValueFloat(c0)
v1 := genValueFloat(c1)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
dest(f).Set(reflect.ValueOf(s0 <= s1).Convert(typ))
return tnext
}
case c0.rval.IsValid():
s0 := vFloat(c0.rval)
v1 := genValueFloat(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s1 := v1(f)
if s0 <= s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
n.exec = func(f *frame) bltn {
_, s1 := v1(f)
dest(f).SetBool(s0 <= s1)
return tnext
}
}
case c1.rval.IsValid():
s1 := vFloat(c1.rval)
v0 := genValueFloat(c0)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
if s0 <= s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
dest(f).SetBool(s0 <= s1)
return tnext
}
}
default:
v0 := genValueFloat(c0)
v1 := genValueFloat(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
if s0 <= s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
dest(f).SetBool(s0 <= s1)
return tnext
}
}
}
case isUint(t0) || isUint(t1):
switch {
case isInterface:
v0 := genValueUint(c0)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
dest(f).Set(reflect.ValueOf(s0 <= s1).Convert(typ))
return tnext
}
case c0.rval.IsValid():
s0 := vUint(c0.rval)
v1 := genValueUint(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s1 := v1(f)
if s0 <= s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
_, s1 := v1(f)
dest(f).SetBool(s0 <= s1)
return tnext
}
}
case c1.rval.IsValid():
s1 := vUint(c1.rval)
v0 := genValueUint(c0)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
if s0 <= s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
dest(f).SetBool(s0 <= s1)
return tnext
}
}
default:
v0 := genValueUint(c0)
v1 := genValueUint(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
if s0 <= s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
dest(f).SetBool(s0 <= s1)
return tnext
}
}
}
case isInt(t0) || isInt(t1):
switch {
case isInterface:
v0 := genValueInt(c0)
v1 := genValueInt(c1)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
dest(f).Set(reflect.ValueOf(s0 <= s1).Convert(typ))
return tnext
}
case c0.rval.IsValid():
s0 := vInt(c0.rval)
v1 := genValueInt(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s1 := v1(f)
if s0 <= s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
_, s1 := v1(f)
dest(f).SetBool(s0 <= s1)
return tnext
}
}
case c1.rval.IsValid():
s1 := vInt(c1.rval)
v0 := genValueInt(c0)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
if s0 <= s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
dest(f).SetBool(s0 <= s1)
return tnext
}
}
default:
v0 := genValueInt(c0)
v1 := genValueInt(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
if s0 <= s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
dest(f).SetBool(s0 <= s1)
return tnext
}
}
}
}
}
func notEqual(n *node) {
tnext := getExec(n.tnext)
dest := genValueOutput(n, reflect.TypeOf(true))
typ := n.typ.concrete().TypeOf()
isInterface := n.typ.TypeOf().Kind() == reflect.Interface
c0, c1 := n.child[0], n.child[1]
t0, t1 := c0.typ.TypeOf(), c1.typ.TypeOf()
if c0.typ.cat == linkedT || c1.typ.cat == linkedT {
switch {
case isInterface:
v0 := genValue(c0)
v1 := genValue(c1)
dest := genValue(n)
n.exec = func(f *frame) bltn {
i0 := v0(f).Interface()
i1 := v1(f).Interface()
dest(f).Set(reflect.ValueOf(i0 != i1).Convert(typ))
return tnext
}
case c0.rval.IsValid():
i0 := c0.rval.Interface()
v1 := genValue(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
i1 := v1(f).Interface()
if i0 != i1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
i1 := v1(f).Interface()
dest(f).SetBool(i0 != i1)
return tnext
}
}
case c1.rval.IsValid():
i1 := c1.rval.Interface()
v0 := genValue(c0)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
i0 := v0(f).Interface()
if i0 != i1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
i0 := v0(f).Interface()
dest(f).SetBool(i0 != i1)
return tnext
}
}
default:
v0 := genValue(c0)
v1 := genValue(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
i0 := v0(f).Interface()
i1 := v1(f).Interface()
if i0 != i1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
i0 := v0(f).Interface()
i1 := v1(f).Interface()
dest(f).SetBool(i0 != i1)
return tnext
}
}
}
return
}
// Do not attempt to optimize '==' or '!=' if an operand is an interface.
// This will preserve proper dynamic type checking at runtime. For static types,
// type checks are already performed, so bypass them if possible.
if t0.Kind() == reflect.Interface || t1.Kind() == reflect.Interface {
v0 := genValue(c0)
v1 := genValue(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
i0 := v0(f).Interface()
i1 := v1(f).Interface()
if i0 != i1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
i0 := v0(f).Interface()
i1 := v1(f).Interface()
dest(f).SetBool(i0 != i1)
return tnext
}
}
return
}
switch {
case isString(t0) || isString(t1):
switch {
case isInterface:
v0 := genValueString(c0)
v1 := genValueString(c1)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
dest(f).Set(reflect.ValueOf(s0 != s1).Convert(typ))
return tnext
}
case c0.rval.IsValid():
s0 := vString(c0.rval)
v1 := genValueString(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s1 := v1(f)
if s0 != s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
n.exec = func(f *frame) bltn {
_, s1 := v1(f)
dest(f).SetBool(s0 != s1)
return tnext
}
}
case c1.rval.IsValid():
s1 := vString(c1.rval)
v0 := genValueString(c0)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
if s0 != s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
dest(f).SetBool(s0 != s1)
return tnext
}
}
default:
v0 := genValueString(c0)
v1 := genValueString(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
if s0 != s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
dest(f).SetBool(s0 != s1)
return tnext
}
}
}
case isFloat(t0) || isFloat(t1):
switch {
case isInterface:
v0 := genValueFloat(c0)
v1 := genValueFloat(c1)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
dest(f).Set(reflect.ValueOf(s0 != s1).Convert(typ))
return tnext
}
case c0.rval.IsValid():
s0 := vFloat(c0.rval)
v1 := genValueFloat(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s1 := v1(f)
if s0 != s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
n.exec = func(f *frame) bltn {
_, s1 := v1(f)
dest(f).SetBool(s0 != s1)
return tnext
}
}
case c1.rval.IsValid():
s1 := vFloat(c1.rval)
v0 := genValueFloat(c0)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
if s0 != s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
dest(f).SetBool(s0 != s1)
return tnext
}
}
default:
v0 := genValueFloat(c0)
v1 := genValueFloat(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
if s0 != s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
dest(f).SetBool(s0 != s1)
return tnext
}
}
}
case isUint(t0) || isUint(t1):
switch {
case isInterface:
v0 := genValueUint(c0)
v1 := genValueUint(c1)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
dest(f).Set(reflect.ValueOf(s0 != s1).Convert(typ))
return tnext
}
case c0.rval.IsValid():
s0 := vUint(c0.rval)
v1 := genValueUint(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s1 := v1(f)
if s0 != s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
_, s1 := v1(f)
dest(f).SetBool(s0 != s1)
return tnext
}
}
case c1.rval.IsValid():
s1 := vUint(c1.rval)
v0 := genValueUint(c0)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
if s0 != s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
dest(f).SetBool(s0 != s1)
return tnext
}
}
default:
v0 := genValueUint(c0)
v1 := genValueUint(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
if s0 != s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
dest(f).SetBool(s0 != s1)
return tnext
}
}
}
case isInt(t0) || isInt(t1):
switch {
case isInterface:
v0 := genValueInt(c0)
v1 := genValueInt(c1)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
dest(f).Set(reflect.ValueOf(s0 != s1).Convert(typ))
return tnext
}
case c0.rval.IsValid():
s0 := vInt(c0.rval)
v1 := genValueInt(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s1 := v1(f)
if s0 != s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
_, s1 := v1(f)
dest(f).SetBool(s0 != s1)
return tnext
}
}
case c1.rval.IsValid():
s1 := vInt(c1.rval)
v0 := genValueInt(c0)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
if s0 != s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
dest(f).SetBool(s0 != s1)
return tnext
}
}
default:
v0 := genValueInt(c0)
v1 := genValueInt(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
if s0 != s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
_, s0 := v0(f)
_, s1 := v1(f)
dest(f).SetBool(s0 != s1)
return tnext
}
}
}
case isComplex(t0) || isComplex(t1):
switch {
case isInterface:
v0 := genComplex(c0)
v1 := genComplex(c1)
n.exec = func(f *frame) bltn {
s0 := v0(f)
s1 := v1(f)
dest(f).Set(reflect.ValueOf(s0 != s1).Convert(typ))
return tnext
}
case c0.rval.IsValid():
s0 := vComplex(c0.rval)
v1 := genComplex(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
s1 := v1(f)
if s0 != s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
n.exec = func(f *frame) bltn {
s1 := v1(f)
dest(f).SetBool(s0 != s1)
return tnext
}
}
case c1.rval.IsValid():
s1 := vComplex(c1.rval)
v0 := genComplex(c0)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
s0 := v0(f)
if s0 != s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
s0 := v0(f)
dest(f).SetBool(s0 != s1)
return tnext
}
}
default:
v0 := genComplex(c0)
v1 := genComplex(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
s0 := v0(f)
s1 := v1(f)
if s0 != s1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
n.exec = func(f *frame) bltn {
s0 := v0(f)
s1 := v1(f)
dest(f).SetBool(s0 != s1)
return tnext
}
}
}
default:
switch {
case isInterface:
v0 := genValue(c0)
v1 := genValue(c1)
n.exec = func(f *frame) bltn {
i0 := v0(f).Interface()
i1 := v1(f).Interface()
dest(f).Set(reflect.ValueOf(i0 != i1).Convert(typ))
return tnext
}
case c0.rval.IsValid():
i0 := c0.rval.Interface()
v1 := genValue(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
i1 := v1(f).Interface()
if i0 != i1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
i1 := v1(f).Interface()
dest(f).SetBool(i0 != i1)
return tnext
}
}
case c1.rval.IsValid():
i1 := c1.rval.Interface()
v0 := genValue(c0)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
i0 := v0(f).Interface()
if i0 != i1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
i0 := v0(f).Interface()
dest(f).SetBool(i0 != i1)
return tnext
}
}
default:
v0 := genValue(c0)
v1 := genValue(c1)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
i0 := v0(f).Interface()
i1 := v1(f).Interface()
if i0 != i1 {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
dest := genValue(n)
n.exec = func(f *frame) bltn {
i0 := v0(f).Interface()
i1 := v1(f).Interface()
dest(f).SetBool(i0 != i1)
return tnext
}
}
}
}
}
================================================
FILE: interp/program.go
================================================
package interp
import (
"context"
"go/ast"
"go/token"
"io/fs"
"path/filepath"
"reflect"
"runtime"
"runtime/debug"
)
// A Program is Go code that has been parsed and compiled.
type Program struct {
pkgName string
root *node
init []*node
}
// PackageName returns name used in a package clause.
func (p *Program) PackageName() string {
return p.pkgName
}
// FileSet is the fileset that must be used for parsing Go that will be passed
// to interp.CompileAST().
func (interp *Interpreter) FileSet() *token.FileSet {
return interp.fset
}
// Compile parses and compiles a Go code represented as a string.
func (interp *Interpreter) Compile(src string) (*Program, error) {
return interp.compileSrc(src, "", true)
}
// CompilePath parses and compiles a Go code located at the given path.
func (interp *Interpreter) CompilePath(path string) (*Program, error) {
path = filepath.ToSlash(path) // Ensure path is in Unix format. Since we work with fs.FS, we need to use Unix path.
if !isFile(interp.filesystem, path) {
_, err := interp.importSrc(mainID, path, NoTest)
return nil, err
}
b, err := fs.ReadFile(interp.filesystem, path)
if err != nil {
return nil, err
}
return interp.compileSrc(string(b), path, false)
}
func (interp *Interpreter) compileSrc(src, name string, inc bool) (*Program, error) {
if name != "" {
interp.name = name
}
if interp.name == "" {
interp.name = DefaultSourceName
}
// Parse source to AST.
n, err := interp.parse(src, interp.name, inc)
if err != nil {
return nil, err
}
return interp.CompileAST(n)
}
// CompileAST builds a Program for the given Go code AST. Files and block
// statements can be compiled, as can most expressions. Var declaration nodes
// cannot be compiled.
//
// WARNING: The node must have been parsed using interp.FileSet(). Results are
// unpredictable otherwise.
func (interp *Interpreter) CompileAST(n ast.Node) (*Program, error) {
// Convert AST.
pkgName, root, err := interp.ast(n)
if err != nil || root == nil {
return nil, err
}
if interp.astDot {
dotCmd := interp.dotCmd
if dotCmd == "" {
dotCmd = defaultDotCmd(interp.name, "yaegi-ast-")
}
root.astDot(dotWriter(dotCmd), interp.name)
if interp.noRun {
return nil, err
}
}
// Perform global types analysis.
if err = interp.gtaRetry([]*node{root}, pkgName, pkgName); err != nil {
return nil, err
}
// Annotate AST with CFG informations.
initNodes, err := interp.cfg(root, nil, pkgName, pkgName)
if err != nil {
if interp.cfgDot {
dotCmd := interp.dotCmd
if dotCmd == "" {
dotCmd = defaultDotCmd(interp.name, "yaegi-cfg-")
}
root.cfgDot(dotWriter(dotCmd))
}
return nil, err
}
if root.kind != fileStmt {
// REPL may skip package statement.
setExec(root.start)
}
interp.mutex.Lock()
gs := interp.scopes[pkgName]
if interp.universe.sym[pkgName] == nil {
// Make the package visible under a path identical to its name.
interp.srcPkg[pkgName] = gs.sym
interp.universe.sym[pkgName] = &symbol{kind: pkgSym, typ: &itype{cat: srcPkgT, path: pkgName}}
interp.pkgNames[pkgName] = pkgName
}
interp.mutex.Unlock()
// Add main to list of functions to run, after all inits.
if m := gs.sym[mainID]; pkgName == mainID && m != nil {
initNodes = append(initNodes, m.node)
}
if interp.cfgDot {
dotCmd := interp.dotCmd
if dotCmd == "" {
dotCmd = defaultDotCmd(interp.name, "yaegi-cfg-")
}
root.cfgDot(dotWriter(dotCmd))
}
return &Program{pkgName, root, initNodes}, nil
}
// Execute executes compiled Go code.
func (interp *Interpreter) Execute(p *Program) (res reflect.Value, err error) {
defer func() {
r := recover()
if r != nil {
var pc [64]uintptr // 64 frames should be enough.
n := runtime.Callers(1, pc[:])
err = Panic{Value: r, Callers: pc[:n], Stack: debug.Stack()}
}
}()
// Generate node exec closures.
if err = genRun(p.root); err != nil {
return res, err
}
// Init interpreter execution memory frame.
interp.frame.setrunid(interp.runid())
interp.frame.mutex.Lock()
interp.resizeFrame()
interp.frame.mutex.Unlock()
// Execute node closures.
interp.run(p.root, nil)
// Wire and execute global vars.
n, err := genGlobalVars([]*node{p.root}, interp.scopes[p.pkgName])
if err != nil {
return res, err
}
interp.run(n, nil)
for _, n := range p.init {
interp.run(n, interp.frame)
}
v := genValue(p.root)
res = v(interp.frame)
// If result is an interpreter node, wrap it in a runtime callable function.
if res.IsValid() {
if n, ok := res.Interface().(*node); ok {
res = genFunctionWrapper(n)(interp.frame)
}
}
return res, err
}
// ExecuteWithContext executes compiled Go code.
func (interp *Interpreter) ExecuteWithContext(ctx context.Context, p *Program) (res reflect.Value, err error) {
interp.mutex.Lock()
interp.done = make(chan struct{})
interp.cancelChan = !interp.opt.fastChan
interp.mutex.Unlock()
done := make(chan struct{})
go func() {
defer close(done)
res, err = interp.Execute(p)
}()
select {
case <-ctx.Done():
interp.stop()
return reflect.Value{}, ctx.Err()
case <-done:
}
return res, err
}
================================================
FILE: interp/realfs.go
================================================
package interp
import (
"io/fs"
"os"
)
// realFS complies with the fs.FS interface (go 1.16 onwards)
// We use this rather than os.DirFS as DirFS has no concept of
// what the current working directory is, whereas this simple
// passthru to os.Open knows about working dir automagically.
type realFS struct{}
// Open complies with the fs.FS interface.
func (dir realFS) Open(name string) (fs.File, error) {
f, err := os.Open(name)
if err != nil {
return nil, err
}
return f, nil
}
================================================
FILE: interp/run.go
================================================
package interp
//go:generate go run ../internal/cmd/genop/genop.go
import (
"errors"
"fmt"
"go/constant"
"reflect"
"regexp"
"strings"
)
// bltn type defines functions which run at CFG execution.
type bltn func(f *frame) bltn
// bltnGenerator type defines a builtin generator function.
type bltnGenerator func(n *node)
var builtin = [...]bltnGenerator{
aNop: nop,
aAddr: addr,
aAssign: assign,
aAdd: add,
aAddAssign: addAssign,
aAnd: and,
aAndAssign: andAssign,
aAndNot: andNot,
aAndNotAssign: andNotAssign,
aBitNot: bitNot,
aCall: call,
aCallSlice: call,
aCase: _case,
aCompositeLit: arrayLit,
aDec: dec,
aEqual: equal,
aGetFunc: getFunc,
aGreater: greater,
aGreaterEqual: greaterEqual,
aInc: inc,
aLand: land,
aLor: lor,
aLower: lower,
aLowerEqual: lowerEqual,
aMul: mul,
aMulAssign: mulAssign,
aNeg: neg,
aNot: not,
aNotEqual: notEqual,
aOr: or,
aOrAssign: orAssign,
aPos: pos,
aQuo: quo,
aQuoAssign: quoAssign,
aRange: _range,
aRecv: recv,
aRem: rem,
aRemAssign: remAssign,
aReturn: _return,
aSend: send,
aShl: shl,
aShlAssign: shlAssign,
aShr: shr,
aShrAssign: shrAssign,
aSlice: slice,
aSlice0: slice0,
aStar: deref,
aSub: sub,
aSubAssign: subAssign,
aTypeAssert: typeAssertShort,
aXor: xor,
aXorAssign: xorAssign,
}
var receiverStripperRxp *regexp.Regexp
func init() {
re := `func\(((.*?(, |\)))(.*))`
var err error
receiverStripperRxp, err = regexp.Compile(re)
if err != nil {
panic(err)
}
}
type valueInterface struct {
node *node
value reflect.Value
}
var floatType, complexType reflect.Type
func init() {
floatType = reflect.ValueOf(0.0).Type()
complexType = reflect.ValueOf(complex(0, 0)).Type()
}
func (interp *Interpreter) run(n *node, cf *frame) {
if n == nil {
return
}
var f *frame
if cf == nil {
f = interp.frame
} else {
f = newFrame(cf, len(n.types), interp.runid())
}
interp.mutex.RLock()
c := reflect.ValueOf(interp.done)
interp.mutex.RUnlock()
f.mutex.Lock()
f.done = reflect.SelectCase{Dir: reflect.SelectRecv, Chan: c}
f.mutex.Unlock()
for i, t := range n.types {
f.data[i] = reflect.New(t).Elem()
}
runCfg(n.start, f, n, nil)
}
func isExecNode(n *node, exec bltn) bool {
if n == nil || n.exec == nil || exec == nil {
return false
}
a1 := reflect.ValueOf(n.exec).Pointer()
a2 := reflect.ValueOf(exec).Pointer()
return a1 == a2
}
// originalExecNode looks in the tree of nodes for the node which has exec,
// aside from n, in order to know where n "inherited" that exec from.
func originalExecNode(n *node, exec bltn) *node {
execAddr := reflect.ValueOf(exec).Pointer()
var originalNode *node
seen := make(map[int64]struct{})
root := n
for {
root = root.anc
if root == nil {
break
}
if _, ok := seen[root.index]; ok {
continue
}
root.Walk(func(wn *node) bool {
if _, ok := seen[wn.index]; ok {
return true
}
seen[wn.index] = struct{}{}
if wn.index == n.index {
return true
}
if wn.exec == nil {
return true
}
if reflect.ValueOf(wn.exec).Pointer() == execAddr {
originalNode = wn
return false
}
return true
}, nil)
if originalNode != nil {
break
}
}
return originalNode
}
// cloned from net/http/server.go , so we can enforce a similar behavior:
// in the stdlib, this error is used as sentinel in panic triggered e.g. on
// request cancellation, in order to catch it and suppress it in a following defer.
// in yaegi, we use it to suppress a "panic" log message that happens in the
// same circumstances.
var errAbortHandler = errors.New("net/http: abort Handler")
// Functions set to run during execution of CFG.
func panicFunc(s *scope) string {
if s == nil {
return ""
}
def := s.def
if def == nil {
return s.pkgID
}
switch def.kind {
case funcDecl:
if c := def.child[1]; c.kind == identExpr {
return s.pkgID + "." + c.ident
}
case funcLit:
if def.anc != nil {
return panicFunc(def.anc.scope) + ".func"
}
}
return s.pkgID
}
// runCfg executes a node AST by walking its CFG and running node builtin at each step.
func runCfg(n *node, f *frame, funcNode, callNode *node) {
var exec bltn
defer func() {
f.mutex.Lock()
f.recovered = recover()
for _, val := range f.deferred {
val[0].Call(val[1:])
}
if f.recovered != nil {
oNode := originalExecNode(n, exec)
if oNode == nil {
oNode = n
}
errorer, ok := f.recovered.(error)
// in this specific case, the stdlib would/will suppress the panic, so we
// suppress the logging here accordingly, to get a similar and consistent
// behavior.
if !ok || errorer.Error() != errAbortHandler.Error() {
fmt.Fprintln(n.interp.stderr, oNode.cfgErrorf("panic: %s(...)", panicFunc(oNode.scope)))
}
f.mutex.Unlock()
panic(f.recovered)
}
f.mutex.Unlock()
}()
dbg := n.interp.debugger
if dbg == nil {
for exec := n.exec; exec != nil && f.runid() == n.interp.runid(); {
exec = exec(f)
}
return
}
if n.exec == nil {
return
}
dbg.enterCall(funcNode, callNode, f)
defer dbg.exitCall(funcNode, callNode, f)
for m, exec := n, n.exec; f.runid() == n.interp.runid(); {
if dbg.exec(m, f) {
break
}
exec = exec(f)
if exec == nil {
break
}
if m == nil {
m = originalExecNode(n, exec)
continue
}
switch {
case isExecNode(m.tnext, exec):
m = m.tnext
case isExecNode(m.fnext, exec):
m = m.fnext
default:
m = originalExecNode(m, exec)
}
}
}
func stripReceiverFromArgs(signature string) (string, error) {
fields := receiverStripperRxp.FindStringSubmatch(signature)
if len(fields) < 5 {
return "", errors.New("error while matching method signature")
}
if fields[3] == ")" {
return fmt.Sprintf("func()%s", fields[4]), nil
}
return fmt.Sprintf("func(%s", fields[4]), nil
}
func typeAssertShort(n *node) {
typeAssert(n, true, false)
}
func typeAssertLong(n *node) {
typeAssert(n, true, true)
}
func typeAssertStatus(n *node) {
typeAssert(n, false, true)
}
func typeAssert(n *node, withResult, withOk bool) {
c0, c1 := n.child[0], n.child[1]
value := genValue(c0) // input value
var value0, value1 func(*frame) reflect.Value
setStatus := false
switch {
case withResult && withOk:
value0 = genValue(n.anc.child[0]) // returned result
value1 = genValue(n.anc.child[1]) // returned status
setStatus = n.anc.child[1].ident != "_" // do not assign status to "_"
case withResult && !withOk:
value0 = genValue(n) // returned result
case !withResult && withOk:
value1 = genValue(n.anc.child[1]) // returned status
setStatus = n.anc.child[1].ident != "_" // do not assign status to "_"
}
typ := c1.typ // type to assert or convert to
typID := typ.id()
rtype := typ.refType(nil) // type to assert
next := getExec(n.tnext)
switch {
case isInterfaceSrc(typ):
n.exec = func(f *frame) bltn {
valf := value(f)
v, ok := valf.Interface().(valueInterface)
if setStatus {
defer func() {
value1(f).SetBool(ok)
}()
}
if !ok {
if !withOk {
panic(n.cfgErrorf("interface conversion: nil is not %v", typID))
}
return next
}
if c0.typ.cat == valueT {
valf = reflect.ValueOf(v)
}
if v.node.typ.id() == typID {
if withResult {
value0(f).Set(valf)
}
return next
}
m0 := v.node.typ.methods()
m1 := typ.methods()
if len(m0) < len(m1) {
ok = false
if !withOk {
panic(n.cfgErrorf("interface conversion: %v is not %v", v.node.typ.id(), typID))
}
return next
}
for k, meth1 := range m1 {
var meth0 string
meth0, ok = m0[k]
if !ok {
return next
}
// As far as we know this equality check can fail because they are two ways to
// represent the signature of a method: one where the receiver appears before the
// func keyword, and one where it is just a func signature, and the receiver is
// seen as the first argument. That's why if that equality fails, we try harder to
// compare them afterwards. Hopefully that is the only reason this equality can fail.
if meth0 == meth1 {
continue
}
tm := lookupFieldOrMethod(v.node.typ, k)
if tm == nil {
ok = false
return next
}
var err error
meth0, err = stripReceiverFromArgs(meth0)
if err != nil {
ok = false
return next
}
if meth0 != meth1 {
ok = false
return next
}
}
if withResult {
value0(f).Set(valf)
}
return next
}
case isInterface(typ):
n.exec = func(f *frame) bltn {
var leftType reflect.Type
v := value(f)
val, ok := v.Interface().(valueInterface)
if setStatus {
defer func() {
value1(f).SetBool(ok)
}()
}
if ok && val.node.typ.cat != valueT {
m0 := val.node.typ.methods()
m1 := typ.methods()
if len(m0) < len(m1) {
ok = false
return next
}
for k, meth1 := range m1 {
var meth0 string
meth0, ok = m0[k]
if !ok {
return next
}
if meth0 != meth1 {
ok = false
return next
}
}
if withResult {
value0(f).Set(genInterfaceWrapper(val.node, rtype)(f))
}
ok = true
return next
}
if ok {
v = val.value
leftType = val.node.typ.rtype
} else {
v = v.Elem()
leftType = v.Type()
ok = true
}
ok = v.IsValid()
if !ok {
if !withOk {
panic(n.cfgErrorf("interface conversion: interface {} is nil, not %s", rtype.String()))
}
return next
}
ok = canAssertTypes(leftType, rtype)
if !ok {
if !withOk {
method := firstMissingMethod(leftType, rtype)
panic(n.cfgErrorf("interface conversion: %s is not %s: missing method %s", leftType.String(), rtype.String(), method))
}
return next
}
if withResult {
value0(f).Set(v)
}
return next
}
case isEmptyInterface(n.child[0].typ):
n.exec = func(f *frame) bltn {
var ok bool
if setStatus {
defer func() {
value1(f).SetBool(ok)
}()
}
val := value(f)
concrete := val.Interface()
ctyp := reflect.TypeOf(concrete)
if vv, ok := concrete.(valueInterface); ok {
ctyp = vv.value.Type()
concrete = vv.value.Interface()
}
ok = canAssertTypes(ctyp, rtype)
if !ok {
if !withOk {
// TODO(mpl): think about whether this should ever happen.
if ctyp == nil {
panic(n.cfgErrorf("interface conversion: interface {} is nil, not %s", rtype.String()))
}
panic(n.cfgErrorf("interface conversion: interface {} is %s, not %s", ctyp.String(), rtype.String()))
}
return next
}
if withResult {
if isInterfaceSrc(typ) {
// TODO(mpl): this requires more work. the wrapped node is not complete enough.
value0(f).Set(reflect.ValueOf(valueInterface{n.child[0], reflect.ValueOf(concrete)}))
} else {
value0(f).Set(reflect.ValueOf(concrete))
}
}
return next
}
case n.child[0].typ.cat == valueT || n.child[0].typ.cat == errorT:
n.exec = func(f *frame) bltn {
v := value(f).Elem()
ok := v.IsValid()
if setStatus {
defer func() {
value1(f).SetBool(ok)
}()
}
if !ok {
if !withOk {
panic(n.cfgErrorf("interface conversion: interface {} is nil, not %s", rtype.String()))
}
return next
}
v = valueInterfaceValue(v)
if vt := v.Type(); vt.Kind() == reflect.Struct && vt.Field(0).Name == "IValue" {
// Value is retrieved from an interface wrapper.
v = v.Field(0).Elem()
}
ok = canAssertTypes(v.Type(), rtype)
if !ok {
if !withOk {
method := firstMissingMethod(v.Type(), rtype)
panic(n.cfgErrorf("interface conversion: %s is not %s: missing method %s", v.Type().String(), rtype.String(), method))
}
return next
}
if withResult {
value0(f).Set(v)
}
return next
}
default:
n.exec = func(f *frame) bltn {
v, ok := value(f).Interface().(valueInterface)
if setStatus {
defer func() {
value1(f).SetBool(ok)
}()
}
if !ok || !v.value.IsValid() {
ok = false
if !withOk {
panic(n.cfgErrorf("interface conversion: interface {} is nil, not %s", rtype.String()))
}
return next
}
ok = canAssertTypes(v.value.Type(), rtype)
if !ok {
if !withOk {
panic(n.cfgErrorf("interface conversion: interface {} is %s, not %s", v.value.Type().String(), rtype.String()))
}
return next
}
if withResult {
value0(f).Set(v.value)
}
return next
}
}
}
func canAssertTypes(src, dest reflect.Type) bool {
if dest == nil {
return false
}
if src == dest {
return true
}
if dest.Kind() == reflect.Interface && src.Implements(dest) {
return true
}
if src == nil {
return false
}
if src.AssignableTo(dest) {
return true
}
return false
}
func firstMissingMethod(src, dest reflect.Type) string {
for i := 0; i < dest.NumMethod(); i++ {
m := dest.Method(i).Name
if _, ok := src.MethodByName(m); !ok {
return m
}
}
return ""
}
func convert(n *node) {
dest := genValue(n)
c := n.child[1]
typ := n.child[0].typ.frameType()
next := getExec(n.tnext)
if c.isNil() { // convert nil to type
// TODO(mpl): Try to completely remove, as maybe frameType already does the job for interfaces.
if isInterfaceSrc(n.child[0].typ) && !isEmptyInterface(n.child[0].typ) {
typ = valueInterfaceType
}
n.exec = func(f *frame) bltn {
dest(f).Set(reflect.New(typ).Elem())
return next
}
return
}
doConvert := true
var value func(*frame) reflect.Value
switch {
case isFuncSrc(c.typ):
value = genFunctionWrapper(c)
default:
value = genValue(c)
}
for _, con := range n.interp.hooks.convert {
if c.typ.rtype == nil {
continue
}
fn := con(c.typ.rtype, typ)
if fn == nil {
continue
}
n.exec = func(f *frame) bltn {
fn(value(f), dest(f))
return next
}
return
}
n.exec = func(f *frame) bltn {
if doConvert {
dest(f).Set(value(f).Convert(typ))
} else {
dest(f).Set(value(f))
}
return next
}
}
// assignFromCall assigns values from a function call.
func assignFromCall(n *node) {
ncall := n.lastChild()
l := len(n.child) - 1
if n.anc.kind == varDecl && n.child[l-1].isType(n.scope) {
// Ignore the type in the assignment if it is part of a variable declaration.
l--
}
dvalue := make([]func(*frame) reflect.Value, l)
for i := range dvalue {
if n.child[i].ident == "_" {
continue
}
dvalue[i] = genValue(n.child[i])
}
next := getExec(n.tnext)
n.exec = func(f *frame) bltn {
for i, v := range dvalue {
if v == nil {
continue
}
s := f.data[ncall.findex+i]
c := n.child[i]
if n.kind == defineXStmt && !c.redeclared {
// Recreate destination value in case of define statement,
// to preserve previous value possibly in use by a closure.
data := getFrame(f, c.level).data
data[c.findex] = reflect.New(data[c.findex].Type()).Elem()
data[c.findex].Set(s)
continue
}
v(f).Set(s)
}
return next
}
}
func assign(n *node) {
next := getExec(n.tnext)
dvalue := make([]func(*frame) reflect.Value, n.nleft)
ivalue := make([]func(*frame) reflect.Value, n.nleft)
svalue := make([]func(*frame) reflect.Value, n.nleft)
var sbase int
if n.nright > 0 {
sbase = len(n.child) - n.nright
}
for i := 0; i < n.nleft; i++ {
dest, src := n.child[i], n.child[sbase+i]
if isNamedFuncSrc(src.typ) {
svalue[i] = genFuncValue(src)
} else {
svalue[i] = genDestValue(dest.typ, src)
}
if isMapEntry(dest) {
if isInterfaceSrc(dest.child[1].typ) { // key
ivalue[i] = genValueInterface(dest.child[1])
} else {
ivalue[i] = genValue(dest.child[1])
}
dvalue[i] = genValue(dest.child[0])
} else {
dvalue[i] = genValue(dest)
}
}
if n.nleft == 1 {
// Single assign operation.
switch s, d, i := svalue[0], dvalue[0], ivalue[0]; {
case n.child[0].ident == "_":
n.exec = func(f *frame) bltn {
return next
}
case i != nil:
n.exec = func(f *frame) bltn {
d(f).SetMapIndex(i(f), s(f))
return next
}
case n.kind == defineStmt:
l := n.level
ind := n.findex
n.exec = func(f *frame) bltn {
data := getFrame(f, l).data
data[ind] = reflect.New(data[ind].Type()).Elem()
data[ind].Set(s(f))
return next
}
default:
n.exec = func(f *frame) bltn {
d(f).Set(s(f))
return next
}
}
return
}
// Multi assign operation.
types := make([]reflect.Type, n.nright)
index := make([]int, n.nright)
level := make([]int, n.nright)
for i := range types {
var t reflect.Type
switch typ := n.child[sbase+i].typ; {
case isInterfaceSrc(typ):
t = valueInterfaceType
default:
t = typ.TypeOf()
}
types[i] = t
index[i] = n.child[i].findex
level[i] = n.child[i].level
}
if n.kind == defineStmt {
// Handle a multiple var declararation / assign. It cannot be a swap.
n.exec = func(f *frame) bltn {
for i, s := range svalue {
if n.child[i].ident == "_" {
continue
}
data := getFrame(f, level[i]).data
j := index[i]
data[j] = reflect.New(data[j].Type()).Elem()
data[j].Set(s(f))
}
return next
}
return
}
// To handle possible swap in multi-assign:
// evaluate and copy all values in assign right hand side into temporary
// then evaluate assign left hand side and copy temporary into it
n.exec = func(f *frame) bltn {
t := make([]reflect.Value, len(svalue))
for i, s := range svalue {
if n.child[i].ident == "_" {
continue
}
t[i] = reflect.New(types[i]).Elem()
t[i].Set(s(f))
}
for i, d := range dvalue {
if n.child[i].ident == "_" {
continue
}
if j := ivalue[i]; j != nil {
d(f).SetMapIndex(j(f), t[i]) // Assign a map entry
} else {
d(f).Set(t[i]) // Assign a var or array/slice entry
}
}
return next
}
}
func not(n *node) {
dest := genValue(n)
value := genValue(n.child[0])
tnext := getExec(n.tnext)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
if !value(f).Bool() {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
} else {
n.exec = func(f *frame) bltn {
dest(f).SetBool(!value(f).Bool())
return tnext
}
}
}
func addr(n *node) {
dest := genValue(n)
next := getExec(n.tnext)
c0 := n.child[0]
value := genValue(c0)
if isInterfaceSrc(c0.typ) || isPtrSrc(c0.typ) {
i := n.findex
l := n.level
n.exec = func(f *frame) bltn {
getFrame(f, l).data[i] = value(f).Addr()
return next
}
return
}
n.exec = func(f *frame) bltn {
dest(f).Set(value(f).Addr())
return next
}
}
func deref(n *node) {
value := genValue(n.child[0])
tnext := getExec(n.tnext)
i := n.findex
l := n.level
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
r := value(f).Elem()
if r.Bool() {
getFrame(f, l).data[i] = r
return tnext
}
return fnext
}
} else {
n.exec = func(f *frame) bltn {
getFrame(f, l).data[i] = value(f).Elem()
return tnext
}
}
}
func _print(n *node) {
child := n.child[1:]
values := make([]func(*frame) reflect.Value, len(child))
for i, c := range child {
values[i] = genValue(c)
}
out := n.interp.stdout
genBuiltinDeferWrapper(n, values, nil, func(args []reflect.Value) []reflect.Value {
for i, value := range args {
if i > 0 {
fmt.Fprintf(out, " ")
}
fmt.Fprintf(out, "%v", value)
}
return nil
})
}
func _println(n *node) {
child := n.child[1:]
values := make([]func(*frame) reflect.Value, len(child))
for i, c := range child {
values[i] = genValue(c)
}
out := n.interp.stdout
genBuiltinDeferWrapper(n, values, nil, func(args []reflect.Value) []reflect.Value {
for i, value := range args {
if i > 0 {
fmt.Fprintf(out, " ")
}
fmt.Fprintf(out, "%v", value)
}
fmt.Fprintln(out, "")
return nil
})
}
func _recover(n *node) {
tnext := getExec(n.tnext)
dest := genValue(n)
n.exec = func(f *frame) bltn {
if f.anc.recovered == nil {
// TODO(mpl): maybe we don't need that special case, and we're just forgetting to unwrap the valueInterface somewhere else.
if isEmptyInterface(n.typ) {
return tnext
}
dest(f).Set(reflect.ValueOf(valueInterface{}))
return tnext
}
if isEmptyInterface(n.typ) {
dest(f).Set(reflect.ValueOf(f.anc.recovered))
} else {
dest(f).Set(reflect.ValueOf(valueInterface{n, reflect.ValueOf(f.anc.recovered)}))
}
f.anc.recovered = nil
return tnext
}
}
func _panic(n *node) {
value := genValue(n.child[1])
n.exec = func(f *frame) bltn {
panic(value(f))
}
}
func genBuiltinDeferWrapper(n *node, in, out []func(*frame) reflect.Value, fn func([]reflect.Value) []reflect.Value) {
next := getExec(n.tnext)
if n.anc.kind == deferStmt {
n.exec = func(f *frame) bltn {
val := make([]reflect.Value, len(in)+1)
inTypes := make([]reflect.Type, len(in))
for i, v := range in {
val[i+1] = v(f)
inTypes[i] = val[i+1].Type()
}
outTypes := make([]reflect.Type, len(out))
for i, v := range out {
outTypes[i] = v(f).Type()
}
funcType := reflect.FuncOf(inTypes, outTypes, false)
val[0] = reflect.MakeFunc(funcType, fn)
f.deferred = append([][]reflect.Value{val}, f.deferred...)
return next
}
return
}
n.exec = func(f *frame) bltn {
val := make([]reflect.Value, len(in))
for i, v := range in {
val[i] = v(f)
}
dests := fn(val)
for i, dest := range dests {
out[i](f).Set(dest)
}
return next
}
}
func genFunctionWrapper(n *node) func(*frame) reflect.Value {
var def *node
var ok bool
if def, ok = n.val.(*node); !ok {
return genValueAsFunctionWrapper(n)
}
start := def.child[3].start
numRet := len(def.typ.ret)
var rcvr func(*frame) reflect.Value
if n.recv != nil {
rcvr = genValueRecv(n)
}
funcType := n.typ.TypeOf()
value := genValue(n)
var isDefer bool
if n.anc != nil && n.anc.anc != nil && n.anc.anc.kind == deferStmt {
isDefer = true
}
return func(f *frame) reflect.Value {
v := value(f)
if !isDefer && v.Kind() == reflect.Func {
// fixes #1634, if v is already a func, then don't re-wrap
// because original wrapping cloned the frame but this doesn't
return v
}
return reflect.MakeFunc(funcType, func(in []reflect.Value) []reflect.Value {
// Allocate and init local frame. All values to be settable and addressable.
fr := newFrame(f, len(def.types), f.runid())
d := fr.data
for i, t := range def.types {
d[i] = reflect.New(t).Elem()
}
if rcvr == nil {
d = d[numRet:]
} else {
// Copy method receiver as first argument.
src, dest := rcvr(f), d[numRet]
sk, dk := src.Kind(), dest.Kind()
for {
vs, ok := src.Interface().(valueInterface)
if !ok {
break
}
src = vs.value
sk = src.Kind()
}
switch {
case sk == reflect.Ptr && dk != reflect.Ptr:
dest.Set(src.Elem())
case sk != reflect.Ptr && dk == reflect.Ptr:
dest.Set(src.Addr())
default:
dest.Set(src)
}
d = d[numRet+1:]
}
// Copy function input arguments in local frame.
for i, arg := range in {
if i >= len(d) {
// In case of unused arg, there may be not even a frame entry allocated, just skip.
break
}
typ := def.typ.arg[i]
switch {
case isEmptyInterface(typ) || typ.TypeOf() == valueInterfaceType:
d[i].Set(arg)
case isInterfaceSrc(typ):
d[i].Set(reflect.ValueOf(valueInterface{value: arg.Elem()}))
default:
d[i].Set(arg)
}
}
// Interpreter code execution.
runCfg(start, fr, def, n)
return fr.data[:numRet]
})
}
}
func genInterfaceWrapper(n *node, typ reflect.Type) func(*frame) reflect.Value {
value := genValue(n)
if typ == nil || typ.Kind() != reflect.Interface || typ.NumMethod() == 0 || n.typ.cat == valueT {
return value
}
tc := n.typ.cat
if tc != structT {
// Always force wrapper generation for struct types, as they may contain
// embedded interface fields which require wrapping, even if reported as
// implementing typ by reflect.
if nt := n.typ.frameType(); nt != nil && nt.Implements(typ) {
return value
}
}
// Retrieve methods from the interface wrapper, which is a struct where all fields
// except the first define the methods to implement.
// As the field name was generated with a prefixed first character (in order to avoid
// collisions with method names), this first character is ignored in comparisons.
wrap := getWrapper(n, typ)
mn := wrap.NumField() - 1
names := make([]string, mn)
methods := make([]*node, mn)
indexes := make([][]int, mn)
for i := 0; i < mn; i++ {
names[i] = wrap.Field(i + 1).Name[1:]
methods[i], indexes[i] = n.typ.lookupMethod(names[i])
if methods[i] == nil && n.typ.cat != nilT {
// interpreted method not found, look for binary method, possibly embedded
_, indexes[i], _, _ = n.typ.lookupBinMethod(names[i])
}
}
return func(f *frame) reflect.Value {
v := value(f)
if tc != structT && v.Type().Implements(typ) {
return v
}
switch v.Kind() {
case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
if v.IsNil() {
return reflect.New(typ).Elem()
}
}
var n2 *node
if vi, ok := v.Interface().(valueInterface); ok {
n2 = vi.node
}
v = getConcreteValue(v)
w := reflect.New(wrap).Elem()
w.Field(0).Set(v)
for i, m := range methods {
if m == nil {
// First direct method lookup on field.
if r := methodByName(v, names[i], indexes[i]); r.IsValid() {
w.Field(i + 1).Set(r)
continue
}
if n2 == nil {
panic(n.cfgErrorf("method not found: %s", names[i]))
}
// Method lookup in embedded valueInterface.
m2, i2 := n2.typ.lookupMethod(names[i])
if m2 != nil {
nod := *m2
nod.recv = &receiver{n, v, i2}
w.Field(i + 1).Set(genFunctionWrapper(&nod)(f))
continue
}
panic(n.cfgErrorf("method not found: %s", names[i]))
}
nod := *m
nod.recv = &receiver{n, v, indexes[i]}
w.Field(i + 1).Set(genFunctionWrapper(&nod)(f))
}
return w
}
}
// methodByName returns the method corresponding to name on value, or nil if not found.
// The search is extended on valueInterface wrapper if present.
// If valid, the returned value is a method function with the receiver already set
// (no need to pass it at call).
func methodByName(value reflect.Value, name string, index []int) (v reflect.Value) {
if vi, ok := value.Interface().(valueInterface); ok {
if v = getConcreteValue(vi.value).MethodByName(name); v.IsValid() {
return
}
}
if v = value.MethodByName(name); v.IsValid() {
return
}
for value.Kind() == reflect.Ptr {
value = value.Elem()
if checkFieldIndex(value.Type(), index) {
value = value.FieldByIndex(index)
}
if v = value.MethodByName(name); v.IsValid() {
return
}
}
return
}
func checkFieldIndex(typ reflect.Type, index []int) bool {
if len(index) == 0 {
return false
}
t := typ
for t.Kind() == reflect.Ptr {
t = t.Elem()
}
if t.Kind() != reflect.Struct {
return false
}
i := index[0]
if i >= t.NumField() {
return false
}
if len(index) > 1 {
return checkFieldIndex(t.Field(i).Type, index[1:])
}
return true
}
func call(n *node) {
goroutine := n.anc.kind == goStmt
c0 := n.child[0]
value := genValue(c0)
var values []func(*frame) reflect.Value
numRet := len(c0.typ.ret)
variadic := variadicPos(n)
child := n.child[1:]
tnext := getExec(n.tnext)
fnext := getExec(n.fnext)
hasVariadicArgs := n.action == aCallSlice // callSlice implies variadic call with ellipsis.
// Compute input argument value functions.
for i, c := range child {
var arg *itype
if variadic >= 0 && i >= variadic {
arg = c0.typ.arg[variadic].val
} else {
arg = c0.typ.arg[i]
}
switch {
case isBinCall(c, c.scope):
// Handle nested function calls: pass returned values as arguments.
numOut := c.child[0].typ.rtype.NumOut()
for j := 0; j < numOut; j++ {
ind := c.findex + j
if hasVariadicArgs || !isInterfaceSrc(arg) || isEmptyInterface(arg) {
values = append(values, func(f *frame) reflect.Value { return f.data[ind] })
continue
}
values = append(values, func(f *frame) reflect.Value {
return reflect.ValueOf(valueInterface{value: f.data[ind]})
})
}
case isRegularCall(c):
// Arguments are return values of a nested function call.
cc0 := c.child[0]
for j := range cc0.typ.ret {
ind := c.findex + j
if hasVariadicArgs || !isInterfaceSrc(arg) || isEmptyInterface(arg) {
values = append(values, func(f *frame) reflect.Value { return f.data[ind] })
continue
}
values = append(values, func(f *frame) reflect.Value {
return reflect.ValueOf(valueInterface{node: cc0.typ.ret[j].node, value: f.data[ind]})
})
}
default:
if c.kind == basicLit || c.rval.IsValid() {
argType := arg.TypeOf()
convertLiteralValue(c, argType)
}
switch {
case hasVariadicArgs:
values = append(values, genValue(c))
case isInterfaceSrc(arg) && (!isEmptyInterface(arg) || len(c.typ.method) > 0):
values = append(values, genValueInterface(c))
case isInterfaceBin(arg):
values = append(values, genInterfaceWrapper(c, arg.rtype))
case isFuncSrc(arg):
values = append(values, genFuncValue(c))
default:
values = append(values, genValue(c))
}
}
}
// Compute output argument value functions.
rtypes := c0.typ.ret
rvalues := make([]func(*frame) reflect.Value, len(rtypes))
switch n.anc.kind {
case defineXStmt, assignXStmt:
l := n.level
for i := range rvalues {
c := n.anc.child[i]
switch {
case c.ident == "_":
// Skip assigning return value to blank var.
case isInterfaceSrc(c.typ) && !isEmptyInterface(c.typ) && !isInterfaceSrc(rtypes[i]):
rvalues[i] = genValueInterfaceValue(c)
default:
j := n.findex + i
rvalues[i] = func(f *frame) reflect.Value { return getFrame(f, l).data[j] }
}
}
case returnStmt:
// Function call from a return statement: forward return values (always at frame start).
for i := range rtypes {
j := n.findex + i
// Set the return value location in return value of caller frame.
rvalues[i] = func(f *frame) reflect.Value { return f.data[j] }
}
default:
// Multiple return values frame index are indexed from the node frame index.
l := n.level
for i := range rtypes {
j := n.findex + i
rvalues[i] = func(f *frame) reflect.Value { return getFrame(f, l).data[j] }
}
}
if n.anc.kind == deferStmt {
// Store function call in frame for deferred execution.
value = genFunctionWrapper(c0)
n.exec = func(f *frame) bltn {
val := make([]reflect.Value, len(values)+1)
val[0] = value(f)
for i, v := range values {
val[i+1] = v(f)
}
f.deferred = append([][]reflect.Value{val}, f.deferred...)
return tnext
}
return
}
n.exec = func(f *frame) bltn {
f.mutex.Lock()
bf := value(f)
def, ok := bf.Interface().(*node)
if ok {
bf = def.rval
}
f.mutex.Unlock()
// Call bin func if defined
if bf.IsValid() {
var callf func([]reflect.Value) []reflect.Value
// Lambda definitions are necessary here. Due to reflect internals,
// having `callf = bf.Call` or `callf = bf.CallSlice` does not work.
//nolint:gocritic
if hasVariadicArgs {
callf = func(in []reflect.Value) []reflect.Value { return bf.CallSlice(in) }
} else {
callf = func(in []reflect.Value) []reflect.Value { return bf.Call(in) }
}
if goroutine {
// Goroutine's arguments should be copied.
in := make([]reflect.Value, len(values))
for i, v := range values {
value := v(f)
in[i] = reflect.New(value.Type()).Elem()
in[i].Set(value)
}
go callf(in)
return tnext
}
in := make([]reflect.Value, len(values))
for i, v := range values {
in[i] = v(f)
}
out := callf(in)
for i, v := range rvalues {
if v != nil {
v(f).Set(out[i])
}
}
if fnext != nil && !out[0].Bool() {
return fnext
}
return tnext
}
nf := newFrame(f, len(def.types), f.runid())
var vararg reflect.Value
// Init return values
for i, v := range rvalues {
if v != nil {
nf.data[i] = v(f)
} else {
nf.data[i] = reflect.New(def.types[i]).Elem()
}
}
// Init local frame values
for i, t := range def.types[numRet:] {
nf.data[numRet+i] = reflect.New(t).Elem()
}
// Init variadic argument vector
if variadic >= 0 {
vararg = nf.data[numRet+variadic]
}
// Copy input parameters from caller
if dest := nf.data[numRet:]; len(dest) > 0 {
for i, v := range values {
switch {
case variadic >= 0 && i >= variadic:
if v(f).Type() == vararg.Type() {
vararg.Set(v(f))
} else {
vararg.Set(reflect.Append(vararg, v(f)))
}
default:
val := v(f)
if val.IsZero() && dest[i].Kind() != reflect.Interface {
// Work around a recursive struct zero interface issue.
// Once there is a better way to handle this case, the dest can just be set.
continue
}
if nod, ok := val.Interface().(*node); ok && nod.recv != nil {
// An interpreted method is passed as value in a function call.
// It must be wrapped now, otherwise the receiver will be missing
// at the method call (#1332).
// TODO (marc): wrapping interpreted functions should be always done
// everywhere at runtime to simplify the whole code,
// but it requires deeper refactoring.
dest[i] = genFunctionWrapper(nod)(f)
continue
}
dest[i].Set(val)
}
}
}
// Execute function body
if goroutine {
go runCfg(def.child[3].start, nf, def, n)
return tnext
}
runCfg(def.child[3].start, nf, def, n)
// Set return values
for i, v := range rvalues {
if v != nil {
v(f).Set(nf.data[i])
}
}
// Handle branching according to boolean result
if fnext != nil && !nf.data[0].Bool() {
return fnext
}
return tnext
}
}
func getFrame(f *frame, l int) *frame {
switch l {
case globalFrame:
return f.root
case 0:
return f
case 1:
return f.anc
case 2:
return f.anc.anc
}
for ; l > 0; l-- {
f = f.anc
}
return f
}
// Callbin calls a function from a bin import, accessible through reflect.
func callBin(n *node) {
tnext := getExec(n.tnext)
fnext := getExec(n.fnext)
child := n.child[1:]
c0 := n.child[0]
value := genValue(c0)
var values []func(*frame) reflect.Value
funcType := c0.typ.rtype
wt := wrappedType(c0)
variadic := -1
if funcType.IsVariadic() {
variadic = funcType.NumIn() - 1
}
// A method signature obtained from reflect.Type includes receiver as 1st arg, except for interface types.
rcvrOffset := 0
if recv := c0.recv; recv != nil && !isInterface(recv.node.typ) {
if variadic > 0 || funcType.NumIn() > len(child) {
rcvrOffset = 1
}
}
// getMapType returns a reflect type suitable for interface wrapper for functions
// with some special processing in case of interface{} argument, i.e. fmt.Printf.
var getMapType func(*itype) reflect.Type
if lr, ok := n.interp.mapTypes[c0.rval]; ok {
getMapType = func(typ *itype) reflect.Type {
for _, rt := range lr {
if typ.implements(&itype{cat: valueT, rtype: rt}) {
return rt
}
}
return nil
}
}
// Determine if we should use `Call` or `CallSlice` on the function Value.
callFn := func(v reflect.Value, in []reflect.Value) []reflect.Value { return v.Call(in) }
if n.action == aCallSlice {
callFn = func(v reflect.Value, in []reflect.Value) []reflect.Value { return v.CallSlice(in) }
}
for i, c := range child {
switch {
case isBinCall(c, c.scope):
// Handle nested function calls: pass returned values as arguments
numOut := c.child[0].typ.rtype.NumOut()
for j := 0; j < numOut; j++ {
ind := c.findex + j
values = append(values, func(f *frame) reflect.Value { return valueInterfaceValue(f.data[ind]) })
}
case isRegularCall(c):
// Handle nested function calls: pass returned values as arguments
for j := range c.child[0].typ.ret {
ind := c.findex + j
values = append(values, func(f *frame) reflect.Value { return valueInterfaceValue(f.data[ind]) })
}
default:
if c.kind == basicLit || c.rval.IsValid() {
// Convert literal value (untyped) to function argument type (if not an interface{})
var argType reflect.Type
if variadic >= 0 && i+rcvrOffset >= variadic {
argType = funcType.In(variadic).Elem()
} else {
argType = funcType.In(i + rcvrOffset)
}
convertLiteralValue(c, argType)
if !reflect.ValueOf(c.val).IsValid() { // Handle "nil"
c.val = reflect.Zero(argType)
}
}
if wt != nil && isInterfaceSrc(wt.arg[i]) {
values = append(values, genValueInterface(c))
break
}
// defType is the target type for a potential interface wrapper.
var defType reflect.Type
if variadic >= 0 && i+rcvrOffset >= variadic {
defType = funcType.In(variadic)
} else {
defType = funcType.In(rcvrOffset + i)
}
if getMapType != nil {
if rt := getMapType(c.typ); rt != nil {
defType = rt
}
}
switch {
case isEmptyInterface(c.typ):
values = append(values, genValue(c))
case isInterfaceSrc(c.typ):
values = append(values, genValueInterfaceValue(c))
case isFuncSrc(c.typ):
values = append(values, genFunctionWrapper(c))
case c.typ.cat == arrayT || c.typ.cat == variadicT:
if isEmptyInterface(c.typ.val) {
values = append(values, genValueArray(c))
} else {
values = append(values, genInterfaceWrapper(c, defType))
}
case isPtrSrc(c.typ):
if c.typ.val.cat == valueT {
values = append(values, genValue(c))
} else {
values = append(values, genInterfaceWrapper(c, defType))
}
case c.typ.cat == valueT:
values = append(values, genValue(c))
default:
values = append(values, genInterfaceWrapper(c, defType))
}
}
}
l := len(values)
switch {
case n.anc.kind == deferStmt:
// Store function call in frame for deferred execution.
n.exec = func(f *frame) bltn {
val := make([]reflect.Value, l+1)
val[0] = value(f)
for i, v := range values {
val[i+1] = getBinValue(getMapType, v, f)
}
f.deferred = append([][]reflect.Value{val}, f.deferred...)
return tnext
}
case n.anc.kind == goStmt:
// Execute function in a goroutine, discard results.
n.exec = func(f *frame) bltn {
in := make([]reflect.Value, l)
for i, v := range values {
in[i] = getBinValue(getMapType, v, f)
}
go callFn(value(f), in)
return tnext
}
case fnext != nil:
// Handle branching according to boolean result.
index := n.findex
level := n.level
n.exec = func(f *frame) bltn {
in := make([]reflect.Value, l)
for i, v := range values {
in[i] = getBinValue(getMapType, v, f)
}
res := callFn(value(f), in)
b := res[0].Bool()
getFrame(f, level).data[index].SetBool(b)
if b {
return tnext
}
return fnext
}
default:
switch n.anc.action {
case aAssignX:
// The function call is part of an assign expression, store results direcly
// to assigned location, to avoid an additional frame copy.
// The optimization of aAssign is handled in assign(), and should not
// be handled here.
rvalues := make([]func(*frame) reflect.Value, funcType.NumOut())
for i := range rvalues {
c := n.anc.child[i]
if c.ident == "_" {
continue
}
if isInterfaceSrc(c.typ) {
rvalues[i] = genValueInterfaceValue(c)
} else {
rvalues[i] = genValue(c)
}
}
n.exec = func(f *frame) bltn {
in := make([]reflect.Value, l)
for i, v := range values {
in[i] = getBinValue(getMapType, v, f)
}
out := callFn(value(f), in)
for i, v := range rvalues {
if v == nil {
continue // Skip assign "_".
}
c := n.anc.child[i]
if n.anc.kind == defineXStmt && !c.redeclared {
// In case of a define statement, the destination value in the frame
// must be recreated. This is necessary to preserve the previous value
// which may be still used in a separate closure.
data := getFrame(f, c.level).data
data[c.findex] = reflect.New(data[c.findex].Type()).Elem()
data[c.findex].Set(out[i])
continue
}
v(f).Set(out[i])
}
return tnext
}
case aReturn:
// The function call is part of a return statement, store output results
// directly in the frame location of outputs of the current function.
b := childPos(n)
n.exec = func(f *frame) bltn {
in := make([]reflect.Value, l)
for i, v := range values {
in[i] = getBinValue(getMapType, v, f)
}
out := callFn(value(f), in)
for i, v := range out {
dest := f.data[b+i]
if _, ok := dest.Interface().(valueInterface); ok {
v = reflect.ValueOf(valueInterface{value: v})
}
dest.Set(v)
}
return tnext
}
default:
n.exec = func(f *frame) bltn {
in := make([]reflect.Value, l)
for i, v := range values {
in[i] = getBinValue(getMapType, v, f)
}
out := callFn(value(f), in)
for i := 0; i < len(out); i++ {
r := out[i]
if r.Kind() == reflect.Func {
getFrame(f, n.level).data[n.findex+i] = r
continue
}
dest := getFrame(f, n.level).data[n.findex+i]
if _, ok := dest.Interface().(valueInterface); ok {
r = reflect.ValueOf(valueInterface{value: r})
}
dest.Set(r)
}
return tnext
}
}
}
}
func getIndexBinMethod(n *node) {
// dest := genValue(n)
i := n.findex
l := n.level
m := n.val.(int)
value := genValue(n.child[0])
next := getExec(n.tnext)
n.exec = func(f *frame) bltn {
// Can not use .Set() because dest type contains the receiver and source not
// dest(f).Set(value(f).Method(m))
getFrame(f, l).data[i] = value(f).Method(m)
return next
}
}
func getIndexBinElemMethod(n *node) {
i := n.findex
l := n.level
m := n.val.(int)
value := genValue(n.child[0])
next := getExec(n.tnext)
n.exec = func(f *frame) bltn {
// Can not use .Set() because dest type contains the receiver and source not
getFrame(f, l).data[i] = value(f).Elem().Method(m)
return next
}
}
func getIndexBinPtrMethod(n *node) {
i := n.findex
l := n.level
m := n.val.(int)
value := genValue(n.child[0])
next := getExec(n.tnext)
n.exec = func(f *frame) bltn {
// Can not use .Set() because dest type contains the receiver and source not
getFrame(f, l).data[i] = value(f).Addr().Method(m)
return next
}
}
// getIndexArray returns array value from index.
func getIndexArray(n *node) {
tnext := getExec(n.tnext)
value0 := genValueArray(n.child[0]) // array
i := n.findex
l := n.level
if n.child[1].rval.IsValid() { // constant array index
ai := int(vInt(n.child[1].rval))
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
r := value0(f).Index(ai)
getFrame(f, l).data[i] = r
if r.Bool() {
return tnext
}
return fnext
}
} else {
n.exec = func(f *frame) bltn {
getFrame(f, l).data[i] = value0(f).Index(ai)
return tnext
}
}
} else {
value1 := genValueInt(n.child[1]) // array index
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
_, vi := value1(f)
r := value0(f).Index(int(vi))
getFrame(f, l).data[i] = r
if r.Bool() {
return tnext
}
return fnext
}
} else {
n.exec = func(f *frame) bltn {
_, vi := value1(f)
getFrame(f, l).data[i] = value0(f).Index(int(vi))
return tnext
}
}
}
}
// getIndexMap retrieves map value from index.
func getIndexMap(n *node) {
dest := genValue(n)
value0 := genValue(n.child[0]) // map
tnext := getExec(n.tnext)
z := reflect.New(n.child[0].typ.frameType().Elem()).Elem()
if n.child[1].rval.IsValid() { // constant map index
mi := n.child[1].rval
switch {
case n.fnext != nil:
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
if v := value0(f).MapIndex(mi); v.IsValid() && v.Bool() {
dest(f).SetBool(true)
return tnext
}
dest(f).Set(z)
return fnext
}
default:
n.exec = func(f *frame) bltn {
if v := value0(f).MapIndex(mi); v.IsValid() {
dest(f).Set(v)
} else {
dest(f).Set(z)
}
return tnext
}
}
} else {
value1 := genValue(n.child[1]) // map index
switch {
case n.fnext != nil:
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
if v := value0(f).MapIndex(value1(f)); v.IsValid() && v.Bool() {
dest(f).SetBool(true)
return tnext
}
dest(f).Set(z)
return fnext
}
default:
n.exec = func(f *frame) bltn {
if v := value0(f).MapIndex(value1(f)); v.IsValid() {
dest(f).Set(v)
} else {
dest(f).Set(z)
}
return tnext
}
}
}
}
// getIndexMap2 retrieves map value from index and set status.
func getIndexMap2(n *node) {
dest := genValue(n.anc.child[0]) // result
value0 := genValue(n.child[0]) // map
value2 := genValue(n.anc.child[1]) // status
next := getExec(n.tnext)
doValue := n.anc.child[0].ident != "_"
doStatus := n.anc.child[1].ident != "_"
if !doValue && !doStatus {
nop(n)
return
}
if n.child[1].rval.IsValid() { // constant map index
mi := n.child[1].rval
switch {
case !doValue:
n.exec = func(f *frame) bltn {
v := value0(f).MapIndex(mi)
value2(f).SetBool(v.IsValid())
return next
}
default:
n.exec = func(f *frame) bltn {
v := value0(f).MapIndex(mi)
if v.IsValid() {
dest(f).Set(v)
}
if doStatus {
value2(f).SetBool(v.IsValid())
}
return next
}
}
} else {
value1 := genValue(n.child[1]) // map index
switch {
case !doValue:
n.exec = func(f *frame) bltn {
v := value0(f).MapIndex(value1(f))
value2(f).SetBool(v.IsValid())
return next
}
default:
n.exec = func(f *frame) bltn {
v := value0(f).MapIndex(value1(f))
if v.IsValid() {
dest(f).Set(v)
}
if doStatus {
value2(f).SetBool(v.IsValid())
}
return next
}
}
}
}
// getFunc compiles a closure function generator for anonymous functions.
func getFunc(n *node) {
i := n.findex
l := n.level
next := getExec(n.tnext)
numRet := len(n.typ.ret)
n.exec = func(f *frame) bltn {
fr := f.clone()
o := getFrame(f, l).data[i]
fct := reflect.MakeFunc(n.typ.TypeOf(), func(in []reflect.Value) []reflect.Value {
// Allocate and init local frame. All values to be settable and addressable.
fr2 := newFrame(fr, len(n.types), fr.runid())
d := fr2.data
for i, t := range n.types {
d[i] = reflect.New(t).Elem()
}
d = d[numRet:]
// Copy function input arguments in local frame.
for i, arg := range in {
if i >= len(d) {
// In case of unused arg, there may be not even a frame entry allocated, just skip.
break
}
typ := n.typ.arg[i]
switch {
case isEmptyInterface(typ) || typ.TypeOf() == valueInterfaceType:
d[i].Set(arg)
case isInterfaceSrc(typ):
d[i].Set(reflect.ValueOf(valueInterface{value: arg.Elem()}))
default:
d[i].Set(arg)
}
}
// Interpreter code execution.
runCfg(n.child[3].start, fr2, n, n)
f.mutex.Lock()
getFrame(f, l).data[i] = o
f.mutex.Unlock()
return fr2.data[:numRet]
})
f.mutex.Lock()
getFrame(f, l).data[i] = fct
f.mutex.Unlock()
return next
}
}
func getMethod(n *node) {
i := n.findex
l := n.level
next := getExec(n.tnext)
n.exec = func(f *frame) bltn {
nod := *(n.val.(*node))
nod.val = &nod
nod.recv = n.recv
getFrame(f, l).data[i] = genFuncValue(&nod)(f)
return next
}
}
func getMethodByName(n *node) {
next := getExec(n.tnext)
value0 := genValue(n.child[0])
name := n.child[1].ident
i := n.findex
l := n.level
n.exec = func(f *frame) bltn {
// The interface object must be directly accessible, or embedded in a struct (exported anonymous field).
val0 := value0(f)
val, ok := value0(f).Interface().(valueInterface)
if !ok {
// Search the first embedded valueInterface.
for val0.Kind() == reflect.Ptr {
val0 = val0.Elem()
}
for i := 0; i < val0.NumField(); i++ {
fld := val0.Type().Field(i)
if !fld.Anonymous || !fld.IsExported() {
continue
}
if val, ok = val0.Field(i).Interface().(valueInterface); ok {
break
// TODO: should we keep track of all the vals that are indeed valueInterface,
// so that later on we can call MethodByName on all of them until one matches?
}
}
if !ok {
panic(n.cfgErrorf("invalid interface value %v", val0))
}
}
// Traverse nested interface values to get the concrete value.
for {
v, ok := val.value.Interface().(valueInterface)
if !ok {
break
}
val = v
}
if met := val.value.MethodByName(name); met.IsValid() {
getFrame(f, l).data[i] = met
return next
}
typ := val.node.typ
if typ.node == nil && typ.cat == valueT {
// It happens with a var of empty interface type, that has value of concrete type
// from runtime, being asserted to "user-defined" interface.
if _, ok := typ.rtype.MethodByName(name); !ok {
panic(n.cfgErrorf("method not found: %s", name))
}
return next
}
// Finally search method recursively in embedded valueInterfaces.
r, m, li := lookupMethodValue(val, name)
if r.IsValid() {
getFrame(f, l).data[i] = r
return next
}
if m == nil {
panic(n.cfgErrorf("method not found: %s", name))
}
nod := *m
nod.val = &nod
nod.recv = &receiver{nil, val.value, li}
getFrame(f, l).data[i] = genFuncValue(&nod)(f)
return next
}
}
// lookupMethodValue recursively looks within val for the method with the given
// name. If a runtime value is found, it is returned in r, otherwise it is returned
// in m, with li as the list of recursive field indexes.
func lookupMethodValue(val valueInterface, name string) (r reflect.Value, m *node, li []int) {
if r = val.value.MethodByName(name); r.IsValid() {
return
}
if m, li = val.node.typ.lookupMethod(name); m != nil {
return
}
if !isStruct(val.node.typ) {
return
}
v := val.value
for v.Type().Kind() == reflect.Ptr {
v = v.Elem()
}
nf := v.NumField()
for i := 0; i < nf; i++ {
vi, ok := v.Field(i).Interface().(valueInterface)
if !ok {
continue
}
if r, m, li = lookupMethodValue(vi, name); m != nil {
li = append([]int{i}, li...)
return
}
}
return
}
func getIndexSeq(n *node) {
value := genValue(n.child[0])
index := n.val.([]int)
tnext := getExec(n.tnext)
i := n.findex
l := n.level
// Note:
// Here we have to store the result using
// f.data[i] = value(...)
// instead of normal
// dest(f).Set(value(...)
// because the value returned by FieldByIndex() must be preserved
// for possible future Set operations on the struct field (avoid a
// dereference from Set, resulting in setting a copy of the
// original field).
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
v := value(f)
r := v.FieldByIndex(index)
getFrame(f, l).data[i] = r
if r.Bool() {
return tnext
}
return fnext
}
} else {
n.exec = func(f *frame) bltn {
v := value(f)
getFrame(f, l).data[i] = v.FieldByIndex(index)
return tnext
}
}
}
func getPtrIndexSeq(n *node) {
index := n.val.([]int)
tnext := getExec(n.tnext)
value := genValue(n.child[0])
i := n.findex
l := n.level
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
r := value(f).Elem().FieldByIndex(index)
getFrame(f, l).data[i] = r
if r.Bool() {
return tnext
}
return fnext
}
} else {
n.exec = func(f *frame) bltn {
getFrame(f, l).data[i] = value(f).Elem().FieldByIndex(index)
return tnext
}
}
}
func getIndexSeqField(n *node) {
value := genValue(n.child[0])
index := n.val.([]int)
i := n.findex
l := n.level
tnext := getExec(n.tnext)
if n.fnext != nil {
fnext := getExec(n.fnext)
if n.child[0].typ.TypeOf().Kind() == reflect.Ptr {
n.exec = func(f *frame) bltn {
r := value(f).Elem().FieldByIndex(index)
getFrame(f, l).data[i] = r
if r.Bool() {
return tnext
}
return fnext
}
} else {
n.exec = func(f *frame) bltn {
r := value(f).FieldByIndex(index)
getFrame(f, l).data[i] = r
if r.Bool() {
return tnext
}
return fnext
}
}
} else {
if n.child[0].typ.TypeOf().Kind() == reflect.Ptr {
n.exec = func(f *frame) bltn {
getFrame(f, l).data[i] = value(f).Elem().FieldByIndex(index)
return tnext
}
} else {
n.exec = func(f *frame) bltn {
getFrame(f, l).data[i] = value(f).FieldByIndex(index)
return tnext
}
}
}
}
func getIndexSeqPtrMethod(n *node) {
value := genValue(n.child[0])
index := n.val.([]int)
fi := index[1:]
mi := index[0]
i := n.findex
l := n.level
next := getExec(n.tnext)
if n.child[0].typ.TypeOf().Kind() == reflect.Ptr {
if len(fi) == 0 {
n.exec = func(f *frame) bltn {
getFrame(f, l).data[i] = value(f).Method(mi)
return next
}
} else {
n.exec = func(f *frame) bltn {
getFrame(f, l).data[i] = value(f).Elem().FieldByIndex(fi).Addr().Method(mi)
return next
}
}
} else {
if len(fi) == 0 {
n.exec = func(f *frame) bltn {
getFrame(f, l).data[i] = value(f).Addr().Method(mi)
return next
}
} else {
n.exec = func(f *frame) bltn {
getFrame(f, l).data[i] = value(f).FieldByIndex(fi).Addr().Method(mi)
return next
}
}
}
}
func getIndexSeqMethod(n *node) {
value := genValue(n.child[0])
index := n.val.([]int)
fi := index[1:]
mi := index[0]
i := n.findex
l := n.level
next := getExec(n.tnext)
if n.child[0].typ.TypeOf().Kind() == reflect.Ptr {
if len(fi) == 0 {
n.exec = func(f *frame) bltn {
getFrame(f, l).data[i] = value(f).Elem().Method(mi)
return next
}
} else {
n.exec = func(f *frame) bltn {
getFrame(f, l).data[i] = value(f).Elem().FieldByIndex(fi).Method(mi)
return next
}
}
} else {
if len(fi) == 0 {
n.exec = func(f *frame) bltn {
getFrame(f, l).data[i] = value(f).Method(mi)
return next
}
} else {
n.exec = func(f *frame) bltn {
getFrame(f, l).data[i] = value(f).FieldByIndex(fi).Method(mi)
return next
}
}
}
}
func neg(n *node) {
dest := genValue(n)
value := genValue(n.child[0])
next := getExec(n.tnext)
typ := n.typ.concrete().TypeOf()
isInterface := n.typ.TypeOf().Kind() == reflect.Interface
switch n.typ.TypeOf().Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
if isInterface {
n.exec = func(f *frame) bltn {
dest(f).Set(reflect.ValueOf(-value(f).Int()).Convert(typ))
return next
}
return
}
n.exec = func(f *frame) bltn {
dest(f).SetInt(-value(f).Int())
return next
}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
if isInterface {
n.exec = func(f *frame) bltn {
dest(f).Set(reflect.ValueOf(-value(f).Uint()).Convert(typ))
return next
}
return
}
n.exec = func(f *frame) bltn {
dest(f).SetUint(-value(f).Uint())
return next
}
case reflect.Float32, reflect.Float64:
if isInterface {
n.exec = func(f *frame) bltn {
dest(f).Set(reflect.ValueOf(-value(f).Float()).Convert(typ))
return next
}
return
}
n.exec = func(f *frame) bltn {
dest(f).SetFloat(-value(f).Float())
return next
}
case reflect.Complex64, reflect.Complex128:
if isInterface {
n.exec = func(f *frame) bltn {
dest(f).Set(reflect.ValueOf(-value(f).Complex()).Convert(typ))
return next
}
return
}
n.exec = func(f *frame) bltn {
dest(f).SetComplex(-value(f).Complex())
return next
}
}
}
func pos(n *node) {
dest := genValue(n)
value := genValue(n.child[0])
next := getExec(n.tnext)
n.exec = func(f *frame) bltn {
dest(f).Set(value(f))
return next
}
}
func bitNot(n *node) {
dest := genValue(n)
value := genValue(n.child[0])
next := getExec(n.tnext)
typ := n.typ.concrete().TypeOf()
isInterface := n.typ.TypeOf().Kind() == reflect.Interface
switch typ.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
if isInterface {
n.exec = func(f *frame) bltn {
dest(f).Set(reflect.ValueOf(^value(f).Int()).Convert(typ))
return next
}
return
}
n.exec = func(f *frame) bltn {
dest(f).SetInt(^value(f).Int())
return next
}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
if isInterface {
n.exec = func(f *frame) bltn {
dest(f).Set(reflect.ValueOf(^value(f).Uint()).Convert(typ))
return next
}
return
}
n.exec = func(f *frame) bltn {
dest(f).SetUint(^value(f).Uint())
return next
}
}
}
func land(n *node) {
value0 := genValue(n.child[0])
value1 := genValue(n.child[1])
tnext := getExec(n.tnext)
dest := genValue(n)
typ := n.typ.concrete().TypeOf()
isInterface := n.typ.TypeOf().Kind() == reflect.Interface
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
if value0(f).Bool() && value1(f).Bool() {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
return
}
if isInterface {
n.exec = func(f *frame) bltn {
dest(f).Set(reflect.ValueOf(value0(f).Bool() && value1(f).Bool()).Convert(typ))
return tnext
}
return
}
n.exec = func(f *frame) bltn {
dest(f).SetBool(value0(f).Bool() && value1(f).Bool())
return tnext
}
}
func lor(n *node) {
value0 := genValue(n.child[0])
value1 := genValue(n.child[1])
tnext := getExec(n.tnext)
dest := genValue(n)
typ := n.typ.concrete().TypeOf()
isInterface := n.typ.TypeOf().Kind() == reflect.Interface
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
if value0(f).Bool() || value1(f).Bool() {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
return
}
if isInterface {
n.exec = func(f *frame) bltn {
dest(f).Set(reflect.ValueOf(value0(f).Bool() || value1(f).Bool()).Convert(typ))
return tnext
}
return
}
n.exec = func(f *frame) bltn {
dest(f).SetBool(value0(f).Bool() || value1(f).Bool())
return tnext
}
}
func nop(n *node) {
next := getExec(n.tnext)
n.exec = func(f *frame) bltn {
return next
}
}
func branch(n *node) {
tnext := getExec(n.tnext)
fnext := getExec(n.fnext)
value := genValue(n)
n.exec = func(f *frame) bltn {
if value(f).Bool() {
return tnext
}
return fnext
}
}
func _return(n *node) {
child := n.child
def := n.val.(*node)
values := make([]func(*frame) reflect.Value, len(child))
for i, c := range child {
switch t := def.typ.ret[i]; t.cat {
case errorT:
values[i] = genInterfaceWrapper(c, t.TypeOf())
case funcT:
values[i] = genValue(c)
case valueT:
switch t.rtype.Kind() {
case reflect.Interface:
values[i] = genInterfaceWrapper(c, t.TypeOf())
continue
case reflect.Func:
values[i] = genFunctionWrapper(c)
continue
}
fallthrough
default:
switch {
case isInterfaceSrc(t):
if len(t.field) == 0 {
// empty interface case.
// we can't let genValueInterface deal with it, because we call on c,
// not on n, which means that the interfaceT knowledge is lost.
values[i] = genValue(c)
break
}
values[i] = genValueInterface(c)
case c.typ.untyped:
values[i] = genValueAs(c, t.TypeOf())
default:
values[i] = genValue(c)
}
}
}
switch len(child) {
case 0:
n.exec = nil
case 1:
switch {
case !child[0].rval.IsValid() && child[0].kind == binaryExpr:
// No additional runtime operation is necessary for constants (not in frame) or
// binary expressions (stored directly at the right location in frame).
n.exec = nil
case isCall(child[0]) && n.child[0].typ.id() == def.typ.ret[0].id():
// Calls are optmized as long as no type conversion is involved.
n.exec = nil
default:
// Regular return: store the value to return at to start of the frame.
v := values[0]
n.exec = func(f *frame) bltn {
f.data[0].Set(v(f))
return nil
}
}
case 2:
v0, v1 := values[0], values[1]
n.exec = func(f *frame) bltn {
f.data[0].Set(v0(f))
f.data[1].Set(v1(f))
return nil
}
default:
n.exec = func(f *frame) bltn {
for i, value := range values {
f.data[i].Set(value(f))
}
return nil
}
}
}
func arrayLit(n *node) {
value := valueGenerator(n, n.findex)
next := getExec(n.tnext)
child := n.child
if n.nleft == 1 {
child = n.child[1:]
}
values := make([]func(*frame) reflect.Value, len(child))
index := make([]int, len(child))
var max, prev int
ntyp := n.typ.resolveAlias()
for i, c := range child {
if c.kind == keyValueExpr {
values[i] = genDestValue(ntyp.val, c.child[1])
index[i] = int(vInt(c.child[0].rval))
} else {
values[i] = genDestValue(ntyp.val, c)
index[i] = prev
}
prev = index[i] + 1
if prev > max {
max = prev
}
}
typ := n.typ.frameType()
kind := typ.Kind()
n.exec = func(f *frame) bltn {
var a reflect.Value
if kind == reflect.Slice {
a = reflect.MakeSlice(typ, max, max)
} else {
a, _ = n.typ.zero()
}
for i, v := range values {
a.Index(index[i]).Set(v(f))
}
value(f).Set(a)
return next
}
}
func mapLit(n *node) {
value := valueGenerator(n, n.findex)
next := getExec(n.tnext)
child := n.child
if n.nleft == 1 {
child = n.child[1:]
}
typ := n.typ.frameType()
keys := make([]func(*frame) reflect.Value, len(child))
values := make([]func(*frame) reflect.Value, len(child))
for i, c := range child {
keys[i] = genDestValue(n.typ.key, c.child[0])
values[i] = genDestValue(n.typ.val, c.child[1])
}
n.exec = func(f *frame) bltn {
m := reflect.MakeMap(typ)
for i, k := range keys {
m.SetMapIndex(k(f), values[i](f))
}
value(f).Set(m)
return next
}
}
func compositeBinMap(n *node) {
value := valueGenerator(n, n.findex)
next := getExec(n.tnext)
child := n.child
if n.nleft == 1 {
child = n.child[1:]
}
typ := n.typ.frameType()
keys := make([]func(*frame) reflect.Value, len(child))
values := make([]func(*frame) reflect.Value, len(child))
for i, c := range child {
convertLiteralValue(c.child[0], typ.Key())
convertLiteralValue(c.child[1], typ.Elem())
keys[i] = genValue(c.child[0])
if isFuncSrc(c.child[1].typ) {
values[i] = genFunctionWrapper(c.child[1])
} else {
values[i] = genValue(c.child[1])
}
}
n.exec = func(f *frame) bltn {
m := reflect.MakeMap(typ)
for i, k := range keys {
m.SetMapIndex(k(f), values[i](f))
}
value(f).Set(m)
return next
}
}
func compositeBinSlice(n *node) {
value := valueGenerator(n, n.findex)
next := getExec(n.tnext)
child := n.child
if n.nleft == 1 {
child = n.child[1:]
}
values := make([]func(*frame) reflect.Value, len(child))
index := make([]int, len(child))
rtype := n.typ.rtype.Elem()
var max, prev int
for i, c := range child {
if c.kind == keyValueExpr {
convertLiteralValue(c.child[1], rtype)
values[i] = genValue(c.child[1])
index[i] = int(vInt(c.child[0].rval))
} else {
convertLiteralValue(c, rtype)
values[i] = genValue(c)
index[i] = prev
}
prev = index[i] + 1
if prev > max {
max = prev
}
}
typ := n.typ.frameType()
kind := typ.Kind()
n.exec = func(f *frame) bltn {
var a reflect.Value
if kind == reflect.Slice {
a = reflect.MakeSlice(typ, max, max)
} else {
a, _ = n.typ.zero()
}
for i, v := range values {
a.Index(index[i]).Set(v(f))
}
value(f).Set(a)
return next
}
}
// doCompositeBinStruct creates and populates a struct object from a binary type.
func doCompositeBinStruct(n *node, hasType bool) {
next := getExec(n.tnext)
value := valueGenerator(n, n.findex)
typ := baseType(n.typ).rtype
child := n.child
if hasType {
child = n.child[1:]
}
values := make([]func(*frame) reflect.Value, len(child))
fieldIndex := make([][]int, len(child))
for i, c := range child {
if c.kind == keyValueExpr {
if sf, ok := typ.FieldByName(c.child[0].ident); ok {
fieldIndex[i] = sf.Index
convertLiteralValue(c.child[1], sf.Type)
if isFuncSrc(c.child[1].typ) {
values[i] = genFunctionWrapper(c.child[1])
} else {
values[i] = genValue(c.child[1])
}
}
} else {
fieldIndex[i] = []int{i}
if isFuncSrc(c.typ) && len(c.child) > 1 {
convertLiteralValue(c.child[1], typ.Field(i).Type)
values[i] = genFunctionWrapper(c.child[1])
} else {
convertLiteralValue(c, typ.Field(i).Type)
values[i] = genValue(c)
}
}
}
frameIndex := n.findex
l := n.level
n.exec = func(f *frame) bltn {
s := reflect.New(typ).Elem()
for i, v := range values {
s.FieldByIndex(fieldIndex[i]).Set(v(f))
}
d := value(f)
switch {
case d.Kind() == reflect.Ptr:
d.Set(s.Addr())
default:
getFrame(f, l).data[frameIndex] = s
}
return next
}
}
func compositeBinStruct(n *node) { doCompositeBinStruct(n, true) }
func compositeBinStructNotype(n *node) { doCompositeBinStruct(n, false) }
func destType(n *node) *itype {
switch n.anc.kind {
case assignStmt, defineStmt:
return n.anc.child[0].typ
default:
return n.typ
}
}
func doComposite(n *node, hasType bool, keyed bool) {
value := valueGenerator(n, n.findex)
next := getExec(n.tnext)
typ := baseType(n.typ)
child := n.child
if hasType {
child = n.child[1:]
}
destInterface := isInterfaceSrc(destType(n))
values := make(map[int]func(*frame) reflect.Value)
for i, c := range child {
var val *node
var fieldIndex int
if keyed {
val = c.child[1]
fieldIndex = typ.fieldIndex(c.child[0].ident)
} else {
val = c
fieldIndex = i
}
ft := typ.field[fieldIndex].typ
rft := ft.TypeOf()
convertLiteralValue(val, rft)
switch {
case val.typ.cat == nilT:
values[fieldIndex] = func(*frame) reflect.Value { return reflect.New(rft).Elem() }
case isNamedFuncSrc(val.typ):
values[fieldIndex] = genValueAsFunctionWrapper(val)
case isInterfaceSrc(ft) && (!isEmptyInterface(ft) || len(val.typ.method) > 0):
values[fieldIndex] = genValueInterface(val)
case isInterface(ft):
values[fieldIndex] = genInterfaceWrapper(val, rft)
default:
values[fieldIndex] = genValue(val)
}
}
frameIndex := n.findex
l := n.level
rt := typ.TypeOf()
n.exec = func(f *frame) bltn {
a := reflect.New(rt).Elem()
for i, v := range values {
a.Field(i).Set(v(f))
}
d := value(f)
switch {
case d.Kind() == reflect.Ptr:
d.Set(a.Addr())
case destInterface:
if len(destType(n).field) > 0 {
d.Set(reflect.ValueOf(valueInterface{n, a}))
break
}
d.Set(a)
default:
getFrame(f, l).data[frameIndex] = a
}
return next
}
}
// doCompositeLit creates and populates a struct object.
func doCompositeLit(n *node, hasType bool) {
doComposite(n, hasType, false)
}
func compositeLit(n *node) { doCompositeLit(n, true) }
func compositeLitNotype(n *node) { doCompositeLit(n, false) }
// doCompositeLitKeyed creates a struct Object, filling fields from sparse key-values.
func doCompositeLitKeyed(n *node, hasType bool) {
doComposite(n, hasType, true)
}
func compositeLitKeyed(n *node) { doCompositeLitKeyed(n, true) }
func compositeLitKeyedNotype(n *node) { doCompositeLitKeyed(n, false) }
func empty(n *node) {}
var rat = reflect.ValueOf((*[]rune)(nil)).Type().Elem() // runes array type
func _range(n *node) {
index0 := n.child[0].findex // array index location in frame
index2 := index0 - 1 // shallow array for range, always just behind index0
index3 := index2 - 1 // additional location to store string char position
fnext := getExec(n.fnext)
tnext := getExec(n.tnext)
var value func(*frame) reflect.Value
var an *node
if len(n.child) == 4 {
an = n.child[2]
index1 := n.child[1].findex // array value location in frame
if isString(an.typ.TypeOf()) {
// Special variant of "range" for string, where the index indicates the byte position
// of the rune in the string, rather than the index of the rune in array.
stringType := reflect.TypeOf("")
value = genValueAs(an, rat) // range on string iterates over runes
n.exec = func(f *frame) bltn {
a := f.data[index2]
v0 := f.data[index3]
v0.SetInt(v0.Int() + 1)
i := int(v0.Int())
if i >= a.Len() {
return fnext
}
// Compute byte position of the rune in string
pos := a.Slice(0, i).Convert(stringType).Len()
f.data[index0].SetInt(int64(pos))
f.data[index1].Set(a.Index(i))
return tnext
}
} else {
value = genValueRangeArray(an)
n.exec = func(f *frame) bltn {
a := f.data[index2]
v0 := f.data[index0]
v0.SetInt(v0.Int() + 1)
i := int(v0.Int())
if i >= a.Len() {
return fnext
}
f.data[index1].Set(a.Index(i))
return tnext
}
}
} else {
an = n.child[1]
if isString(an.typ.TypeOf()) {
value = genValueAs(an, rat) // range on string iterates over runes
} else {
value = genValueRangeArray(an)
}
n.exec = func(f *frame) bltn {
v0 := f.data[index0]
v0.SetInt(v0.Int() + 1)
if int(v0.Int()) >= f.data[index2].Len() {
return fnext
}
return tnext
}
}
// Init sequence
next := n.exec
index := index0
if isString(an.typ.TypeOf()) && len(n.child) == 4 {
index = index3
}
n.child[0].exec = func(f *frame) bltn {
f.data[index2] = value(f) // set array shallow copy for range
f.data[index].SetInt(-1) // assing index value
return next
}
}
func rangeInt(n *node) {
ixn := n.child[0]
index0 := ixn.findex // array index location in frame
index2 := index0 - 1 // max
fnext := getExec(n.fnext)
tnext := getExec(n.tnext)
var value func(*frame) reflect.Value
mxn := n.child[1]
value = genValue(mxn)
n.exec = func(f *frame) bltn {
rv := f.data[index0]
rv.SetInt(rv.Int() + 1)
if int(rv.Int()) >= int(f.data[index2].Int()) {
return fnext
}
return tnext
}
// Init sequence
next := n.exec
index := index0
ixn.exec = func(f *frame) bltn {
f.data[index2] = value(f) // set max
f.data[index].SetInt(-1) // assing index value
return next
}
}
func loopVarKey(n *node) {
ixn := n.anc.anc.child[0]
next := getExec(n.tnext)
n.exec = func(f *frame) bltn {
rv := f.data[ixn.findex]
nv := reflect.New(rv.Type()).Elem()
nv.Set(rv)
f.data[n.findex] = nv
return next
}
}
func loopVarVal(n *node) {
vln := n.anc.anc.child[1]
next := getExec(n.tnext)
n.exec = func(f *frame) bltn {
rv := f.data[vln.findex]
nv := reflect.New(rv.Type()).Elem()
nv.Set(rv)
f.data[n.findex] = nv
return next
}
}
func loopVarFor(n *node) {
ixn := n.anc.anc.child[0].child[0]
next := getExec(n.tnext)
n.exec = func(f *frame) bltn {
fv := f.data[ixn.findex]
nv := reflect.New(fv.Type()).Elem()
nv.Set(fv)
f.data[n.findex] = nv
return next
}
}
func rangeChan(n *node) {
i := n.child[0].findex // element index location in frame
value := genValue(n.child[1]) // chan
fnext := getExec(n.fnext)
tnext := getExec(n.tnext)
n.exec = func(f *frame) bltn {
f.mutex.RLock()
done := f.done
f.mutex.RUnlock()
chosen, v, ok := reflect.Select([]reflect.SelectCase{done, {Dir: reflect.SelectRecv, Chan: value(f)}})
if chosen == 0 {
return nil
}
if !ok {
return fnext
}
f.data[i].Set(v)
return tnext
}
}
func rangeMap(n *node) {
index0 := n.child[0].findex // map index location in frame
index2 := index0 - 1 // iterator for range, always just behind index0
fnext := getExec(n.fnext)
tnext := getExec(n.tnext)
value := genValue(n.child[len(n.child)-2]) // map value
if len(n.child) == 4 && n.child[1].ident != "_" {
index1 := n.child[1].findex // map value location in frame
n.exec = func(f *frame) bltn {
iter := f.data[index2].Interface().(*reflect.MapIter)
if !iter.Next() {
return fnext
}
f.data[index0].Set(iter.Key())
f.data[index1].Set(iter.Value())
return tnext
}
} else {
n.exec = func(f *frame) bltn {
iter := f.data[index2].Interface().(*reflect.MapIter)
if !iter.Next() {
return fnext
}
f.data[index0].Set(iter.Key())
return tnext
}
}
// Init sequence
next := n.exec
n.child[0].exec = func(f *frame) bltn {
f.data[index2].Set(reflect.ValueOf(value(f).MapRange()))
return next
}
}
func _case(n *node) {
tnext := getExec(n.tnext)
// TODO(mpl): a lot of what is done in typeAssert should probably be redone/reused here.
switch {
case n.anc.anc.kind == typeSwitch:
fnext := getExec(n.fnext)
sn := n.anc.anc // switch node
types := make([]*itype, len(n.child)-1)
for i := range types {
types[i] = n.child[i].typ
}
srcValue := genValue(sn.child[1].lastChild().child[0])
if len(sn.child[1].child) != 2 {
// no assign in switch guard
if len(n.child) <= 1 {
n.exec = func(f *frame) bltn { return tnext }
} else {
n.exec = func(f *frame) bltn {
ival := srcValue(f).Interface()
val, ok := ival.(valueInterface)
// TODO(mpl): I'm assuming here that !ok means that we're dealing with the empty
// interface case. But maybe we should make sure by checking the relevant cat
// instead? later. Use t := v.Type(); t.Kind() == reflect.Interface , like above.
if !ok {
var stype string
if ival != nil {
stype = strings.ReplaceAll(reflect.TypeOf(ival).String(), " {}", "{}")
}
for _, typ := range types {
// TODO(mpl): we should actually use canAssertTypes, but need to find a valid
// rtype for typ. Plus we need to refactor with typeAssert().
// weak check instead for now.
if ival == nil {
if typ.cat == nilT {
return tnext
}
continue
}
if stype == typ.id() {
return tnext
}
}
return fnext
}
if v := val.node; v != nil {
for _, typ := range types {
if v.typ.id() == typ.id() {
return tnext
}
}
}
return fnext
}
}
break
}
// assign in switch guard
destValue := genValue(n.lastChild().child[0])
switch len(types) {
case 0:
// default clause: assign var to interface value
n.exec = func(f *frame) bltn {
destValue(f).Set(srcValue(f))
return tnext
}
case 1:
// match against 1 type: assign var to concrete value
typ := types[0]
n.exec = func(f *frame) bltn {
v := srcValue(f)
if !v.IsValid() {
// match zero value against nil
if typ.cat == nilT {
return tnext
}
return fnext
}
if t := v.Type(); t.Kind() == reflect.Interface {
if typ.cat == nilT && v.IsNil() {
return tnext
}
rtyp := typ.TypeOf()
if rtyp == nil {
return fnext
}
elem := v.Elem()
if rtyp.String() == t.String() && implementsInterface(v, typ) {
destValue(f).Set(elem)
return tnext
}
ival := v.Interface()
if ival != nil && rtyp.String() == reflect.TypeOf(ival).String() {
destValue(f).Set(elem)
return tnext
}
if typ.cat == valueT && rtyp.Kind() == reflect.Interface && elem.IsValid() && elem.Type().Implements(rtyp) {
destValue(f).Set(elem)
return tnext
}
return fnext
}
if vi, ok := v.Interface().(valueInterface); ok {
if vi.node != nil {
if vi.node.typ.id() == typ.id() {
destValue(f).Set(vi.value)
return tnext
}
}
return fnext
}
if v.Type() == typ.TypeOf() {
destValue(f).Set(v)
return tnext
}
return fnext
}
default:
n.exec = func(f *frame) bltn {
val := srcValue(f)
if t := val.Type(); t.Kind() == reflect.Interface {
for _, typ := range types {
if typ.cat == nilT && val.IsNil() {
return tnext
}
rtyp := typ.TypeOf()
if rtyp == nil {
continue
}
elem := val.Elem()
if rtyp.String() == t.String() && implementsInterface(val, typ) {
destValue(f).Set(elem)
return tnext
}
ival := val.Interface()
if ival != nil && rtyp.String() == reflect.TypeOf(ival).String() {
destValue(f).Set(elem)
return tnext
}
if typ.cat == valueT && rtyp.Kind() == reflect.Interface && elem.IsValid() && elem.Type().Implements(rtyp) {
destValue(f).Set(elem)
return tnext
}
}
return fnext
}
if vi, ok := val.Interface().(valueInterface); ok {
if v := vi.node; v != nil {
for _, typ := range types {
if v.typ.id() == typ.id() {
destValue(f).Set(val)
return tnext
}
}
}
return fnext
}
vt := val.Type()
for _, typ := range types {
if vt == typ.TypeOf() {
destValue(f).Set(val)
return tnext
}
}
return fnext
}
}
case len(n.child) <= 1: // default clause
n.exec = func(f *frame) bltn { return tnext }
default:
fnext := getExec(n.fnext)
l := len(n.anc.anc.child)
value := genValue(n.anc.anc.child[l-2])
values := make([]func(*frame) reflect.Value, len(n.child)-1)
for i := range values {
values[i] = genValue(n.child[i])
}
n.exec = func(f *frame) bltn {
v0 := value(f)
for _, v := range values {
v1 := v(f)
if !v0.Type().AssignableTo(v1.Type()) {
v0 = v0.Convert(v1.Type())
}
if v0.Interface() == v1.Interface() {
return tnext
}
}
return fnext
}
}
}
func implementsInterface(v reflect.Value, t *itype) bool {
rt := v.Type()
if t.cat == valueT {
return rt.Implements(t.rtype)
}
vt := &itype{cat: valueT, rtype: rt}
if vt.methods().contains(t.methods()) {
return true
}
vi, ok := v.Interface().(valueInterface)
if !ok {
return false
}
return vi.node != nil && vi.node.typ.methods().contains(t.methods())
}
func appendSlice(n *node) {
dest := genValueOutput(n, n.typ.rtype)
next := getExec(n.tnext)
value := genValue(n.child[1])
value0 := genValue(n.child[2])
if isString(n.child[2].typ.TypeOf()) {
typ := reflect.TypeOf([]byte{})
n.exec = func(f *frame) bltn {
dest(f).Set(reflect.AppendSlice(value(f), value0(f).Convert(typ)))
return next
}
} else {
n.exec = func(f *frame) bltn {
dest(f).Set(reflect.AppendSlice(value(f), value0(f)))
return next
}
}
}
func _append(n *node) {
if len(n.child) == 3 {
c1, c2 := n.child[1], n.child[2]
if (c1.typ.cat == valueT || c2.typ.cat == valueT) && c1.typ.rtype == c2.typ.rtype ||
isArray(c2.typ) && c2.typ.elem().id() == n.typ.elem().id() ||
isByteArray(c1.typ.TypeOf()) && isString(c2.typ.TypeOf()) {
appendSlice(n)
return
}
}
dest := genValueOutput(n, n.typ.rtype)
value := genValue(n.child[1])
next := getExec(n.tnext)
switch l := len(n.child); {
case l == 2:
n.exec = func(f *frame) bltn {
dest(f).Set(value(f))
return next
}
case l > 3:
args := n.child[2:]
l := len(args)
values := make([]func(*frame) reflect.Value, l)
for i, arg := range args {
switch elem := n.typ.elem(); {
case isInterfaceSrc(elem) && (!isEmptyInterface(elem) || len(arg.typ.method) > 0):
values[i] = genValueInterface(arg)
case isInterfaceBin(elem):
values[i] = genInterfaceWrapper(arg, elem.rtype)
case arg.typ.untyped:
values[i] = genValueAs(arg, n.child[1].typ.TypeOf().Elem())
default:
values[i] = genValue(arg)
}
}
n.exec = func(f *frame) bltn {
sl := make([]reflect.Value, l)
for i, v := range values {
sl[i] = v(f)
}
dest(f).Set(reflect.Append(value(f), sl...))
return next
}
default:
var value0 func(*frame) reflect.Value
switch elem := n.typ.elem(); {
case isInterfaceSrc(elem) && (!isEmptyInterface(elem) || len(n.child[2].typ.method) > 0):
value0 = genValueInterface(n.child[2])
case isInterfaceBin(elem):
value0 = genInterfaceWrapper(n.child[2], elem.rtype)
case n.child[2].typ.untyped:
value0 = genValueAs(n.child[2], n.child[1].typ.TypeOf().Elem())
default:
value0 = genValue(n.child[2])
}
n.exec = func(f *frame) bltn {
dest(f).Set(reflect.Append(value(f), value0(f)))
return next
}
}
}
func _cap(n *node) {
dest := genValueOutput(n, reflect.TypeOf(int(0)))
value := genValue(n.child[1])
next := getExec(n.tnext)
if wantEmptyInterface(n) {
n.exec = func(f *frame) bltn {
dest(f).Set(reflect.ValueOf(value(f).Cap()))
return next
}
return
}
n.exec = func(f *frame) bltn {
dest(f).SetInt(int64(value(f).Cap()))
return next
}
}
func _copy(n *node) {
in := []func(*frame) reflect.Value{genValueArray(n.child[1]), genValue(n.child[2])}
out := []func(*frame) reflect.Value{genValueOutput(n, reflect.TypeOf(0))}
genBuiltinDeferWrapper(n, in, out, func(args []reflect.Value) []reflect.Value {
cnt := reflect.Copy(args[0], args[1])
return []reflect.Value{reflect.ValueOf(cnt)}
})
}
func _close(n *node) {
in := []func(*frame) reflect.Value{genValue(n.child[1])}
genBuiltinDeferWrapper(n, in, nil, func(args []reflect.Value) []reflect.Value {
args[0].Close()
return nil
})
}
func _complex(n *node) {
dest := genValueOutput(n, reflect.TypeOf(complex(0, 0)))
c1, c2 := n.child[1], n.child[2]
convertLiteralValue(c1, floatType)
convertLiteralValue(c2, floatType)
value0 := genValue(c1)
value1 := genValue(c2)
next := getExec(n.tnext)
typ := n.typ.TypeOf()
if isComplex(typ) {
if wantEmptyInterface(n) {
n.exec = func(f *frame) bltn {
dest(f).Set(reflect.ValueOf(complex(value0(f).Float(), value1(f).Float())))
return next
}
return
}
n.exec = func(f *frame) bltn {
dest(f).SetComplex(complex(value0(f).Float(), value1(f).Float()))
return next
}
return
}
// Not a complex type: ignore imaginary part
n.exec = func(f *frame) bltn {
dest(f).Set(value0(f).Convert(typ))
return next
}
}
func _imag(n *node) {
dest := genValueOutput(n, reflect.TypeOf(float64(0)))
convertLiteralValue(n.child[1], complexType)
value := genValue(n.child[1])
next := getExec(n.tnext)
if wantEmptyInterface(n) {
n.exec = func(f *frame) bltn {
dest(f).Set(reflect.ValueOf(imag(value(f).Complex())))
return next
}
return
}
n.exec = func(f *frame) bltn {
dest(f).SetFloat(imag(value(f).Complex()))
return next
}
}
func _real(n *node) {
dest := genValueOutput(n, reflect.TypeOf(float64(0)))
convertLiteralValue(n.child[1], complexType)
value := genValue(n.child[1])
next := getExec(n.tnext)
if wantEmptyInterface(n) {
n.exec = func(f *frame) bltn {
dest(f).Set(reflect.ValueOf(real(value(f).Complex())))
return next
}
return
}
n.exec = func(f *frame) bltn {
dest(f).SetFloat(real(value(f).Complex()))
return next
}
}
func _delete(n *node) {
value0 := genValue(n.child[1]) // map
value1 := genValue(n.child[2]) // key
in := []func(*frame) reflect.Value{value0, value1}
var z reflect.Value
genBuiltinDeferWrapper(n, in, nil, func(args []reflect.Value) []reflect.Value {
args[0].SetMapIndex(args[1], z)
return nil
})
}
func capConst(n *node) {
// There is no Cap() method for reflect.Type, just return Len() instead.
lenConst(n)
}
func lenConst(n *node) {
n.rval = reflect.New(reflect.TypeOf(int(0))).Elem()
c1 := n.child[1]
if c1.rval.IsValid() {
n.rval.SetInt(int64(len(vString(c1.rval))))
return
}
t := c1.typ.TypeOf()
for t.Kind() == reflect.Ptr {
t = t.Elem()
}
n.rval.SetInt(int64(t.Len()))
}
func _len(n *node) {
dest := genValueOutput(n, reflect.TypeOf(int(0)))
value := genValue(n.child[1])
if isPtr(n.child[1].typ) {
val := value
value = func(f *frame) reflect.Value {
v := val(f).Elem()
for v.Kind() == reflect.Ptr {
v = v.Elem()
}
return v
}
}
next := getExec(n.tnext)
if wantEmptyInterface(n) {
n.exec = func(f *frame) bltn {
dest(f).Set(reflect.ValueOf(value(f).Len()))
return next
}
return
}
n.exec = func(f *frame) bltn {
dest(f).SetInt(int64(value(f).Len()))
return next
}
}
func _new(n *node) {
next := getExec(n.tnext)
t1 := n.child[1].typ
typ := t1.TypeOf()
dest := genValueOutput(n, reflect.PtrTo(typ))
if isInterfaceSrc(t1) && (!isEmptyInterface(t1) || len(t1.method) > 0) {
typ = zeroInterfaceValue().Type()
}
n.exec = func(f *frame) bltn {
v := reflect.New(typ)
if vi, ok := v.Interface().(*valueInterface); ok {
vi.node = n
}
dest(f).Set(v)
return next
}
}
// _make allocates and initializes a slice, a map or a chan.
func _make(n *node) {
next := getExec(n.tnext)
typ := n.child[1].typ.frameType()
dest := genValueOutput(n, typ)
switch typ.Kind() {
case reflect.Array, reflect.Slice:
value := genValue(n.child[2])
switch len(n.child) {
case 3:
n.exec = func(f *frame) bltn {
length := int(vInt(value(f)))
dest(f).Set(reflect.MakeSlice(typ, length, length))
return next
}
case 4:
value1 := genValue(n.child[3])
n.exec = func(f *frame) bltn {
dest(f).Set(reflect.MakeSlice(typ, int(vInt(value(f))), int(vInt(value1(f)))))
return next
}
}
case reflect.Chan:
switch len(n.child) {
case 2:
n.exec = func(f *frame) bltn {
dest(f).Set(reflect.MakeChan(typ, 0))
return next
}
case 3:
value := genValue(n.child[2])
n.exec = func(f *frame) bltn {
dest(f).Set(reflect.MakeChan(typ, int(vInt(value(f)))))
return next
}
}
case reflect.Map:
switch len(n.child) {
case 2:
n.exec = func(f *frame) bltn {
dest(f).Set(reflect.MakeMap(typ))
return next
}
case 3:
value := genValue(n.child[2])
n.exec = func(f *frame) bltn {
dest(f).Set(reflect.MakeMapWithSize(typ, int(vInt(value(f)))))
return next
}
}
}
}
func reset(n *node) {
next := getExec(n.tnext)
switch l := len(n.child) - 1; l {
case 1:
typ := n.child[0].typ.frameType()
i := n.child[0].findex
n.exec = func(f *frame) bltn {
f.data[i] = reflect.New(typ).Elem()
return next
}
case 2:
c0, c1 := n.child[0], n.child[1]
i0, i1 := c0.findex, c1.findex
t0, t1 := c0.typ.frameType(), c1.typ.frameType()
n.exec = func(f *frame) bltn {
f.data[i0] = reflect.New(t0).Elem()
f.data[i1] = reflect.New(t1).Elem()
return next
}
default:
types := make([]reflect.Type, l)
index := make([]int, l)
for i, c := range n.child[:l] {
index[i] = c.findex
types[i] = c.typ.frameType()
}
n.exec = func(f *frame) bltn {
for i, ind := range index {
f.data[ind] = reflect.New(types[i]).Elem()
}
return next
}
}
}
// recv reads from a channel.
func recv(n *node) {
value := genValue(n.child[0])
tnext := getExec(n.tnext)
i := n.findex
l := n.level
if n.interp.cancelChan {
// Cancellable channel read
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
// Fast: channel read doesn't block
ch := value(f)
if r, ok := ch.TryRecv(); ok {
getFrame(f, l).data[i] = r
if r.Bool() {
return tnext
}
return fnext
}
// Slow: channel read blocks, allow cancel
f.mutex.RLock()
done := f.done
f.mutex.RUnlock()
chosen, v, _ := reflect.Select([]reflect.SelectCase{done, {Dir: reflect.SelectRecv, Chan: ch}})
if chosen == 0 {
return nil
}
if v.Bool() {
return tnext
}
return fnext
}
} else {
n.exec = func(f *frame) bltn {
// Fast: channel read doesn't block
ch := value(f)
if r, ok := ch.TryRecv(); ok {
getFrame(f, l).data[i] = r
return tnext
}
// Slow: channel is blocked, allow cancel
f.mutex.RLock()
done := f.done
f.mutex.RUnlock()
var chosen int
chosen, getFrame(f, l).data[i], _ = reflect.Select([]reflect.SelectCase{done, {Dir: reflect.SelectRecv, Chan: ch}})
if chosen == 0 {
return nil
}
return tnext
}
}
} else {
// Blocking channel read (less overhead)
if n.fnext != nil {
fnext := getExec(n.fnext)
n.exec = func(f *frame) bltn {
if r, _ := value(f).Recv(); r.Bool() {
getFrame(f, l).data[i] = r
return tnext
}
return fnext
}
} else {
i := n.findex
n.exec = func(f *frame) bltn {
getFrame(f, l).data[i], _ = value(f).Recv()
return tnext
}
}
}
}
func recv2(n *node) {
vchan := genValue(n.child[0]) // chan
vres := genValue(n.anc.child[0]) // result
vok := genValue(n.anc.child[1]) // status
tnext := getExec(n.tnext)
if n.interp.cancelChan {
// Cancellable channel read
n.exec = func(f *frame) bltn {
ch, result, status := vchan(f), vres(f), vok(f)
// Fast: channel read doesn't block
if v, ok := ch.TryRecv(); ok {
result.Set(v)
status.SetBool(true)
return tnext
}
// Slow: channel is blocked, allow cancel
f.mutex.RLock()
done := f.done
f.mutex.RUnlock()
chosen, v, ok := reflect.Select([]reflect.SelectCase{done, {Dir: reflect.SelectRecv, Chan: ch}})
if chosen == 0 {
return nil
}
result.Set(v)
status.SetBool(ok)
return tnext
}
} else {
// Blocking channel read (less overhead)
n.exec = func(f *frame) bltn {
v, ok := vchan(f).Recv()
vres(f).Set(v)
vok(f).SetBool(ok)
return tnext
}
}
}
func convertLiteralValue(n *node, t reflect.Type) {
switch {
case n.typ.cat == nilT:
// Create a zero value of target type.
n.rval = reflect.New(t).Elem()
case !(n.kind == basicLit || n.rval.IsValid()) || t == nil || t.Kind() == reflect.Interface || t == valueInterfaceType || t.Kind() == reflect.Slice && t.Elem().Kind() == reflect.Interface:
// Skip non-constant values, undefined target type or interface target type.
case n.rval.IsValid():
// Convert constant value to target type.
convertConstantValue(n)
n.rval = n.rval.Convert(t)
default:
// Create a zero value of target type.
n.rval = reflect.New(t).Elem()
}
}
func convertConstantValue(n *node) {
if !n.rval.IsValid() {
return
}
c, ok := n.rval.Interface().(constant.Value)
if !ok {
return
}
var v reflect.Value
switch c.Kind() {
case constant.Bool:
v = reflect.ValueOf(constant.BoolVal(c))
case constant.String:
v = reflect.ValueOf(constant.StringVal(c))
case constant.Int:
i, x := constant.Int64Val(c)
if !x {
panic(n.cfgErrorf("constant %s overflows int64", c.ExactString()))
}
v = reflect.ValueOf(int(i))
case constant.Float:
f, _ := constant.Float64Val(c)
v = reflect.ValueOf(f)
case constant.Complex:
r, _ := constant.Float64Val(constant.Real(c))
i, _ := constant.Float64Val(constant.Imag(c))
v = reflect.ValueOf(complex(r, i))
}
n.rval = v.Convert(n.typ.TypeOf())
}
// Write to a channel.
func send(n *node) {
next := getExec(n.tnext)
c0, c1 := n.child[0], n.child[1]
value0 := genValue(c0) // Send channel.
value1 := genDestValue(c0.typ.elem(), c1)
if !n.interp.cancelChan {
// Send is non-cancellable, has the least overhead.
n.exec = func(f *frame) bltn {
value0(f).Send(value1(f))
return next
}
return
}
// Send is cancellable, may have some overhead.
n.exec = func(f *frame) bltn {
ch, data := value0(f), value1(f)
// Fast: send on channel doesn't block.
if ok := ch.TrySend(data); ok {
return next
}
// Slow: send on channel blocks, allow cancel.
f.mutex.RLock()
done := f.done
f.mutex.RUnlock()
chosen, _, _ := reflect.Select([]reflect.SelectCase{done, {Dir: reflect.SelectSend, Chan: ch, Send: data}})
if chosen == 0 {
return nil
}
return next
}
}
func clauseChanDir(n *node) (*node, *node, *node, reflect.SelectDir) {
dir := reflect.SelectDefault
var nod, assigned, ok *node
var stop bool
n.Walk(func(m *node) bool {
switch m.action {
case aRecv:
dir = reflect.SelectRecv
nod = m.child[0]
switch m.anc.action {
case aAssign:
assigned = m.anc.child[0]
case aAssignX:
assigned = m.anc.child[0]
ok = m.anc.child[1]
}
stop = true
case aSend:
dir = reflect.SelectSend
nod = m.child[0]
assigned = m.child[1]
stop = true
}
return !stop
}, nil)
return nod, assigned, ok, dir
}
func _select(n *node) {
nbClause := len(n.child)
chans := make([]*node, nbClause)
assigned := make([]*node, nbClause)
ok := make([]*node, nbClause)
clause := make([]bltn, nbClause)
chanValues := make([]func(*frame) reflect.Value, nbClause)
assignedValues := make([]func(*frame) reflect.Value, nbClause)
okValues := make([]func(*frame) reflect.Value, nbClause)
cases := make([]reflect.SelectCase, nbClause+1)
next := getExec(n.tnext)
for i := 0; i < nbClause; i++ {
cl := n.child[i]
if cl.kind == commClauseDefault {
cases[i].Dir = reflect.SelectDefault
if len(cl.child) == 0 {
clause[i] = func(*frame) bltn { return next }
} else {
clause[i] = getExec(cl.child[0].start)
}
continue
}
// The comm clause is in send or recv direction.
switch c0 := cl.child[0]; {
case len(cl.child) > 1:
// The comm clause contains a channel operation and a clause body.
clause[i] = getExec(cl.child[1].start)
chans[i], assigned[i], ok[i], cases[i].Dir = clauseChanDir(c0)
chanValues[i] = genValue(chans[i])
if assigned[i] != nil {
assignedValues[i] = genValue(assigned[i])
}
if ok[i] != nil {
okValues[i] = genValue(ok[i])
}
case c0.kind == exprStmt && len(c0.child) == 1 && c0.child[0].action == aRecv:
// The comm clause has an empty body clause after channel receive.
chanValues[i] = genValue(c0.child[0].child[0])
cases[i].Dir = reflect.SelectRecv
clause[i] = func(*frame) bltn { return next }
case c0.kind == sendStmt:
// The comm clause as an empty body clause after channel send.
chanValues[i] = genValue(c0.child[0])
cases[i].Dir = reflect.SelectSend
assignedValues[i] = genValue(c0.child[1])
clause[i] = func(*frame) bltn { return next }
}
}
n.exec = func(f *frame) bltn {
f.mutex.RLock()
cases[nbClause] = f.done
f.mutex.RUnlock()
for i := range cases[:nbClause] {
switch cases[i].Dir {
case reflect.SelectRecv:
cases[i].Chan = chanValues[i](f)
case reflect.SelectSend:
cases[i].Chan = chanValues[i](f)
cases[i].Send = assignedValues[i](f)
case reflect.SelectDefault:
// Keep zero values for comm clause
}
}
j, v, s := reflect.Select(cases)
if j == nbClause {
return nil
}
if cases[j].Dir == reflect.SelectRecv && assignedValues[j] != nil {
assignedValues[j](f).Set(v)
if ok[j] != nil {
okValues[j](f).SetBool(s)
}
}
return clause[j]
}
}
// slice expression: array[low:high:max].
func slice(n *node) {
i := n.findex
l := n.level
next := getExec(n.tnext)
value0 := genValueArray(n.child[0]) // array
value1 := genValue(n.child[1]) // low (if 2 or 3 args) or high (if 1 arg)
switch len(n.child) {
case 2:
n.exec = func(f *frame) bltn {
a := value0(f)
getFrame(f, l).data[i] = a.Slice(int(vInt(value1(f))), a.Len())
return next
}
case 3:
value2 := genValue(n.child[2]) // max
n.exec = func(f *frame) bltn {
a := value0(f)
getFrame(f, l).data[i] = a.Slice(int(vInt(value1(f))), int(vInt(value2(f))))
return next
}
case 4:
value2 := genValue(n.child[2])
value3 := genValue(n.child[3])
n.exec = func(f *frame) bltn {
a := value0(f)
getFrame(f, l).data[i] = a.Slice3(int(vInt(value1(f))), int(vInt(value2(f))), int(vInt(value3(f))))
return next
}
}
}
// slice expression, no low value: array[:high:max].
func slice0(n *node) {
i := n.findex
l := n.level
next := getExec(n.tnext)
value0 := genValueArray(n.child[0])
switch len(n.child) {
case 1:
n.exec = func(f *frame) bltn {
a := value0(f)
getFrame(f, l).data[i] = a.Slice(0, a.Len())
return next
}
case 2:
value1 := genValue(n.child[1])
n.exec = func(f *frame) bltn {
a := value0(f)
getFrame(f, l).data[i] = a.Slice(0, int(vInt(value1(f))))
return next
}
case 3:
value1 := genValue(n.child[1])
value2 := genValue(n.child[2])
n.exec = func(f *frame) bltn {
a := value0(f)
getFrame(f, l).data[i] = a.Slice3(0, int(vInt(value1(f))), int(vInt(value2(f))))
return next
}
}
}
func isNilChild(child int) func(n *node) {
return func(n *node) {
var value func(*frame) reflect.Value
child := n.child[child]
value = genValue(child)
typ := n.typ.concrete().TypeOf()
isInterface := n.typ.TypeOf().Kind() == reflect.Interface
tnext := getExec(n.tnext)
dest := genValue(n)
if n.fnext == nil {
if !isInterfaceSrc(child.typ) {
if isInterface {
n.exec = func(f *frame) bltn {
dest(f).Set(reflect.ValueOf(value(f).IsNil()).Convert(typ))
return tnext
}
return
}
n.exec = func(f *frame) bltn {
dest(f).SetBool(value(f).IsNil())
return tnext
}
return
}
if isInterface {
n.exec = func(f *frame) bltn {
v := value(f)
var r bool
if vi, ok := v.Interface().(valueInterface); ok {
r = (vi == valueInterface{} || vi.node.kind == basicLit && vi.node.typ.cat == nilT)
} else {
r = v.IsNil()
}
dest(f).Set(reflect.ValueOf(r).Convert(typ))
return tnext
}
return
}
n.exec = func(f *frame) bltn {
v := value(f)
var r bool
if vi, ok := v.Interface().(valueInterface); ok {
r = (vi == valueInterface{} || vi.node.kind == basicLit && vi.node.typ.cat == nilT)
} else {
r = v.IsNil()
}
dest(f).SetBool(r)
return tnext
}
return
}
fnext := getExec(n.fnext)
if !isInterfaceSrc(child.typ) {
n.exec = func(f *frame) bltn {
if value(f).IsNil() {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
return
}
n.exec = func(f *frame) bltn {
v := value(f)
if vi, ok := v.Interface().(valueInterface); ok {
if (vi == valueInterface{} || vi.node.kind == basicLit && vi.node.typ.cat == nilT) {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
if v.IsNil() {
dest(f).SetBool(true)
return tnext
}
dest(f).SetBool(false)
return fnext
}
}
}
func isNotNil(n *node) {
var value func(*frame) reflect.Value
c0 := n.child[0]
value = genValue(c0)
typ := n.typ.concrete().TypeOf()
isInterface := n.typ.TypeOf().Kind() == reflect.Interface
tnext := getExec(n.tnext)
dest := genValue(n)
if n.fnext == nil {
if isInterfaceSrc(c0.typ) && c0.typ.TypeOf() != valueInterfaceType {
if isInterface {
n.exec = func(f *frame) bltn {
dest(f).Set(reflect.ValueOf(!value(f).IsNil()).Convert(typ))
return tnext
}
return
}
n.exec = func(f *frame) bltn {
dest(f).SetBool(!value(f).IsNil())
return tnext
}
return
}
if isInterface {
n.exec = func(f *frame) bltn {
v := value(f)
var r bool
if vi, ok := v.Interface().(valueInterface); ok {
r = (vi == valueInterface{} || vi.node.kind == basicLit && vi.node.typ.cat == nilT)
} else {
r = v.IsNil()
}
dest(f).Set(reflect.ValueOf(!r).Convert(typ))
return tnext
}
return
}
n.exec = func(f *frame) bltn {
v := value(f)
var r bool
if vi, ok := v.Interface().(valueInterface); ok {
r = (vi == valueInterface{} || vi.node.kind == basicLit && vi.node.typ.cat == nilT)
} else {
r = v.IsNil()
}
dest(f).SetBool(!r)
return tnext
}
return
}
fnext := getExec(n.fnext)
if isInterfaceSrc(c0.typ) && c0.typ.TypeOf() != valueInterfaceType {
n.exec = func(f *frame) bltn {
if value(f).IsNil() {
dest(f).SetBool(false)
return fnext
}
dest(f).SetBool(true)
return tnext
}
return
}
n.exec = func(f *frame) bltn {
v := value(f)
if vi, ok := v.Interface().(valueInterface); ok {
if (vi == valueInterface{} || vi.node.kind == basicLit && vi.node.typ.cat == nilT) {
dest(f).SetBool(false)
return fnext
}
dest(f).SetBool(true)
return tnext
}
if v.IsNil() {
dest(f).SetBool(false)
return fnext
}
dest(f).SetBool(true)
return tnext
}
}
func complexConst(n *node) {
if v0, v1 := n.child[1].rval, n.child[2].rval; v0.IsValid() && v1.IsValid() {
n.rval = reflect.ValueOf(complex(vFloat(v0), vFloat(v1)))
n.gen = nop
}
}
func imagConst(n *node) {
if v := n.child[1].rval; v.IsValid() {
n.rval = reflect.ValueOf(imag(v.Complex()))
n.gen = nop
}
}
func realConst(n *node) {
if v := n.child[1].rval; v.IsValid() {
n.rval = reflect.ValueOf(real(v.Complex()))
n.gen = nop
}
}
================================================
FILE: interp/scope.go
================================================
package interp
import (
"log"
"reflect"
"strconv"
)
// A sKind represents the kind of symbol.
type sKind uint
// Symbol kinds for the Go interpreter.
const (
undefSym sKind = iota
binSym // Binary from runtime
bltnSym // Builtin
constSym // Constant
funcSym // Function
labelSym // Label
pkgSym // Package
typeSym // Type
varTypeSym // Variable type (generic)
varSym // Variable
)
var symKinds = [...]string{
undefSym: "undefSym",
binSym: "binSym",
bltnSym: "bltnSym",
constSym: "constSym",
funcSym: "funcSym",
labelSym: "labelSym",
pkgSym: "pkgSym",
typeSym: "typeSym",
varTypeSym: "varTypeSym",
varSym: "varSym",
}
func (k sKind) String() string {
if k < sKind(len(symKinds)) {
return symKinds[k]
}
return "SymKind(" + strconv.Itoa(int(k)) + ")"
}
// A symbol represents an interpreter object such as type, constant, var, func,
// label, builtin or binary object. Symbols are defined within a scope.
type symbol struct {
kind sKind
typ *itype // Type of value
node *node // Node value if index is negative
from []*node // list of goto nodes jumping to this label node, or nil
recv *receiver // receiver node value, if sym refers to a method
index int // index of value in frame or -1
rval reflect.Value // default value (used for constants)
builtin bltnGenerator // Builtin function or nil
global bool // true if symbol is defined in global space
}
// scope type stores symbols in maps, and frame layout as array of types
// The purposes of scopes are to manage the visibility of each symbol
// and to store the memory frame layout information (type and index in frame)
// at each level (global, package, functions)
//
// scopes are organized in a stack fashion: a first scope (universe) is created
// once at global level, and for each block (package, func, for, etc...), a new
// scope is pushed at entry, and poped at exit.
//
// Nested scopes with the same level value use the same frame: it allows to have
// exactly one frame per function, with a fixed position for each variable (named
// or not), no matter the inner complexity (number of nested blocks in the function)
//
// In symbols, the index value corresponds to the index in scope.types, and at
// execution to the index in frame, created exactly from the types layout.
type scope struct {
anc *scope // ancestor upper scope
child []*scope // included scopes
def *node // function definition node this scope belongs to, or nil
loop *node // loop exit node for break statement
loopRestart *node // loop restart node for continue statement
pkgID string // unique id of package in which scope is defined
pkgName string // package name for the package
types []reflect.Type // frame layout, may be shared by same level scopes
level int // frame level: number of frame indirections to access var during execution
sym map[string]*symbol // map of symbols defined in this current scope
global bool // true if scope refers to global space (single frame for universe and package level scopes)
iota int // iota value in this scope
}
// push creates a new child scope and chain it to the current one.
func (s *scope) push(indirect bool) *scope {
sc := &scope{anc: s, level: s.level, sym: map[string]*symbol{}}
s.child = append(s.child, sc)
if indirect {
sc.types = []reflect.Type{}
sc.level = s.level + 1
} else {
// Propagate size, types, def and global as scopes at same level share the same frame.
sc.types = s.types
sc.def = s.def
sc.global = s.global
sc.level = s.level
}
// inherit loop state and pkgID from ancestor
sc.loop, sc.loopRestart, sc.pkgID = s.loop, s.loopRestart, s.pkgID
return sc
}
func (s *scope) pushBloc() *scope { return s.push(false) }
func (s *scope) pushFunc() *scope { return s.push(true) }
func (s *scope) pop() *scope {
if s.level == s.anc.level {
// Propagate size and types, as scopes at same level share the same frame.
s.anc.types = s.types
}
return s.anc
}
func (s *scope) upperLevel() *scope {
level := s.level
for s != nil && s.level == level {
s = s.anc
}
return s
}
// lookup searches for a symbol in the current scope, and upper ones if not found
// it returns the symbol, the number of indirections level from the current scope
// and status (false if no result).
func (s *scope) lookup(ident string) (*symbol, int, bool) {
level := s.level
for {
if sym, ok := s.sym[ident]; ok {
if sym.global {
return sym, globalFrame, true
}
return sym, level - s.level, true
}
if s.anc == nil {
break
}
s = s.anc
}
return nil, 0, false
}
func (s *scope) isRedeclared(n *node) bool {
if !isNewDefine(n, s) {
return false
}
// Existing symbol in the scope indicates a redeclaration.
return s.sym[n.ident] != nil
}
func (s *scope) rangeChanType(n *node) *itype {
if sym, _, found := s.lookup(n.child[1].ident); found {
if t := sym.typ; len(n.child) == 3 && t != nil && (t.cat == chanT || t.cat == chanRecvT) {
return t
}
}
c := n.child[1]
if c.typ == nil {
return nil
}
switch {
case c.typ.cat == chanT, c.typ.cat == chanRecvT:
return c.typ
case c.typ.cat == valueT && c.typ.rtype.Kind() == reflect.Chan:
dir := chanSendRecv
switch c.typ.rtype.ChanDir() {
case reflect.RecvDir:
dir = chanRecv
case reflect.SendDir:
dir = chanSend
}
return chanOf(valueTOf(c.typ.rtype.Elem()), dir)
}
return nil
}
// fixType returns the input type, or a valid default type for untyped constant.
func (s *scope) fixType(t *itype) *itype {
if !t.untyped || t.cat != valueT {
return t
}
switch typ := t.TypeOf(); typ.Kind() {
case reflect.Int64:
return s.getType("int")
case reflect.Uint64:
return s.getType("uint")
case reflect.Float64:
return s.getType("float64")
case reflect.Complex128:
return s.getType("complex128")
}
return t
}
func (s *scope) getType(ident string) *itype {
var t *itype
if sym, _, found := s.lookup(ident); found {
if sym.kind == typeSym {
t = sym.typ
}
}
return t
}
// add adds a type to the scope types array, and returns its index.
func (s *scope) add(typ *itype) (index int) {
if typ == nil {
log.Panic("nil type")
}
index = len(s.types)
t := typ.frameType()
if t == nil {
log.Panic("nil reflect type")
}
s.types = append(s.types, t)
return
}
func (interp *Interpreter) initScopePkg(pkgID, pkgName string) *scope {
sc := interp.universe
interp.mutex.Lock()
if _, ok := interp.scopes[pkgID]; !ok {
interp.scopes[pkgID] = sc.pushBloc()
}
sc = interp.scopes[pkgID]
sc.pkgID = pkgID
sc.pkgName = pkgName
interp.mutex.Unlock()
return sc
}
// Globals returns a map of global variables and constants in the main package.
func (interp *Interpreter) Globals() map[string]reflect.Value {
syms := map[string]reflect.Value{}
interp.mutex.RLock()
defer interp.mutex.RUnlock()
v, ok := interp.srcPkg["main"]
if !ok {
return syms
}
for n, s := range v {
switch s.kind {
case constSym:
syms[n] = s.rval
case varSym:
syms[n] = interp.frame.data[s.index]
}
}
return syms
}
================================================
FILE: interp/self_example_test.go
================================================
package interp_test
import (
"log"
"github.com/traefik/yaegi/interp"
"github.com/traefik/yaegi/stdlib"
)
func ExampleInterpreter_self() {
i := interp.New(interp.Options{})
if err := i.Use(stdlib.Symbols); err != nil {
log.Fatal(err)
}
if err := i.Use(interp.Symbols); err != nil {
log.Fatal(err)
}
_, err := i.Eval(`import (
"fmt"
"log"
// Import interp to gain access to Self.
"github.com/traefik/yaegi/interp"
)`)
if err != nil {
log.Fatal(err)
}
_, err = i.Eval(`
// Evaluate code directly.
fmt.Println("Hello Yaegi from Go")
// Evaluate code indirectly via the Self access point.
_, err := interp.Self.Eval("fmt.Println(\"Hello Yaegi from Yaegi\")")
if err != nil {
log.Fatal(err)
}
`)
if err != nil {
log.Fatal(err)
}
// Output:
//
// Hello Yaegi from Go
// Hello Yaegi from Yaegi
}
================================================
FILE: interp/src.go
================================================
package interp
import (
"errors"
"fmt"
"io/fs"
"path"
"path/filepath"
"strings"
)
// importSrc calls gta on the source code for the package identified by
// importPath. rPath is the relative path to the directory containing the source
// code for the package. It can also be "main" as a special value.
func (interp *Interpreter) importSrc(rPath, importPath string, skipTest bool) (string, error) {
var dir string
var err error
if interp.srcPkg[importPath] != nil {
name, ok := interp.pkgNames[importPath]
if !ok {
return "", fmt.Errorf("inconsistent knowledge about %s", importPath)
}
return name, nil
}
// For relative import paths in the form "./xxx" or "../xxx", the initial
// base path is the directory of the interpreter input file, or "." if no file
// was provided.
// In all other cases, absolute import paths are resolved from the GOPATH
// and the nested "vendor" directories.
if isPathRelative(importPath) {
if rPath == mainID {
rPath = "."
}
dir = path.Join(path.Dir(interp.name), rPath, importPath)
} else if dir, rPath, err = interp.pkgDir(filepath.ToSlash(interp.context.GOPATH), rPath, importPath); err != nil {
// Try again, assuming a root dir at the source location.
if rPath, err = interp.rootFromSourceLocation(); err != nil {
return "", err
}
if dir, rPath, err = interp.pkgDir(filepath.ToSlash(interp.context.GOPATH), rPath, importPath); err != nil {
return "", err
}
}
if interp.rdir[importPath] {
return "", fmt.Errorf("import cycle not allowed\n\timports %s", importPath)
}
interp.rdir[importPath] = true
files, err := fs.ReadDir(interp.opt.filesystem, dir)
if err != nil {
return "", err
}
var initNodes []*node
var rootNodes []*node
revisit := make(map[string][]*node)
var root *node
var pkgName string
// Parse source files.
for _, file := range files {
name := file.Name()
if skipFile(&interp.context, name, skipTest) {
continue
}
name = path.Join(dir, name)
var buf []byte
if buf, err = fs.ReadFile(interp.opt.filesystem, name); err != nil {
return "", err
}
n, err := interp.parse(string(buf), name, false)
if err != nil {
return "", err
}
if n == nil {
continue
}
var pname string
if pname, root, err = interp.ast(n); err != nil {
return "", err
}
if root == nil {
continue
}
if interp.astDot {
dotCmd := interp.dotCmd
if dotCmd == "" {
dotCmd = defaultDotCmd(name, "yaegi-ast-")
}
root.astDot(dotWriter(dotCmd), name)
}
if pkgName == "" {
pkgName = pname
} else if pkgName != pname && skipTest {
return "", fmt.Errorf("found packages %s and %s in %s", pkgName, pname, dir)
}
rootNodes = append(rootNodes, root)
subRPath := effectivePkg(rPath, importPath)
var list []*node
list, err = interp.gta(root, subRPath, importPath, pkgName)
if err != nil {
return "", err
}
revisit[subRPath] = append(revisit[subRPath], list...)
}
// Revisit incomplete nodes where GTA could not complete.
for _, nodes := range revisit {
if err = interp.gtaRetry(nodes, importPath, pkgName); err != nil {
return "", err
}
}
// Generate control flow graphs.
for _, root := range rootNodes {
var nodes []*node
if nodes, err = interp.cfg(root, nil, importPath, pkgName); err != nil {
return "", err
}
initNodes = append(initNodes, nodes...)
}
// Register source package in the interpreter. The package contains only
// the global symbols in the package scope.
interp.mutex.Lock()
gs := interp.scopes[importPath]
if gs == nil {
interp.mutex.Unlock()
// A nil scope means that no even an empty package is created from source.
return "", fmt.Errorf("no Go files in %s", dir)
}
interp.srcPkg[importPath] = gs.sym
interp.pkgNames[importPath] = pkgName
interp.frame.mutex.Lock()
interp.resizeFrame()
interp.frame.mutex.Unlock()
interp.mutex.Unlock()
// Once all package sources have been parsed, execute entry points then init functions.
for _, n := range rootNodes {
if err = genRun(n); err != nil {
return "", err
}
interp.run(n, nil)
}
// Wire and execute global vars in global scope gs.
n, err := genGlobalVars(rootNodes, gs)
if err != nil {
return "", err
}
interp.run(n, nil)
// Add main to list of functions to run, after all inits.
if m := gs.sym[mainID]; pkgName == mainID && m != nil && skipTest {
initNodes = append(initNodes, m.node)
}
for _, n := range initNodes {
interp.run(n, interp.frame)
}
return pkgName, nil
}
// rootFromSourceLocation returns the path to the directory containing the input
// Go file given to the interpreter, relative to $GOPATH/src.
// It is meant to be called in the case when the initial input is a main package.
func (interp *Interpreter) rootFromSourceLocation() (string, error) {
sourceFile := interp.name
if sourceFile == DefaultSourceName {
return "", nil
}
_, isRealFS := interp.opt.filesystem.(*realFS)
if isRealFS {
// In the "real" FS, GOPATH will be an absolute path, so we need to convert
// the source file to an absolute path to compare them.
absPath, err := filepath.Abs(filepath.FromSlash(sourceFile))
if err != nil {
return "", err
}
sourceFile = filepath.ToSlash(absPath)
}
pkgDir := path.Dir(sourceFile)
goPath := path.Join(filepath.ToSlash(interp.context.GOPATH), "src") + "/"
if !strings.HasPrefix(pkgDir, goPath) {
return "", fmt.Errorf("package location %s not in GOPATH", pkgDir)
}
return strings.TrimPrefix(pkgDir, goPath), nil
}
// pkgDir returns the absolute path in filesystem for a package given its import path
// and the root of the subtree dependencies.
func (interp *Interpreter) pkgDir(goPath string, root, importPath string) (string, string, error) {
rPath := path.Join(root, "vendor")
dir := path.Join(goPath, "src", rPath, importPath)
if _, err := fs.Stat(interp.opt.filesystem, dir); err == nil {
return dir, rPath, nil // found!
}
dir = path.Join(goPath, "src", effectivePkg(root, importPath))
if _, err := fs.Stat(interp.opt.filesystem, dir); err == nil {
return dir, root, nil // found!
}
if root == "" {
if interp.context.GOPATH == "" {
return "", "", fmt.Errorf("unable to find source related to: %q. Either the GOPATH environment variable, or the Interpreter.Options.GoPath needs to be set", importPath)
}
return "", "", fmt.Errorf("unable to find source related to: %q", importPath)
}
rootPath := path.Join(goPath, "src", root)
prevRoot, err := previousRoot(interp.opt.filesystem, rootPath, root)
if err != nil {
return "", "", err
}
return interp.pkgDir(goPath, prevRoot, importPath)
}
const vendor = "vendor"
// Find the previous source root (vendor > vendor > ... > GOPATH).
func previousRoot(filesystem fs.FS, rootPath, root string) (string, error) {
rootPath = path.Clean(rootPath)
parent, final := path.Split(rootPath)
parent = path.Clean(parent)
// TODO(mpl): maybe it works for the special case main, but can't be bothered for now.
if root != mainID && final != vendor {
root = strings.TrimSuffix(root, "/")
prefix := strings.TrimSuffix(strings.TrimSuffix(rootPath, root), "/")
// look for the closest vendor in one of our direct ancestors, as it takes priority.
var vendored string
for {
fi, err := fs.Stat(filesystem, path.Join(parent, vendor))
if err == nil && fi.IsDir() {
vendored = strings.TrimPrefix(strings.TrimPrefix(parent, prefix), "/")
break
}
if !errors.Is(err, fs.ErrNotExist) {
return "", err
}
// stop when we reach GOPATH/src
if parent == prefix {
break
}
// stop when we reach GOPATH/src/blah
parent = path.Dir(parent)
if parent == prefix {
break
}
// just an additional failsafe, stop if we reach the filesystem root, or dot (if
// we are dealing with relative paths).
// TODO(mpl): It should probably be a critical error actually,
// as we shouldn't have gone that high up in the tree.
// TODO(dennwc): This partially fails on Windows, since it cannot recognize drive letters as "root".
if parent == "/" || parent == "." || parent == "" {
break
}
}
if vendored != "" {
return vendored, nil
}
}
// TODO(mpl): the algorithm below might be redundant with the one above,
// but keeping it for now. Investigate/simplify/remove later.
splitRoot := strings.Split(root, "/")
var index int
for i := len(splitRoot) - 1; i >= 0; i-- {
if splitRoot[i] == "vendor" {
index = i
break
}
}
if index == 0 {
return "", nil
}
return path.Join(splitRoot[:index]...), nil
}
func effectivePkg(root, p string) string {
splitRoot := strings.Split(root, "/")
splitPath := strings.Split(p, "/")
var result []string
rootIndex := 0
prevRootIndex := 0
for i := 0; i < len(splitPath); i++ {
part := splitPath[len(splitPath)-1-i]
index := len(splitRoot) - 1 - rootIndex
if index > 0 && part == splitRoot[index] && i != 0 {
prevRootIndex = rootIndex
rootIndex++
} else if prevRootIndex == rootIndex {
result = append(result, part)
}
}
var frag string
for i := len(result) - 1; i >= 0; i-- {
frag = path.Join(frag, result[i])
}
return path.Join(root, frag)
}
// isPathRelative returns true if path starts with "./" or "../".
// It is intended for use on import paths, where "/" is always the directory separator.
func isPathRelative(s string) bool {
return strings.HasPrefix(s, "./") || strings.HasPrefix(s, "../")
}
================================================
FILE: interp/src_test.go
================================================
package interp
import (
"os"
"path"
"path/filepath"
"testing"
)
func Test_effectivePkg(t *testing.T) {
testCases := []struct {
desc string
root string
path string
expected string
}{
{
desc: "path is a subpackage",
root: "github.com/foo/plugin/vendor/guthib.com/traefik/fromage",
path: "guthib.com/traefik/fromage/couteau/lol",
expected: "github.com/foo/plugin/vendor/guthib.com/traefik/fromage/couteau/lol",
},
{
desc: "path is a vendored package",
root: "github.com/foo/plugin/vendor/guthib.com/traefik/fromage",
path: "vendor/guthib.com/traefik/vin",
expected: "github.com/foo/plugin/vendor/guthib.com/traefik/fromage/vendor/guthib.com/traefik/vin",
},
{
desc: "path is non-existent",
root: "foo",
path: "githib.com/foo/app",
expected: "foo/githib.com/foo/app",
},
}
for _, test := range testCases {
test := test
t.Run(test.desc, func(t *testing.T) {
t.Parallel()
pkg := effectivePkg(test.root, test.path)
if pkg != test.expected {
t.Errorf("Got %s, want %s", pkg, test.expected)
}
})
}
}
func Test_pkgDir(t *testing.T) {
// create GOPATH
goPath := t.TempDir()
// Create project
project := filepath.Join(goPath, "src", "guthib.com", "foo", "root")
if err := os.MkdirAll(project, 0o700); err != nil {
t.Fatal(err)
}
type expected struct {
dir string
rpath string
}
testCases := []struct {
desc string
path string
root string
setup func() error
expected expected
}{
{
desc: "GOPATH only",
path: "guthib.com/foo/bar",
root: "",
setup: func() error {
return os.MkdirAll(filepath.Join(goPath, "src", "guthib.com", "foo", "bar"), 0o700)
},
expected: expected{
dir: filepath.Join(goPath, "src", "guthib.com", "foo", "bar"),
rpath: "",
},
},
{
desc: "vendor",
path: "guthib.com/foo/bar",
root: path.Join("guthib.com", "foo", "root"),
setup: func() error {
return os.MkdirAll(filepath.Join(project, "vendor", "guthib.com", "foo", "bar"), 0o700)
},
expected: expected{
dir: filepath.Join(goPath, "src", "guthib.com", "foo", "root", "vendor", "guthib.com", "foo", "bar"),
rpath: filepath.Join("guthib.com", "foo", "root", "vendor"),
},
},
{
desc: "GOPATH flat",
path: "guthib.com/foo/bar",
root: path.Join("guthib.com", "foo", "root"),
setup: func() error {
return os.MkdirAll(filepath.Join(goPath, "src", "guthib.com", "foo", "bar"), 0o700)
},
expected: expected{
dir: filepath.Join(goPath, "src", "guthib.com", "foo", "bar"),
rpath: "",
},
},
{
desc: "vendor flat",
path: "guthib.com/foo/bar",
root: path.Join("guthib.com", "foo", "root", "vendor", "guthib.com", "foo", "bir"),
setup: func() error {
if err := os.MkdirAll(filepath.Join(project, "vendor", "guthib.com", "foo", "bar"), 0o700); err != nil {
return err
}
return os.MkdirAll(filepath.Join(project, "vendor", "guthib.com", "foo", "bir"), 0o700)
},
expected: expected{
dir: filepath.Join(goPath, "src", "guthib.com", "foo", "root", "vendor", "guthib.com", "foo", "bar"),
rpath: filepath.Join("guthib.com", "foo", "root", "vendor"),
},
},
{
desc: "fallback to GOPATH",
path: "guthib.com/foo/bar",
root: path.Join("guthib.com", "foo", "root", "vendor", "guthib.com", "foo", "bir"),
setup: func() error {
if err := os.MkdirAll(filepath.Join(goPath, "src", "guthib.com", "foo", "bar"), 0o700); err != nil {
return err
}
return os.MkdirAll(filepath.Join(project, "vendor", "guthib.com", "foo", "bir"), 0o700)
},
expected: expected{
dir: filepath.Join(goPath, "src", "guthib.com", "foo", "bar"),
rpath: "",
},
},
{
desc: "vendor recursive",
path: "guthib.com/foo/bar",
root: path.Join("guthib.com", "foo", "root", "vendor", "guthib.com", "foo", "bir", "vendor", "guthib.com", "foo", "bur"),
setup: func() error {
if err := os.MkdirAll(
filepath.Join(goPath, "src", "guthib.com", "foo", "root", "vendor", "guthib.com", "foo", "bir", "vendor", "guthib.com", "foo", "bur"),
0o700); err != nil {
return err
}
return os.MkdirAll(filepath.Join(project, "vendor", "guthib.com", "foo", "bar"), 0o700)
},
expected: expected{
dir: filepath.Join(project, "vendor", "guthib.com", "foo", "bar"),
rpath: filepath.Join("guthib.com", "foo", "root", "vendor"),
},
},
}
interp := &Interpreter{
opt: opt{
filesystem: &realFS{},
},
}
for _, test := range testCases {
test := test
t.Run(test.desc, func(t *testing.T) {
if err := os.RemoveAll(goPath); err != nil {
t.Fatal(err)
}
if err := os.MkdirAll(goPath, 0o700); err != nil {
t.Fatal(err)
}
if test.setup != nil {
err := test.setup()
if err != nil {
t.Fatal(err)
}
}
goPath := filepath.ToSlash(goPath)
dir, rPath, err := interp.pkgDir(goPath, test.root, test.path)
if err != nil {
t.Fatal(err)
}
expectedDir := filepath.ToSlash(test.expected.dir)
if dir != expectedDir {
t.Errorf("[dir] got: %s, want: %s", dir, expectedDir)
}
expectedRpath := filepath.ToSlash(test.expected.rpath)
if rPath != expectedRpath {
t.Errorf(" [rpath] got: %s, want: %s", rPath, expectedRpath)
}
})
}
}
func Test_previousRoot(t *testing.T) {
testCases := []struct {
desc string
root string
rootPathSuffix string
expected string
}{
{
desc: "GOPATH",
root: "github.com/foo/pkg/",
expected: "",
},
{
desc: "vendor level 1",
root: "github.com/foo/pkg/vendor/guthib.com/traefik/fromage",
expected: "github.com/foo/pkg",
},
{
desc: "vendor level 2",
root: "github.com/foo/pkg/vendor/guthib.com/traefik/fromage/vendor/guthib.com/traefik/fuu",
expected: "github.com/foo/pkg/vendor/guthib.com/traefik/fromage",
},
{
desc: "vendor is sibling",
root: "github.com/foo/bar",
rootPathSuffix: "testdata/src/github.com/foo/bar",
expected: "github.com/foo",
},
{
desc: "vendor is uncle",
root: "github.com/foo/bar/baz",
rootPathSuffix: "testdata/src/github.com/foo/bar/baz",
expected: "github.com/foo",
},
}
for _, test := range testCases {
test := test
t.Run(test.desc, func(t *testing.T) {
t.Parallel()
var rootPath string
if test.rootPathSuffix != "" {
wd, err := os.Getwd()
if err != nil {
t.Fatal(err)
}
rootPath = filepath.ToSlash(filepath.Join(wd, test.rootPathSuffix))
} else {
rootPath = vendor
}
p, err := previousRoot(&realFS{}, rootPath, test.root)
if err != nil {
t.Error(err)
}
if p != test.expected {
previousRoot(&realFS{}, rootPath, test.root)
t.Errorf("got: %s, want: %s", p, test.expected)
}
})
}
}
================================================
FILE: interp/testdata/concurrent/composite/composite_lit.go
================================================
package main
import (
"time"
)
type foo struct {
bar string
}
func main() {
for i := 0; i < 2; i++ {
go func() {
a := foo{"hello"}
println(a)
}()
}
time.Sleep(time.Second)
}
================================================
FILE: interp/testdata/concurrent/composite/composite_sparse.go
================================================
package main
import (
"time"
)
type foo struct {
bar string
}
func main() {
for i := 0; i < 2; i++ {
go func() {
a := foo{bar: "hello"}
println(a)
}()
}
time.Sleep(time.Second)
}
================================================
FILE: interp/testdata/concurrent/hello1.go
================================================
package main
import "time"
func main() {
go func() {
time.Sleep(3 * time.Second)
println("hello world1")
}()
}
================================================
FILE: interp/testdata/concurrent/hello2.go
================================================
package main
import "time"
func main() {
go func() {
time.Sleep(3 * time.Second)
println("hello world2")
}()
}
================================================
FILE: interp/testdata/multi/731/sample1.go
================================================
package subpkg
import "fmt"
func PrintA() {
fmt.Println("A")
}
================================================
FILE: interp/testdata/multi/731/sample2.go
================================================
package subpkg
import "fmt"
func PrintB() {
fmt.Println("B")
}
================================================
FILE: interp/testdata/multi/731/sample3.go
================================================
package main
import "subpkg"
func main() {
subpkg.PrintA()
subpkg.PrintB()
}
================================================
FILE: interp/testdata/src/github.com/foo/bar/baz/baz.go
================================================
package baz
================================================
FILE: interp/testdata/src/github.com/foo/vendor/whatever/whatever.go
================================================
package whatever
================================================
FILE: interp/trace.go
================================================
package interp
import (
"fmt"
"reflect"
"strings"
)
// Set trace to true for debugging the cfg and other processes.
var trace = false
func traceIndent(n *node) string {
return strings.Repeat(" ", n.depth())
}
// tracePrintln works like fmt.Println, with indenting by depth
// and key info on given node.
func tracePrintln(n *node, v ...any) {
if !trace {
return
}
fmt.Println(append([]any{traceIndent(n), n}, v...)...)
}
// tracePrintTree is particularly useful in post-order for seeing the full
// structure of a given code segment of interest.
//
//nolint:unused // debugging facility
func tracePrintTree(n *node, v ...any) {
if !trace {
return
}
tracePrintln(n, v...)
n.Walk(func(n *node) bool {
tracePrintln(n)
return true
}, nil)
}
// nodeAddr returns the pointer address of node, short version.
func ptrAddr(v any) string {
p := fmt.Sprintf("%p", v)
return p[:2] + p[9:] // unique bits
}
// valString returns string rep of given value, showing underlying pointers etc.
//
//nolint:unused // debugging facility
func valString(v reflect.Value) string {
s := v.String()
if v.Kind() == reflect.Func || v.Kind() == reflect.Map || v.Kind() == reflect.Pointer || v.Kind() == reflect.Slice || v.Kind() == reflect.UnsafePointer {
p := fmt.Sprintf("%#x", v.Pointer())
ln := len(p)
s += " " + p[:2] + p[max(2, ln-4):]
}
return s
}
func (n *node) String() string {
s := n.kind.String()
if n.ident != "" {
s += " " + n.ident
}
s += " " + ptrAddr(n)
if n.sym != nil {
s += " sym:" + n.sym.String()
} else if n.typ != nil {
s += " typ:" + n.typ.String()
}
if n.findex >= 0 {
s += fmt.Sprintf(" fidx: %d lev: %d", n.findex, n.level)
}
if n.start != nil && n.start != n {
s += fmt.Sprintf(" ->start: %s %s", n.start.kind.String(), ptrAddr(n.start))
}
if n.tnext != nil {
s += fmt.Sprintf(" ->tnext: %s %s", n.tnext.kind.String(), ptrAddr(n.tnext))
}
if n.fnext != nil {
s += fmt.Sprintf(" ->fnext: %s %s", n.fnext.kind.String(), ptrAddr(n.fnext))
}
return s
}
func (n *node) depth() int {
if n.anc != nil {
return n.anc.depth() + 1
}
return 0
}
func (sy *symbol) String() string {
s := sy.kind.String()
if sy.typ != nil {
s += " (" + sy.typ.String() + ")"
}
if sy.rval.IsValid() {
s += " = " + sy.rval.String()
}
if sy.index >= 0 {
s += fmt.Sprintf(" idx: %d", sy.index)
}
if sy.node != nil {
s += " " + sy.node.String()
}
return s
}
func (t *itype) String() string {
if t.str != "" {
return t.str
}
s := t.cat.String()
if t.name != "" {
s += " (" + t.name + ")"
}
return s
}
================================================
FILE: interp/type.go
================================================
package interp
import (
"fmt"
"go/constant"
"path"
"reflect"
"strconv"
"strings"
"github.com/traefik/yaegi/internal/unsafe2"
)
// tcat defines interpreter type categories.
type tcat uint
// Types for go language.
const (
nilT tcat = iota
arrayT
binT
binPkgT
boolT
builtinT
chanT
chanSendT
chanRecvT
comparableT
complex64T
complex128T
constraintT
errorT
float32T
float64T
funcT
genericT
interfaceT
intT
int8T
int16T
int32T
int64T
linkedT
mapT
ptrT
sliceT
srcPkgT
stringT
structT
uintT
uint8T
uint16T
uint32T
uint64T
uintptrT
valueT
variadicT
maxT
)
var cats = [...]string{
nilT: "nilT",
arrayT: "arrayT",
binT: "binT",
binPkgT: "binPkgT",
boolT: "boolT",
builtinT: "builtinT",
chanT: "chanT",
comparableT: "comparableT",
complex64T: "complex64T",
complex128T: "complex128T",
constraintT: "constraintT",
errorT: "errorT",
float32T: "float32",
float64T: "float64T",
funcT: "funcT",
genericT: "genericT",
interfaceT: "interfaceT",
intT: "intT",
int8T: "int8T",
int16T: "int16T",
int32T: "int32T",
int64T: "int64T",
linkedT: "linkedT",
mapT: "mapT",
ptrT: "ptrT",
sliceT: "sliceT",
srcPkgT: "srcPkgT",
stringT: "stringT",
structT: "structT",
uintT: "uintT",
uint8T: "uint8T",
uint16T: "uint16T",
uint32T: "uint32T",
uint64T: "uint64T",
uintptrT: "uintptrT",
valueT: "valueT",
variadicT: "variadicT",
}
func (c tcat) String() string {
if c < tcat(len(cats)) {
return cats[c]
}
return "Cat(" + strconv.Itoa(int(c)) + ")"
}
// structField type defines a field in a struct.
type structField struct {
name string
tag string
embed bool
typ *itype
}
// itype defines the internal representation of types in the interpreter.
type itype struct {
cat tcat // Type category
field []structField // Array of struct fields if structT or interfaceT
key *itype // Type of key element if MapT or nil
val *itype // Type of value element if chanT, chanSendT, chanRecvT, mapT, ptrT, linkedT, arrayT, sliceT, variadicT or genericT
recv *itype // Receiver type for funcT or nil
arg []*itype // Argument types if funcT or nil
ret []*itype // Return types if funcT or nil
ptr *itype // Pointer to this type. Might be nil
method []*node // Associated methods or nil
constraint []*itype // For interfaceT: list of types part of interface set
ulconstraint []*itype // For interfaceT: list of underlying types part of interface set
instance []*itype // For genericT: list of instantiated types
name string // name of type within its package for a defined type
path string // for a defined type, the package import path
length int // length of array if ArrayT
rtype reflect.Type // Reflection type if ValueT, or nil
node *node // root AST node of type definition
scope *scope // type declaration scope (in case of re-parse incomplete type)
str string // String representation of the type
incomplete bool // true if type must be parsed again (out of order declarations)
untyped bool // true for a literal value (string or number)
isBinMethod bool // true if the type refers to a bin method function
}
type generic struct{}
func untypedBool(n *node) *itype {
return &itype{cat: boolT, name: "bool", untyped: true, str: "untyped bool", node: n}
}
func untypedString(n *node) *itype {
return &itype{cat: stringT, name: "string", untyped: true, str: "untyped string", node: n}
}
func untypedRune(n *node) *itype {
return &itype{cat: int32T, name: "int32", untyped: true, str: "untyped rune", node: n}
}
func untypedInt(n *node) *itype {
return &itype{cat: intT, name: "int", untyped: true, str: "untyped int", node: n}
}
func untypedFloat(n *node) *itype {
return &itype{cat: float64T, name: "float64", untyped: true, str: "untyped float", node: n}
}
func untypedComplex(n *node) *itype {
return &itype{cat: complex128T, name: "complex128", untyped: true, str: "untyped complex", node: n}
}
func errorMethodType(sc *scope) *itype {
return &itype{cat: funcT, ret: []*itype{sc.getType("string")}, str: "func() string"}
}
type itypeOption func(*itype)
func isBinMethod() itypeOption {
return func(t *itype) {
t.isBinMethod = true
}
}
func withRecv(typ *itype) itypeOption {
return func(t *itype) {
t.recv = typ
}
}
func withNode(n *node) itypeOption {
return func(t *itype) {
t.node = n
}
}
func withScope(sc *scope) itypeOption {
return func(t *itype) {
t.scope = sc
}
}
func withUntyped(b bool) itypeOption {
return func(t *itype) {
t.untyped = b
}
}
// valueTOf returns a valueT itype.
func valueTOf(rtype reflect.Type, opts ...itypeOption) *itype {
t := &itype{cat: valueT, rtype: rtype, str: rtype.String()}
for _, opt := range opts {
opt(t)
}
if t.untyped {
t.str = "untyped " + t.str
}
return t
}
// wrapperValueTOf returns a valueT itype wrapping an itype.
func wrapperValueTOf(rtype reflect.Type, val *itype, opts ...itypeOption) *itype {
t := &itype{cat: valueT, rtype: rtype, val: val, str: rtype.String()}
for _, opt := range opts {
opt(t)
}
return t
}
func variadicOf(val *itype, opts ...itypeOption) *itype {
t := &itype{cat: variadicT, val: val, str: "..." + val.str}
for _, opt := range opts {
opt(t)
}
return t
}
// ptrOf returns a pointer to t.
func ptrOf(val *itype, opts ...itypeOption) *itype {
if val.ptr != nil {
return val.ptr
}
t := &itype{cat: ptrT, val: val, str: "*" + val.str}
for _, opt := range opts {
opt(t)
}
val.ptr = t
return t
}
// namedOf returns a named type of val.
func namedOf(val *itype, path, name string, opts ...itypeOption) *itype {
str := name
if path != "" {
str = path + "." + name
}
t := &itype{cat: linkedT, val: val, path: path, name: name, str: str}
for _, opt := range opts {
opt(t)
}
return t
}
// funcOf returns a function type with the given args and returns.
func funcOf(args []*itype, ret []*itype, opts ...itypeOption) *itype {
b := []byte{}
b = append(b, "func("...)
b = append(b, paramsTypeString(args)...)
b = append(b, ')')
if len(ret) != 0 {
b = append(b, ' ')
if len(ret) > 1 {
b = append(b, '(')
}
b = append(b, paramsTypeString(ret)...)
if len(ret) > 1 {
b = append(b, ')')
}
}
t := &itype{cat: funcT, arg: args, ret: ret, str: string(b)}
for _, opt := range opts {
opt(t)
}
return t
}
type chanDir uint8
const (
chanSendRecv chanDir = iota
chanSend
chanRecv
)
// chanOf returns a channel of the underlying type val.
func chanOf(val *itype, dir chanDir, opts ...itypeOption) *itype {
cat := chanT
str := "chan "
switch dir {
case chanSend:
cat = chanSendT
str = "chan<- "
case chanRecv:
cat = chanRecvT
str = "<-chan "
}
t := &itype{cat: cat, val: val, str: str + val.str}
for _, opt := range opts {
opt(t)
}
return t
}
// arrayOf returns am array type of the underlying val with the given length.
func arrayOf(val *itype, l int, opts ...itypeOption) *itype {
lstr := strconv.Itoa(l)
t := &itype{cat: arrayT, val: val, length: l, str: "[" + lstr + "]" + val.str}
for _, opt := range opts {
opt(t)
}
return t
}
// sliceOf returns a slice type of the underlying val.
func sliceOf(val *itype, opts ...itypeOption) *itype {
t := &itype{cat: sliceT, val: val, str: "[]" + val.str}
for _, opt := range opts {
opt(t)
}
return t
}
// mapOf returns a map type of the underlying key and val.
func mapOf(key, val *itype, opts ...itypeOption) *itype {
t := &itype{cat: mapT, key: key, val: val, str: "map[" + key.str + "]" + val.str}
for _, opt := range opts {
opt(t)
}
return t
}
// interfaceOf returns an interface type with the given fields.
func interfaceOf(t *itype, fields []structField, constraint, ulconstraint []*itype, opts ...itypeOption) *itype {
str := "interface{}"
if len(fields) > 0 {
str = "interface { " + methodsTypeString(fields) + "}"
}
if t == nil {
t = &itype{}
}
t.cat = interfaceT
t.field = fields
t.constraint = constraint
t.ulconstraint = ulconstraint
t.str = str
for _, opt := range opts {
opt(t)
}
return t
}
// structOf returns a struct type with the given fields.
func structOf(t *itype, fields []structField, opts ...itypeOption) *itype {
str := "struct {}"
if len(fields) > 0 {
str = "struct { " + fieldsTypeString(fields) + "}"
}
if t == nil {
t = &itype{}
}
t.cat = structT
t.field = fields
t.str = str
for _, opt := range opts {
opt(t)
}
return t
}
// genericOf returns a generic type.
func genericOf(val *itype, name, path string, opts ...itypeOption) *itype {
t := &itype{cat: genericT, name: name, path: path, str: name, val: val}
for _, opt := range opts {
opt(t)
}
return t
}
// seenNode determines if a node has been seen.
//
// seenNode treats the slice of nodes as the path traveled down a node
// tree.
func seenNode(ns []*node, n *node) bool {
for _, nn := range ns {
if nn == n {
return true
}
}
return false
}
// nodeType returns a type definition for the corresponding AST subtree.
func nodeType(interp *Interpreter, sc *scope, n *node) (*itype, error) {
return nodeType2(interp, sc, n, nil)
}
func nodeType2(interp *Interpreter, sc *scope, n *node, seen []*node) (t *itype, err error) {
if n.typ != nil && !n.typ.incomplete {
return n.typ, nil
}
if sname := typeName(n); sname != "" {
sym, _, found := sc.lookup(sname)
if found && sym.kind == typeSym && sym.typ != nil {
if sym.typ.isComplete() {
return sym.typ, nil
}
if seenNode(seen, n) {
// We have seen this node in our tree, so it must be recursive.
sym.typ.incomplete = false
return sym.typ, nil
}
}
}
seen = append(seen, n)
defer func() { seen = seen[:len(seen)-1] }()
switch n.kind {
case addressExpr, starExpr:
val, err := nodeType2(interp, sc, n.child[0], seen)
if err != nil {
return nil, err
}
t = ptrOf(val, withNode(n), withScope(sc))
t.incomplete = val.incomplete
case arrayType:
c0 := n.child[0]
if len(n.child) == 1 {
val, err := nodeType2(interp, sc, c0, seen)
if err != nil {
return nil, err
}
t = sliceOf(val, withNode(n), withScope(sc))
t.incomplete = val.incomplete
break
}
// Array size is defined.
var (
length int
incomplete bool
)
switch v := c0.rval; {
case v.IsValid():
// Size if defined by a constant literal value.
if isConstantValue(v.Type()) {
c := v.Interface().(constant.Value)
length = constToInt(c)
} else {
switch v.Type().Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
length = int(v.Int())
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
length = int(v.Uint())
default:
return nil, c0.cfgErrorf("non integer constant %v", v)
}
}
case c0.kind == ellipsisExpr:
// [...]T expression, get size from the length of composite array.
length, err = arrayTypeLen(n.anc, sc)
if err != nil {
incomplete = true
}
case c0.kind == identExpr:
sym, _, ok := sc.lookup(c0.ident)
if !ok {
incomplete = true
break
}
// Size is defined by a symbol which must be a constant integer.
if sym.kind != constSym {
return nil, c0.cfgErrorf("non-constant array bound %q", c0.ident)
}
if sym.typ == nil || !isInt(sym.typ.TypeOf()) || !sym.rval.IsValid() {
incomplete = true
break
}
length = int(vInt(sym.rval))
default:
// Size is defined by a numeric constant expression.
var ok bool
if _, err := interp.cfg(c0, sc, sc.pkgID, sc.pkgName); err != nil {
if strings.Contains(err.Error(), " undefined: ") {
incomplete = true
break
}
return nil, err
}
if !c0.rval.IsValid() {
return nil, c0.cfgErrorf("undefined array size")
}
if length, ok = c0.rval.Interface().(int); !ok {
v, ok := c0.rval.Interface().(constant.Value)
if !ok {
incomplete = true
break
}
length = constToInt(v)
}
}
val, err := nodeType2(interp, sc, n.child[1], seen)
if err != nil {
return nil, err
}
t = arrayOf(val, length, withNode(n), withScope(sc))
t.incomplete = incomplete || val.incomplete
case basicLit:
switch v := n.rval.Interface().(type) {
case bool:
n.rval = reflect.ValueOf(constant.MakeBool(v))
t = untypedBool(n)
case rune:
// It is impossible to work out rune const literals in AST
// with the correct type so we must make the const type here.
n.rval = reflect.ValueOf(constant.MakeInt64(int64(v)))
t = untypedRune(n)
case constant.Value:
switch v.Kind() {
case constant.Bool:
t = untypedBool(n)
case constant.String:
t = untypedString(n)
case constant.Int:
t = untypedInt(n)
case constant.Float:
t = untypedFloat(n)
case constant.Complex:
t = untypedComplex(n)
default:
err = n.cfgErrorf("missing support for type %v", n.rval)
}
default:
err = n.cfgErrorf("missing support for type %T: %v", v, n.rval)
}
case unaryExpr:
// In interfaceType, we process an underlying type constraint definition.
if isInInterfaceType(n) {
t1, err := nodeType2(interp, sc, n.child[0], seen)
if err != nil {
return nil, err
}
t = &itype{cat: constraintT, ulconstraint: []*itype{t1}}
break
}
t, err = nodeType2(interp, sc, n.child[0], seen)
case binaryExpr:
// In interfaceType, we process a type constraint union definition.
if isInInterfaceType(n) {
t = &itype{cat: constraintT, constraint: []*itype{}, ulconstraint: []*itype{}}
for _, c := range n.child {
t1, err := nodeType2(interp, sc, c, seen)
if err != nil {
return nil, err
}
switch t1.cat {
case constraintT:
t.constraint = append(t.constraint, t1.constraint...)
t.ulconstraint = append(t.ulconstraint, t1.ulconstraint...)
default:
t.constraint = append(t.constraint, t1)
}
}
break
}
// Get type of first operand.
if t, err = nodeType2(interp, sc, n.child[0], seen); err != nil {
return nil, err
}
// For operators other than shift, get the type from the 2nd operand if the first is untyped.
if t.untyped && !isShiftNode(n) {
var t1 *itype
t1, err = nodeType2(interp, sc, n.child[1], seen)
if !(t1.untyped && isInt(t1.TypeOf()) && isFloat(t.TypeOf())) {
t = t1
}
}
// If the node is to be assigned or returned, the node type is the destination type.
dt := t
switch a := n.anc; {
case a.kind == assignStmt && isEmptyInterface(a.child[0].typ):
// Because an empty interface concrete type "mutates" as different values are
// assigned to it, we need to make a new itype from scratch everytime a new
// assignment is made, and not let different nodes (of the same variable) share the
// same itype. Otherwise they would overwrite each other.
a.child[0].typ = &itype{cat: interfaceT, val: dt, str: "interface{}"}
case a.kind == defineStmt && len(a.child) > a.nleft+a.nright:
if dt, err = nodeType2(interp, sc, a.child[a.nleft], seen); err != nil {
return nil, err
}
case a.kind == returnStmt:
dt = sc.def.typ.ret[childPos(n)]
}
if isInterfaceSrc(dt) {
// Set a new interface type preserving the concrete type (.val field).
t2 := *dt
t2.val = t
dt = &t2
}
t = dt
case callExpr:
if isBuiltinCall(n, sc) {
// Builtin types are special and may depend from their input arguments.
switch n.child[0].ident {
case bltnComplex:
var nt0, nt1 *itype
if nt0, err = nodeType2(interp, sc, n.child[1], seen); err != nil {
return nil, err
}
if nt1, err = nodeType2(interp, sc, n.child[2], seen); err != nil {
return nil, err
}
if nt0.incomplete || nt1.incomplete {
t.incomplete = true
} else {
switch t0, t1 := nt0.TypeOf(), nt1.TypeOf(); {
case isFloat32(t0) && isFloat32(t1):
t = sc.getType("complex64")
case isFloat64(t0) && isFloat64(t1):
t = sc.getType("complex128")
case nt0.untyped && isNumber(t0) && nt1.untyped && isNumber(t1):
t = untypedComplex(n)
case nt0.untyped && isFloat32(t1) || nt1.untyped && isFloat32(t0):
t = sc.getType("complex64")
case nt0.untyped && isFloat64(t1) || nt1.untyped && isFloat64(t0):
t = sc.getType("complex128")
default:
err = n.cfgErrorf("invalid types %s and %s", t0.Kind(), t1.Kind())
}
if nt0.untyped && nt1.untyped {
t = untypedComplex(n)
}
}
case bltnReal, bltnImag:
if t, err = nodeType2(interp, sc, n.child[1], seen); err != nil {
return nil, err
}
if !t.incomplete {
switch k := t.TypeOf().Kind(); {
case t.untyped && isNumber(t.TypeOf()):
t = untypedFloat(n)
case k == reflect.Complex64:
t = sc.getType("float32")
case k == reflect.Complex128:
t = sc.getType("float64")
default:
err = n.cfgErrorf("invalid complex type %s", k)
}
}
case bltnCap, bltnCopy, bltnLen:
t = sc.getType("int")
case bltnAppend, bltnMake:
t, err = nodeType2(interp, sc, n.child[1], seen)
case bltnNew:
t, err = nodeType2(interp, sc, n.child[1], seen)
incomplete := t.incomplete
t = ptrOf(t, withScope(sc))
t.incomplete = incomplete
case bltnRecover:
t = sc.getType("interface{}")
default:
t = &itype{cat: builtinT}
}
if err != nil {
return nil, err
}
} else {
if t, err = nodeType2(interp, sc, n.child[0], seen); err != nil || t == nil {
return nil, err
}
switch t.cat {
case valueT:
if rt := t.rtype; rt.Kind() == reflect.Func && rt.NumOut() == 1 {
t = valueTOf(rt.Out(0), withScope(sc))
}
default:
if len(t.ret) == 1 {
t = t.ret[0]
}
}
}
case compositeLitExpr:
t, err = nodeType2(interp, sc, n.child[0], seen)
case chanType, chanTypeRecv, chanTypeSend:
dir := chanSendRecv
switch n.kind {
case chanTypeRecv:
dir = chanRecv
case chanTypeSend:
dir = chanSend
}
val, err := nodeType2(interp, sc, n.child[0], seen)
if err != nil {
return nil, err
}
t = chanOf(val, dir, withNode(n), withScope(sc))
t.incomplete = val.incomplete
case ellipsisExpr:
val, err := nodeType2(interp, sc, n.child[0], seen)
if err != nil {
return nil, err
}
t = variadicOf(val, withNode(n), withScope(sc))
t.incomplete = t.val.incomplete
case funcLit:
t, err = nodeType2(interp, sc, n.child[2], seen)
case funcType:
var incomplete bool
// Handle type parameters.
for _, arg := range n.child[0].child {
cl := len(arg.child) - 1
typ, err := nodeType2(interp, sc, arg.child[cl], seen)
if err != nil {
return nil, err
}
for _, c := range arg.child[:cl] {
sc.sym[c.ident] = &symbol{index: -1, kind: varTypeSym, typ: typ}
}
incomplete = incomplete || typ.incomplete
}
// Handle input parameters.
args := make([]*itype, 0, len(n.child[1].child))
for _, arg := range n.child[1].child {
cl := len(arg.child) - 1
typ, err := nodeType2(interp, sc, arg.child[cl], seen)
if err != nil {
return nil, err
}
args = append(args, typ)
// Several arguments may be factorized on the same field type.
for i := 1; i < cl; i++ {
args = append(args, typ)
}
incomplete = incomplete || typ.incomplete
}
// Handle returned values.
var rets []*itype
if len(n.child) == 3 {
for _, ret := range n.child[2].child {
cl := len(ret.child) - 1
typ, err := nodeType2(interp, sc, ret.child[cl], seen)
if err != nil {
return nil, err
}
rets = append(rets, typ)
// Several arguments may be factorized on the same field type.
for i := 1; i < cl; i++ {
rets = append(rets, typ)
}
incomplete = incomplete || typ.incomplete
}
}
t = funcOf(args, rets, withNode(n), withScope(sc))
t.incomplete = incomplete
case identExpr:
sym, _, found := sc.lookup(n.ident)
if !found {
// retry with the filename, in case ident is a package name.
baseName := path.Base(interp.fset.Position(n.pos).Filename)
ident := path.Join(n.ident, baseName)
sym, _, found = sc.lookup(ident)
if !found {
t = &itype{name: n.ident, path: sc.pkgName, node: n, incomplete: true, scope: sc}
sc.sym[n.ident] = &symbol{kind: typeSym, typ: t}
break
}
}
if sym.kind == varTypeSym {
t = genericOf(sym.typ, n.ident, sc.pkgName, withNode(n), withScope(sc))
} else {
t = sym.typ
}
if t == nil {
if t, err = nodeType2(interp, sc, sym.node, seen); err != nil {
return nil, err
}
}
if t.incomplete && t.cat == linkedT && t.val != nil && t.val.cat != nilT {
t.incomplete = false
}
if t.incomplete && t.node != n {
m := t.method
if t, err = nodeType2(interp, sc, t.node, seen); err != nil {
return nil, err
}
t.method = m
sym.typ = t
}
if t.node == nil {
t.node = n
}
case indexExpr:
var lt *itype
if lt, err = nodeType2(interp, sc, n.child[0], seen); err != nil {
return nil, err
}
if lt.incomplete {
if t == nil {
t = lt
} else {
t.incomplete = true
}
break
}
switch lt.cat {
case arrayT, mapT, sliceT, variadicT:
t = lt.val
case genericT:
t1, err := nodeType2(interp, sc, n.child[1], seen)
if err != nil {
return nil, err
}
if t1.cat == genericT || t1.incomplete {
t = lt
break
}
name := lt.id() + "[" + t1.id() + "]"
if sym, _, found := sc.lookup(name); found {
t = sym.typ
break
}
// A generic type is being instantiated. Generate it.
t, err = genType(interp, sc, name, lt, []*itype{t1}, seen)
if err != nil {
return nil, err
}
}
case indexListExpr:
// Similar to above indexExpr for generic types, but handle multiple type parameters.
var lt *itype
if lt, err = nodeType2(interp, sc, n.child[0], seen); err != nil {
return nil, err
}
if lt.incomplete {
if t == nil {
t = lt
} else {
t.incomplete = true
}
break
}
// Index list expressions can be used only in context of generic types.
if lt.cat != genericT {
err = n.cfgErrorf("not a generic type: %s", lt.id())
return nil, err
}
name := lt.id() + "["
out := false
types := []*itype{}
for _, c := range n.child[1:] {
t1, err := nodeType2(interp, sc, c, seen)
if err != nil {
return nil, err
}
if t1.cat == genericT || t1.incomplete {
t = lt
out = true
break
}
types = append(types, t1)
name += t1.id() + ","
}
if out {
break
}
name = strings.TrimSuffix(name, ",") + "]"
if sym, _, found := sc.lookup(name); found {
t = sym.typ
break
}
// A generic type is being instantiated. Generate it.
t, err = genType(interp, sc, name, lt, types, seen)
case interfaceType:
if sname := typeName(n); sname != "" {
if sym, _, found := sc.lookup(sname); found && sym.kind == typeSym {
t = interfaceOf(sym.typ, sym.typ.field, sym.typ.constraint, sym.typ.ulconstraint, withNode(n), withScope(sc))
}
}
var incomplete bool
fields := []structField{}
constraint := []*itype{}
ulconstraint := []*itype{}
for _, c := range n.child[0].child {
c0 := c.child[0]
if len(c.child) == 1 {
if c0.ident == "error" {
// Unwrap error interface inplace rather than embedding it, because
// "error" is lower case which may cause problems with reflect for method lookup.
typ := errorMethodType(sc)
fields = append(fields, structField{name: "Error", typ: typ})
continue
}
typ, err := nodeType2(interp, sc, c0, seen)
if err != nil {
return nil, err
}
incomplete = incomplete || typ.incomplete
if typ.cat == constraintT {
constraint = append(constraint, typ.constraint...)
ulconstraint = append(ulconstraint, typ.ulconstraint...)
continue
}
fields = append(fields, structField{name: fieldName(c0), embed: true, typ: typ})
continue
}
typ, err := nodeType2(interp, sc, c.child[1], seen)
if err != nil {
return nil, err
}
fields = append(fields, structField{name: c0.ident, typ: typ})
incomplete = incomplete || typ.incomplete
}
t = interfaceOf(t, fields, constraint, ulconstraint, withNode(n), withScope(sc))
t.incomplete = incomplete
case landExpr, lorExpr:
t = sc.getType("bool")
case mapType:
key, err := nodeType2(interp, sc, n.child[0], seen)
if err != nil {
return nil, err
}
val, err := nodeType2(interp, sc, n.child[1], seen)
if err != nil {
return nil, err
}
t = mapOf(key, val, withNode(n), withScope(sc))
t.incomplete = key.incomplete || val.incomplete
case parenExpr:
t, err = nodeType2(interp, sc, n.child[0], seen)
case selectorExpr:
// Resolve the left part of selector, then lookup the right part on it
var lt *itype
// Lookup the package symbol first if we are in a field expression as
// a previous parameter has the same name as the package, we need to
// prioritize the package type.
if n.anc.kind == fieldExpr {
lt = findPackageType(interp, sc, n.child[0])
}
if lt == nil {
// No package was found or we are not in a field expression, we are looking for a variable.
if lt, err = nodeType2(interp, sc, n.child[0], seen); err != nil {
return nil, err
}
}
if lt.incomplete {
break
}
name := n.child[1].ident
switch lt.cat {
case binPkgT:
pkg := interp.binPkg[lt.path]
if v, ok := pkg[name]; ok {
rtype := v.Type()
if isBinType(v) {
// A bin type is encoded as a pointer on a typed nil value.
rtype = rtype.Elem()
}
t = valueTOf(rtype, withNode(n), withScope(sc))
break
}
// Continue search in source package, as it may exist if package contains generics.
fallthrough
case srcPkgT:
if pkg, ok := interp.srcPkg[lt.path]; ok {
if s, ok := pkg[name]; ok {
t = s.typ
break
}
}
err = n.cfgErrorf("undefined selector %s.%s", lt.path, name)
default:
if m, _ := lt.lookupMethod(name); m != nil {
t, err = nodeType2(interp, sc, m.child[2], seen)
} else if bm, _, _, ok := lt.lookupBinMethod(name); ok {
t = valueTOf(bm.Type, isBinMethod(), withRecv(lt), withScope(sc))
} else if ti := lt.lookupField(name); len(ti) > 0 {
t = lt.fieldSeq(ti)
} else if bs, _, ok := lt.lookupBinField(name); ok {
t = valueTOf(bs.Type, withScope(sc))
} else {
err = lt.node.cfgErrorf("undefined selector %s", name)
}
}
case sliceExpr:
t, err = nodeType2(interp, sc, n.child[0], seen)
if err != nil {
return nil, err
}
if t.cat == valueT {
switch t.rtype.Kind() {
case reflect.Array, reflect.Ptr:
t = valueTOf(reflect.SliceOf(t.rtype.Elem()), withScope(sc))
}
break
}
if t.cat == ptrT {
t = t.val
}
if t.cat == arrayT {
incomplete := t.incomplete
t = sliceOf(t.val, withNode(n), withScope(sc))
t.incomplete = incomplete
}
case structType:
var sym *symbol
var found bool
sname := structName(n)
if sname != "" {
sym, _, found = sc.lookup(sname)
if found && sym.kind == typeSym && sym.typ != nil {
t = structOf(sym.typ, sym.typ.field, withNode(n), withScope(sc))
} else {
t = structOf(nil, nil, withNode(n), withScope(sc))
sc.sym[sname] = &symbol{index: -1, kind: typeSym, typ: t, node: n}
}
}
var incomplete bool
fields := make([]structField, 0, len(n.child[0].child))
for _, c := range n.child[0].child {
switch {
case len(c.child) == 1:
typ, err := nodeType2(interp, sc, c.child[0], seen)
if err != nil {
return nil, err
}
fields = append(fields, structField{name: fieldName(c.child[0]), embed: true, typ: typ})
incomplete = incomplete || typ.incomplete
case len(c.child) == 2 && c.child[1].kind == basicLit:
tag := vString(c.child[1].rval)
typ, err := nodeType2(interp, sc, c.child[0], seen)
if err != nil {
return nil, err
}
fields = append(fields, structField{name: fieldName(c.child[0]), embed: true, typ: typ, tag: tag})
incomplete = incomplete || typ.incomplete
default:
var tag string
l := len(c.child)
if c.lastChild().kind == basicLit {
tag = vString(c.lastChild().rval)
l--
}
typ, err := nodeType2(interp, sc, c.child[l-1], seen)
if err != nil {
return nil, err
}
incomplete = incomplete || typ.incomplete
for _, d := range c.child[:l-1] {
fields = append(fields, structField{name: d.ident, typ: typ, tag: tag})
}
}
}
t = structOf(t, fields, withNode(n), withScope(sc))
t.incomplete = incomplete
if sname != "" {
if sc.sym[sname] == nil {
sc.sym[sname] = &symbol{index: -1, kind: typeSym, node: n}
}
sc.sym[sname].typ = t
}
case typeAssertExpr:
t, err = nodeType2(interp, sc, n.child[1], seen)
default:
err = n.cfgErrorf("type definition not implemented: %s", n.kind)
}
if err == nil && t != nil && t.cat == nilT && !t.incomplete {
err = n.cfgErrorf("use of untyped nil %s", t.name)
}
// The existing symbol data needs to be recovered, but not in the
// case where we are aliasing another type.
if n.anc.kind == typeSpec && n.kind != selectorExpr && n.kind != identExpr {
name := n.anc.child[0].ident
if sym := sc.sym[name]; sym != nil {
t.path = sc.pkgName
t.name = name
}
}
switch {
case t == nil:
case t.name != "" && t.path != "":
t.str = t.path + "." + t.name
case t.cat == nilT:
t.str = "nil"
}
return t, err
}
func genType(interp *Interpreter, sc *scope, name string, lt *itype, types []*itype, seen []*node) (t *itype, err error) {
// A generic type is being instantiated. Generate it.
g, _, err := genAST(sc, lt.node.anc, types)
if err != nil {
return nil, err
}
t, err = nodeType2(interp, sc, g.lastChild(), seen)
if err != nil {
return nil, err
}
lt.instance = append(lt.instance, t)
// Add generated symbol in the scope of generic source and user.
sc.sym[name] = &symbol{index: -1, kind: typeSym, typ: t, node: g}
if lt.scope.sym[name] == nil {
lt.scope.sym[name] = sc.sym[name]
}
for _, nod := range lt.method {
if err := genMethod(interp, sc, t, nod, types); err != nil {
return nil, err
}
}
return t, err
}
func genMethod(interp *Interpreter, sc *scope, t *itype, nod *node, types []*itype) error {
gm, _, err := genAST(sc, nod, types)
if err != nil {
return err
}
if gm.typ, err = nodeType(interp, sc, gm.child[2]); err != nil {
return err
}
t.addMethod(gm)
// If the receiver is a pointer to a generic type, generate also the pointer type.
if rtn := gm.child[0].child[0].lastChild(); rtn != nil && rtn.kind == starExpr {
pt := ptrOf(t, withNode(t.node), withScope(sc))
pt.addMethod(gm)
rtn.typ = pt
}
// Compile the method AST in the scope of the generic type.
scop := nod.typ.scope
if _, err = interp.cfg(gm, scop, scop.pkgID, scop.pkgName); err != nil {
return err
}
// Generate closures for function body.
return genRun(gm)
}
// findPackageType searches the top level scope for a package type.
func findPackageType(interp *Interpreter, sc *scope, n *node) *itype {
// Find the root scope, the package symbols will exist there.
for sc.level != 0 {
sc = sc.anc
}
baseName := path.Base(interp.fset.Position(n.pos).Filename)
sym, _, found := sc.lookup(path.Join(n.ident, baseName))
if !found || sym.typ == nil && sym.typ.cat != srcPkgT && sym.typ.cat != binPkgT {
return nil
}
return sym.typ
}
func isBuiltinCall(n *node, sc *scope) bool {
if n.kind != callExpr {
return false
}
s := n.child[0].sym
if s == nil {
if sym, _, found := sc.lookup(n.child[0].ident); found {
s = sym
}
}
return s != nil && s.kind == bltnSym
}
// struct name returns the name of a struct type.
func typeName(n *node) string {
if n.anc.kind == typeSpec && len(n.anc.child) == 2 {
return n.anc.child[0].ident
}
return ""
}
func structName(n *node) string {
if n.anc.kind == typeSpec {
return n.anc.child[0].ident
}
return ""
}
// fieldName returns an implicit struct field name according to node kind.
func fieldName(n *node) string {
switch n.kind {
case selectorExpr:
return fieldName(n.child[1])
case starExpr:
return fieldName(n.child[0])
case indexExpr:
return fieldName(n.child[0])
case identExpr:
return n.ident
default:
return ""
}
}
var zeroValues [maxT]reflect.Value
func init() {
zeroValues[boolT] = reflect.ValueOf(false)
zeroValues[complex64T] = reflect.ValueOf(complex64(0))
zeroValues[complex128T] = reflect.ValueOf(complex128(0))
zeroValues[errorT] = reflect.ValueOf(new(error)).Elem()
zeroValues[float32T] = reflect.ValueOf(float32(0))
zeroValues[float64T] = reflect.ValueOf(float64(0))
zeroValues[intT] = reflect.ValueOf(int(0))
zeroValues[int8T] = reflect.ValueOf(int8(0))
zeroValues[int16T] = reflect.ValueOf(int16(0))
zeroValues[int32T] = reflect.ValueOf(int32(0))
zeroValues[int64T] = reflect.ValueOf(int64(0))
zeroValues[stringT] = reflect.ValueOf("")
zeroValues[uintT] = reflect.ValueOf(uint(0))
zeroValues[uint8T] = reflect.ValueOf(uint8(0))
zeroValues[uint16T] = reflect.ValueOf(uint16(0))
zeroValues[uint32T] = reflect.ValueOf(uint32(0))
zeroValues[uint64T] = reflect.ValueOf(uint64(0))
zeroValues[uintptrT] = reflect.ValueOf(uintptr(0))
}
// Finalize returns a type pointer and error. It reparses a type from the
// partial AST if necessary (after missing dependecy data is available).
// If error is nil, the type is guarranteed to be completely defined and
// usable for CFG.
func (t *itype) finalize() (*itype, error) {
var err error
if t.incomplete {
sym, _, found := t.scope.lookup(t.name)
if found && !sym.typ.incomplete {
sym.typ.method = append(sym.typ.method, t.method...)
t.method = sym.typ.method
t.incomplete = false
return sym.typ, nil
}
m := t.method
if t, err = nodeType(t.node.interp, t.scope, t.node); err != nil {
return nil, err
}
if t.incomplete {
return nil, t.node.cfgErrorf("incomplete type %s", t.name)
}
t.method = m
t.node.typ = t
if sym != nil {
sym.typ = t
}
}
return t, err
}
func (t *itype) addMethod(n *node) {
for _, m := range t.method {
if m == n {
return
}
}
t.method = append(t.method, n)
}
func (t *itype) numIn() int {
switch t.cat {
case funcT:
return len(t.arg)
case valueT:
if t.rtype.Kind() != reflect.Func {
return 0
}
in := t.rtype.NumIn()
if t.recv != nil {
in--
}
return in
}
return 0
}
func (t *itype) in(i int) *itype {
switch t.cat {
case funcT:
return t.arg[i]
case valueT:
if t.rtype.Kind() == reflect.Func {
if t.recv != nil && !isInterface(t.recv) {
i++
}
if t.rtype.IsVariadic() && i == t.rtype.NumIn()-1 {
val := valueTOf(t.rtype.In(i).Elem())
return &itype{cat: variadicT, val: val, str: "..." + val.str}
}
return valueTOf(t.rtype.In(i))
}
}
return nil
}
func (t *itype) numOut() int {
switch t.cat {
case funcT:
return len(t.ret)
case valueT:
if t.rtype.Kind() == reflect.Func {
return t.rtype.NumOut()
}
case builtinT:
switch t.name {
case "append", "cap", "complex", "copy", "imag", "len", "make", "new", "real", "recover", "unsafe.Alignof", "unsafe.Offsetof", "unsafe.Sizeof":
return 1
}
}
return 0
}
func (t *itype) out(i int) *itype {
switch t.cat {
case funcT:
return t.ret[i]
case valueT:
if t.rtype.Kind() == reflect.Func {
return valueTOf(t.rtype.Out(i))
}
}
return nil
}
func (t *itype) concrete() *itype {
if isInterface(t) && t.val != nil {
return t.val.concrete()
}
return t
}
func (t *itype) underlying() *itype {
if t.cat == linkedT {
return t.val.underlying()
}
return t
}
// typeDefined returns true if type t1 is defined from type t2 or t2 from t1.
func typeDefined(t1, t2 *itype) bool {
if t1.cat == linkedT && t1.val == t2 {
return true
}
if t2.cat == linkedT && t2.val == t1 {
return true
}
return false
}
// isVariadic returns true if the function type is variadic.
// If the type is not a function or is not variadic, it will
// return false.
func (t *itype) isVariadic() bool {
switch t.cat {
case funcT:
return len(t.arg) > 0 && t.arg[len(t.arg)-1].cat == variadicT
case valueT:
if t.rtype.Kind() == reflect.Func {
return t.rtype.IsVariadic()
}
}
return false
}
// isComplete returns true if type definition is complete.
func (t *itype) isComplete() bool { return isComplete(t, map[string]bool{}) }
func isComplete(t *itype, visited map[string]bool) bool {
if t.incomplete {
return false
}
name := t.path + "/" + t.name
if visited[name] {
return true
}
if t.name != "" {
visited[name] = true
}
switch t.cat {
case linkedT:
if t.val != nil && t.val.cat != nilT {
// A type aliased to a partially defined type is considered complete, to allow recursivity.
return true
}
fallthrough
case arrayT, chanT, chanRecvT, chanSendT, ptrT, sliceT, variadicT:
return isComplete(t.val, visited)
case funcT:
complete := true
for _, a := range t.arg {
complete = complete && isComplete(a, visited)
}
for _, a := range t.ret {
complete = complete && isComplete(a, visited)
}
return complete
case interfaceT, structT:
complete := true
for _, f := range t.field {
// Field implicit type names must be marked as visited, to break false circles.
visited[f.typ.path+"/"+f.typ.name] = true
complete = complete && isComplete(f.typ, visited)
}
return complete
case mapT:
return isComplete(t.key, visited) && isComplete(t.val, visited)
case nilT:
return false
}
return true
}
// comparable returns true if the type is comparable.
func (t *itype) comparable() bool {
typ := t.TypeOf()
return t.cat == nilT || typ != nil && typ.Comparable()
}
func (t *itype) assignableTo(o *itype) bool {
if t.equals(o) {
return true
}
if t.cat == linkedT && o.cat == linkedT && (t.underlying().id() != o.underlying().id() || !typeDefined(t, o)) {
return false
}
if t.isNil() && o.hasNil() || o.isNil() && t.hasNil() {
return true
}
if t.TypeOf().AssignableTo(o.TypeOf()) {
return true
}
if isInterface(o) && t.implements(o) {
return true
}
if t.cat == sliceT && o.cat == sliceT {
return t.val.assignableTo(o.val)
}
if t.isBinMethod && isFunc(o) {
// TODO (marc): check that t without receiver as first parameter is equivalent to o.
return true
}
if t.untyped && isNumber(t.TypeOf()) && isNumber(o.TypeOf()) {
// Assignability depends on constant numeric value (overflow check), to be tested elsewhere.
return true
}
n := t.node
if n == nil || !n.rval.IsValid() {
return false
}
con, ok := n.rval.Interface().(constant.Value)
if !ok {
return false
}
if con == nil || !isConstType(o) {
return false
}
return representableConst(con, o.TypeOf())
}
// convertibleTo returns true if t is convertible to o.
func (t *itype) convertibleTo(o *itype) bool {
if t.assignableTo(o) {
return true
}
// unsafe checks
tt, ot := t.TypeOf(), o.TypeOf()
if (tt.Kind() == reflect.Ptr || tt.Kind() == reflect.Uintptr) && ot.Kind() == reflect.UnsafePointer {
return true
}
if tt.Kind() == reflect.UnsafePointer && (ot.Kind() == reflect.Ptr || ot.Kind() == reflect.Uintptr) {
return true
}
return t.TypeOf().ConvertibleTo(o.TypeOf())
}
// ordered returns true if the type is ordered.
func (t *itype) ordered() bool {
typ := t.TypeOf()
return isInt(typ) || isFloat(typ) || isString(typ)
}
// equals returns true if the given type is identical to the receiver one.
func (t *itype) equals(o *itype) bool {
switch ti, oi := isInterface(t), isInterface(o); {
case ti && oi:
return t.methods().equals(o.methods())
case ti && !oi:
return o.methods().contains(t.methods())
case oi && !ti:
return t.methods().contains(o.methods())
default:
return t.id() == o.id()
}
}
// matchDefault returns true if the receiver default type is the same as the given one.
func (t *itype) matchDefault(o *itype) bool {
return t.untyped && t.id() == "untyped "+o.id()
}
// MethodSet defines the set of methods signatures as strings, indexed per method name.
type methodSet map[string]string
// Contains returns true if the method set m contains the method set n.
func (m methodSet) contains(n methodSet) bool {
for k := range n {
// Only check the presence of method, not its complete signature,
// as the receiver may be part of the arguments, which makes a
// robust check complex.
if _, ok := m[k]; !ok {
return false
}
}
return true
}
// Equal returns true if the method set m is equal to the method set n.
func (m methodSet) equals(n methodSet) bool {
return m.contains(n) && n.contains(m)
}
// Methods returns a map of method type strings, indexed by method names.
func (t *itype) methods() methodSet {
seen := map[*itype]bool{}
var getMethods func(typ *itype) methodSet
getMethods = func(typ *itype) methodSet {
res := make(methodSet)
if seen[typ] {
// Stop the recursion, we have seen this type.
return res
}
seen[typ] = true
switch typ.cat {
case linkedT:
for k, v := range getMethods(typ.val) {
res[k] = v
}
case interfaceT:
// Get methods from recursive analysis of interface fields.
for _, f := range typ.field {
if f.typ.cat == funcT {
res[f.name] = f.typ.TypeOf().String()
} else {
for k, v := range getMethods(f.typ) {
res[k] = v
}
}
}
case valueT, errorT:
// Get method from corresponding reflect.Type.
for i := typ.TypeOf().NumMethod() - 1; i >= 0; i-- {
m := typ.rtype.Method(i)
res[m.Name] = m.Type.String()
}
case ptrT:
if typ.val.cat == valueT {
// Ptr receiver methods need to be found with the ptr type.
typ.TypeOf() // Ensure the rtype exists.
for i := typ.rtype.NumMethod() - 1; i >= 0; i-- {
m := typ.rtype.Method(i)
res[m.Name] = m.Type.String()
}
}
for k, v := range getMethods(typ.val) {
res[k] = v
}
case structT:
for _, f := range typ.field {
if !f.embed {
continue
}
for k, v := range getMethods(f.typ) {
res[k] = v
}
}
}
// Get all methods defined on this type.
for _, m := range typ.method {
res[m.ident] = m.typ.TypeOf().String()
}
return res
}
return getMethods(t)
}
// id returns a unique type identificator string.
func (t *itype) id() (res string) {
// Prefer the wrapped type string over the rtype string.
if t.cat == valueT && t.val != nil {
return t.val.str
}
return t.str
}
// fixPossibleConstType returns the input type if it not a constant value,
// otherwise, it returns the default Go type corresponding to the
// constant.Value.
func fixPossibleConstType(t reflect.Type) (r reflect.Type) {
cv, ok := reflect.New(t).Elem().Interface().(constant.Value)
if !ok {
return t
}
switch cv.Kind() {
case constant.Bool:
r = reflect.TypeOf(true)
case constant.Int:
r = reflect.TypeOf(0)
case constant.String:
r = reflect.TypeOf("")
case constant.Float:
r = reflect.TypeOf(float64(0))
case constant.Complex:
r = reflect.TypeOf(complex128(0))
}
return r
}
// zero instantiates and return a zero value object for the given type during execution.
func (t *itype) zero() (v reflect.Value, err error) {
if t, err = t.finalize(); err != nil {
return v, err
}
switch t.cat {
case linkedT:
v, err = t.val.zero()
case arrayT, ptrT, structT, sliceT:
v = reflect.New(t.frameType()).Elem()
case valueT:
v = reflect.New(t.rtype).Elem()
default:
v = zeroValues[t.cat]
}
return v, err
}
// fieldIndex returns the field index from name in a struct, or -1 if not found.
func (t *itype) fieldIndex(name string) int {
switch t.cat {
case linkedT, ptrT:
return t.val.fieldIndex(name)
}
for i, field := range t.field {
if name == field.name {
return i
}
}
return -1
}
// fieldSeq returns the field type from the list of field indexes.
func (t *itype) fieldSeq(seq []int) *itype {
ft := t
for _, i := range seq {
ft = baseType(ft).field[i].typ
}
return ft
}
// lookupField returns a list of indices, i.e. a path to access a field in a struct object.
func (t *itype) lookupField(name string) []int {
seen := map[*itype]bool{}
var lookup func(*itype) []int
tias := isStruct(t)
lookup = func(typ *itype) []int {
if seen[typ] {
return nil
}
seen[typ] = true
switch typ.cat {
case linkedT, ptrT:
return lookup(typ.val)
}
if fi := typ.fieldIndex(name); fi >= 0 {
return []int{fi}
}
for i, f := range typ.field {
switch f.typ.cat {
case ptrT, structT, interfaceT, linkedT:
if tias != isStruct(f.typ) {
// Interface fields are not valid embedded struct fields.
// Struct fields are not valid interface fields.
break
}
if index2 := lookup(f.typ); len(index2) > 0 {
return append([]int{i}, index2...)
}
}
}
return nil
}
return lookup(t)
}
// lookupBinField returns a structfield and a path to access an embedded binary field in a struct object.
func (t *itype) lookupBinField(name string) (s reflect.StructField, index []int, ok bool) {
if t.cat == ptrT {
return t.val.lookupBinField(name)
}
if !isStruct(t) {
return
}
rt := t.TypeOf()
for t.cat == valueT && rt.Kind() == reflect.Ptr {
rt = rt.Elem()
}
if rt.Kind() != reflect.Struct {
return
}
s, ok = rt.FieldByName(name)
if !ok {
for i, f := range t.field {
if f.embed {
if s2, index2, ok2 := f.typ.lookupBinField(name); ok2 {
index = append([]int{i}, index2...)
return s2, index, ok2
}
}
}
}
return s, index, ok
}
// MethodCallType returns a method function type without the receiver defined.
// The input type must be a method function type with the receiver as the first input argument.
func (t *itype) methodCallType() reflect.Type {
it := []reflect.Type{}
ni := t.rtype.NumIn()
for i := 1; i < ni; i++ {
it = append(it, t.rtype.In(i))
}
ot := []reflect.Type{}
no := t.rtype.NumOut()
for i := 0; i < no; i++ {
ot = append(ot, t.rtype.Out(i))
}
return reflect.FuncOf(it, ot, t.rtype.IsVariadic())
}
func (t *itype) resolveAlias() *itype {
for t.cat == linkedT {
t = t.val
}
return t
}
// GetMethod returns a pointer to the method definition.
func (t *itype) getMethod(name string) *node {
for _, m := range t.method {
if name == m.ident {
return m
}
}
return nil
}
// LookupMethod returns a pointer to method definition associated to type t
// and the list of indices to access the right struct field, in case of an embedded method.
func (t *itype) lookupMethod(name string) (*node, []int) {
return t.lookupMethod2(name, nil)
}
func (t *itype) lookupMethod2(name string, seen map[*itype]bool) (*node, []int) {
if seen == nil {
seen = map[*itype]bool{}
}
if seen[t] {
return nil, nil
}
seen[t] = true
if t.cat == ptrT {
return t.val.lookupMethod2(name, seen)
}
var index []int
m := t.getMethod(name)
if m == nil {
for i, f := range t.field {
if f.embed {
if n, index2 := f.typ.lookupMethod2(name, seen); n != nil {
index = append([]int{i}, index2...)
return n, index
}
}
}
if t.cat == linkedT || isInterfaceSrc(t) && t.val != nil {
return t.val.lookupMethod2(name, seen)
}
}
return m, index
}
// interfaceMethod returns type of method matching an interface method name (not as a concrete method).
func (t *itype) interfaceMethod(name string) *itype {
return t.interfaceMethod2(name, nil)
}
func (t *itype) interfaceMethod2(name string, seen map[*itype]bool) *itype {
if seen == nil {
seen = map[*itype]bool{}
}
if seen[t] {
return nil
}
seen[t] = true
if t.cat == ptrT {
return t.val.interfaceMethod2(name, seen)
}
for _, f := range t.field {
if f.name == name && isInterface(t) {
return f.typ
}
if !f.embed {
continue
}
if typ := f.typ.interfaceMethod2(name, seen); typ != nil {
return typ
}
}
if t.cat == linkedT || isInterfaceSrc(t) && t.val != nil {
return t.val.interfaceMethod2(name, seen)
}
return nil
}
// methodDepth returns a depth greater or equal to 0, or -1 if no match.
func (t *itype) methodDepth(name string) int {
if m, lint := t.lookupMethod(name); m != nil {
return len(lint)
}
if _, lint, _, ok := t.lookupBinMethod(name); ok {
return len(lint)
}
return -1
}
// LookupBinMethod returns a method and a path to access a field in a struct object (the receiver).
func (t *itype) lookupBinMethod(name string) (m reflect.Method, index []int, isPtr, ok bool) {
return t.lookupBinMethod2(name, nil)
}
func (t *itype) lookupBinMethod2(name string, seen map[*itype]bool) (m reflect.Method, index []int, isPtr, ok bool) {
if seen == nil {
seen = map[*itype]bool{}
}
if seen[t] {
return
}
seen[t] = true
if t.cat == ptrT {
return t.val.lookupBinMethod2(name, seen)
}
for i, f := range t.field {
if f.embed {
if m2, index2, isPtr2, ok2 := f.typ.lookupBinMethod2(name, seen); ok2 {
index = append([]int{i}, index2...)
return m2, index, isPtr2, ok2
}
}
}
m, ok = t.TypeOf().MethodByName(name)
if !ok {
m, ok = reflect.PtrTo(t.TypeOf()).MethodByName(name)
isPtr = ok
}
return m, index, isPtr, ok
}
func lookupFieldOrMethod(t *itype, name string) *itype {
switch {
case t.cat == valueT || t.cat == ptrT && t.val.cat == valueT:
m, _, isPtr, ok := t.lookupBinMethod(name)
if !ok {
return nil
}
var recv *itype
if t.rtype.Kind() != reflect.Interface {
recv = t
if isPtr && t.cat != ptrT && t.rtype.Kind() != reflect.Ptr {
recv = ptrOf(t)
}
}
return valueTOf(m.Type, withRecv(recv))
case t.cat == interfaceT:
seq := t.lookupField(name)
if seq == nil {
return nil
}
return t.fieldSeq(seq)
default:
n, _ := t.lookupMethod(name)
if n == nil {
return nil
}
return n.typ
}
}
func exportName(s string) string {
if canExport(s) {
return s
}
return "X" + s
}
var (
// TODO(mpl): generators.
emptyInterfaceType = reflect.TypeOf((*interface{})(nil)).Elem()
valueInterfaceType = reflect.TypeOf((*valueInterface)(nil)).Elem()
constVal = reflect.TypeOf((*constant.Value)(nil)).Elem()
)
type refTypeContext struct {
defined map[string]*itype
// refs keeps track of all the places (in the same type recursion) where the
// type name (as key) is used as a field of another (or possibly the same) struct
// type. Each of these fields will then live as an unsafe2.dummy type until the
// whole recursion is fully resolved, and the type is fixed.
refs map[string][]*itype
// When we detect for the first time that we are in a recursive type (thanks to
// defined), we keep track of the first occurrence of the type where the recursion
// started, so we can restart the last step that fixes all the types from the same
// "top-level" point.
rect *itype
rebuilding bool
slevel int
}
// Clone creates a copy of the ref type context.
func (c *refTypeContext) Clone() *refTypeContext {
return &refTypeContext{defined: c.defined, refs: c.refs, rebuilding: c.rebuilding}
}
func (c *refTypeContext) isComplete() bool {
for _, t := range c.defined {
if t.rtype == nil {
return false
}
}
return true
}
func (t *itype) fixDummy(typ reflect.Type) reflect.Type {
if typ == unsafe2.DummyType {
return t.rtype
}
switch typ.Kind() {
case reflect.Array:
return reflect.ArrayOf(typ.Len(), t.fixDummy(typ.Elem()))
case reflect.Chan:
return reflect.ChanOf(typ.ChanDir(), t.fixDummy(typ.Elem()))
case reflect.Func:
in := make([]reflect.Type, typ.NumIn())
for i := range in {
in[i] = t.fixDummy(typ.In(i))
}
out := make([]reflect.Type, typ.NumOut())
for i := range out {
out[i] = t.fixDummy(typ.Out(i))
}
return reflect.FuncOf(in, out, typ.IsVariadic())
case reflect.Map:
return reflect.MapOf(t.fixDummy(typ.Key()), t.fixDummy(typ.Elem()))
case reflect.Ptr:
return reflect.PtrTo(t.fixDummy(typ.Elem()))
case reflect.Slice:
return reflect.SliceOf(t.fixDummy(typ.Elem()))
case reflect.Struct:
fields := make([]reflect.StructField, typ.NumField())
for i := range fields {
fields[i] = typ.Field(i)
fields[i].Type = t.fixDummy(fields[i].Type)
}
return reflect.StructOf(fields)
}
return typ
}
// RefType returns a reflect.Type representation from an interpreter type.
// In simple cases, reflect types are directly mapped from the interpreter
// counterpart.
// For recursive named struct or interfaces, as reflect does not permit to
// create a recursive named struct, a dummy type is set temporarily for each recursive
// field. When done, the dummy type fields are updated with the original reflect type
// pointer using unsafe. We thus obtain a usable recursive type definition, except
// for string representation, as created reflect types are still unnamed.
func (t *itype) refType(ctx *refTypeContext) reflect.Type {
if ctx == nil {
ctx = &refTypeContext{
defined: map[string]*itype{},
refs: map[string][]*itype{},
}
}
if t.incomplete || t.cat == nilT {
var err error
if t, err = t.finalize(); err != nil {
panic(err)
}
}
name := t.path + "/" + t.name
if t.rtype != nil && !ctx.rebuilding {
return t.rtype
}
if dt := ctx.defined[name]; dt != nil {
// We get here when we are a struct field, and our type name has already been
// seen at least once in one of our englobing structs. i.e. there's at least one
// level of type recursion.
if dt.rtype != nil {
t.rtype = dt.rtype
return dt.rtype
}
// The recursion has not been fully resolved yet.
// To indicate that a rebuild is needed on the englobing struct,
// return a dummy field type and create an empty entry.
flds := ctx.refs[name]
ctx.rect = dt
// We know we are used as a field by someone, but we don't know by who
// at this point in the code, so we just mark it as an empty *itype for now.
// We'll complete the *itype in the caller.
ctx.refs[name] = append(flds, (*itype)(nil))
return unsafe2.DummyType
}
if isGeneric(t) {
return reflect.TypeOf((*generic)(nil)).Elem()
}
switch t.cat {
case linkedT:
t.rtype = t.val.refType(ctx)
case arrayT:
t.rtype = reflect.ArrayOf(t.length, t.val.refType(ctx))
case sliceT, variadicT:
t.rtype = reflect.SliceOf(t.val.refType(ctx))
case chanT:
t.rtype = reflect.ChanOf(reflect.BothDir, t.val.refType(ctx))
case chanRecvT:
t.rtype = reflect.ChanOf(reflect.RecvDir, t.val.refType(ctx))
case chanSendT:
t.rtype = reflect.ChanOf(reflect.SendDir, t.val.refType(ctx))
case errorT:
t.rtype = reflect.TypeOf(new(error)).Elem()
case funcT:
variadic := false
in := make([]reflect.Type, len(t.arg))
out := make([]reflect.Type, len(t.ret))
for i, v := range t.arg {
in[i] = v.refType(ctx)
variadic = v.cat == variadicT
}
for i, v := range t.ret {
out[i] = v.refType(ctx)
}
t.rtype = reflect.FuncOf(in, out, variadic)
case interfaceT:
if len(t.field) == 0 {
// empty interface, do not wrap it
t.rtype = emptyInterfaceType
break
}
t.rtype = valueInterfaceType
case mapT:
t.rtype = reflect.MapOf(t.key.refType(ctx), t.val.refType(ctx))
case ptrT:
rt := t.val.refType(ctx)
if rt == unsafe2.DummyType && ctx.slevel > 1 {
// We have a pointer to a recursive struct which is not yet fully computed.
// Return it but do not yet store it in rtype, so the complete version can
// be stored in future.
return reflect.PtrTo(rt)
}
t.rtype = reflect.PtrTo(rt)
case structT:
if t.name != "" {
ctx.defined[name] = t
}
ctx.slevel++
var fields []reflect.StructField
for _, f := range t.field {
field := reflect.StructField{
Name: exportName(f.name),
Type: f.typ.refType(ctx),
Tag: reflect.StructTag(f.tag),
}
if len(t.field) == 1 && f.embed {
// Mark the field as embedded (anonymous) only if it is the
// only one, to avoid a panic due to golang/go#15924 issue.
field.Anonymous = true
}
fields = append(fields, field)
// Find any nil type refs that indicates a rebuild is needed on this field.
for _, flds := range ctx.refs {
for j, fld := range flds {
if fld == nil {
flds[j] = t
}
}
}
}
ctx.slevel--
type fixStructField struct {
name string
index int
}
fieldFix := []fixStructField{} // Slice of field indices to fix for recursivity.
t.rtype = reflect.StructOf(fields)
if ctx.isComplete() {
for _, s := range ctx.defined {
for i := 0; i < s.rtype.NumField(); i++ {
f := s.rtype.Field(i)
if strings.HasSuffix(f.Type.String(), "unsafe2.dummy") {
unsafe2.SetFieldType(s.rtype, i, ctx.rect.fixDummy(s.rtype.Field(i).Type))
if name == s.path+"/"+s.name {
fieldFix = append(fieldFix, fixStructField{s.name, i})
}
continue
}
if f.Type.Kind() == reflect.Func && strings.Contains(f.Type.String(), "unsafe2.dummy") {
fieldFix = append(fieldFix, fixStructField{s.name, i})
}
}
}
}
// The rtype has now been built, we can go back and rebuild
// all the recursive types that relied on this type.
// However, as we are keyed by type name, if two or more (recursive) fields at
// the same depth level are of the same type, or a "variation" of the same type
// (slice of, map of, etc), they "mask" each other, and only one
// of them is in ctx.refs. That is why the code around here is a bit convoluted,
// and we need both the loop above, around all the struct fields, and the loop
// below, around the ctx.refs.
for _, f := range ctx.refs[name] {
for _, ff := range fieldFix {
if ff.name == f.name {
ftyp := f.field[ff.index].typ.refType(&refTypeContext{defined: ctx.defined, rebuilding: true})
unsafe2.SetFieldType(f.rtype, ff.index, ftyp)
}
}
}
default:
if z, _ := t.zero(); z.IsValid() {
t.rtype = z.Type()
}
}
return t.rtype
}
// TypeOf returns the reflection type of dynamic interpreter type t.
func (t *itype) TypeOf() reflect.Type {
return t.refType(nil)
}
func (t *itype) frameType() (r reflect.Type) {
var err error
if t, err = t.finalize(); err != nil {
panic(err)
}
switch t.cat {
case linkedT:
r = t.val.frameType()
case arrayT:
r = reflect.ArrayOf(t.length, t.val.frameType())
case sliceT, variadicT:
r = reflect.SliceOf(t.val.frameType())
case interfaceT:
if len(t.field) == 0 {
// empty interface, do not wrap it
r = emptyInterfaceType
break
}
r = valueInterfaceType
case mapT:
r = reflect.MapOf(t.key.frameType(), t.val.frameType())
case ptrT:
r = reflect.PtrTo(t.val.frameType())
default:
r = t.TypeOf()
}
return r
}
func (t *itype) implements(it *itype) bool {
if isBin(t) {
// Note: in case of a valueInterfaceType, we
// miss required data which will be available
// later, so we optimistically return true to progress,
// and additional checks will be hopefully performed at
// runtime.
if rt := it.TypeOf(); rt == valueInterfaceType {
return true
}
return t.TypeOf().Implements(it.TypeOf())
}
return t.methods().contains(it.methods())
}
// defaultType returns the default type of an untyped type.
func (t *itype) defaultType(v reflect.Value, sc *scope) *itype {
if !t.untyped {
return t
}
typ := t
// The default type can also be derived from a constant value.
if v.IsValid() && v.Type().Implements(constVal) {
switch v.Interface().(constant.Value).Kind() {
case constant.String:
typ = sc.getType("string")
case constant.Bool:
typ = sc.getType("bool")
case constant.Int:
switch t.cat {
case int32T:
typ = sc.getType("int32")
default:
typ = sc.getType("int")
}
case constant.Float:
typ = sc.getType("float64")
case constant.Complex:
typ = sc.getType("complex128")
}
}
if typ.untyped {
switch t.cat {
case stringT:
typ = sc.getType("string")
case boolT:
typ = sc.getType("bool")
case intT:
typ = sc.getType("int")
case float64T:
typ = sc.getType("float64")
case complex128T:
typ = sc.getType("complex128")
default:
*typ = *t
typ.untyped = false
}
}
return typ
}
func (t *itype) isNil() bool { return t.cat == nilT }
func (t *itype) hasNil() bool {
switch rt := t.TypeOf(); rt.Kind() {
case reflect.UnsafePointer:
return true
case reflect.Slice, reflect.Ptr, reflect.Func, reflect.Interface, reflect.Map, reflect.Chan:
return true
case reflect.Struct:
if rt == valueInterfaceType {
return true
}
}
return false
}
func (t *itype) elem() *itype {
if t.cat == valueT {
return valueTOf(t.rtype.Elem())
}
return t.val
}
func hasElem(t reflect.Type) bool {
switch t.Kind() {
case reflect.Array, reflect.Chan, reflect.Map, reflect.Ptr, reflect.Slice:
return true
}
return false
}
func constToInt(c constant.Value) int {
if constant.BitLen(c) > 64 {
panic(fmt.Sprintf("constant %s overflows int64", c.ExactString()))
}
i, _ := constant.Int64Val(c)
return int(i)
}
func constToString(v reflect.Value) string {
c := v.Interface().(constant.Value)
return constant.StringVal(c)
}
func wrappedType(n *node) *itype {
if n.typ.cat != valueT {
return nil
}
return n.typ.val
}
func isShiftNode(n *node) bool {
switch n.action {
case aShl, aShr, aShlAssign, aShrAssign:
return true
}
return false
}
// chanElement returns the channel element type.
func chanElement(t *itype) *itype {
switch t.cat {
case linkedT:
return chanElement(t.val)
case chanT, chanSendT, chanRecvT:
return t.val
case valueT:
return valueTOf(t.rtype.Elem(), withNode(t.node), withScope(t.scope))
}
return nil
}
func isBool(t *itype) bool { return t.TypeOf().Kind() == reflect.Bool }
func isChan(t *itype) bool { return t.TypeOf().Kind() == reflect.Chan }
func isFunc(t *itype) bool { return t.TypeOf().Kind() == reflect.Func }
func isMap(t *itype) bool { return t.TypeOf().Kind() == reflect.Map }
func isPtr(t *itype) bool { return t.TypeOf().Kind() == reflect.Ptr }
func isEmptyInterface(t *itype) bool {
return t != nil && t.cat == interfaceT && len(t.field) == 0
}
func isGeneric(t *itype) bool {
return t.cat == funcT && t.node != nil && len(t.node.child) > 0 && len(t.node.child[0].child) > 0
}
func isNamedFuncSrc(t *itype) bool {
return isFuncSrc(t) && t.node.anc.kind == funcDecl
}
func isFuncSrc(t *itype) bool {
return t.cat == funcT || (t.cat == linkedT && isFuncSrc(t.val))
}
func isPtrSrc(t *itype) bool {
return t.cat == ptrT || (t.cat == linkedT && isPtrSrc(t.val))
}
func isSendChan(t *itype) bool {
rt := t.TypeOf()
return rt.Kind() == reflect.Chan && rt.ChanDir() == reflect.SendDir
}
func isArray(t *itype) bool {
if t.cat == nilT {
return false
}
k := t.TypeOf().Kind()
return k == reflect.Array || k == reflect.Slice
}
func isInterfaceSrc(t *itype) bool {
return t.cat == interfaceT || (t.cat == linkedT && isInterfaceSrc(t.val))
}
func isInterfaceBin(t *itype) bool {
return t.cat == valueT && t.rtype.Kind() == reflect.Interface || t.cat == errorT
}
func isInterface(t *itype) bool {
return isInterfaceSrc(t) || t.TypeOf() == valueInterfaceType || t.TypeOf() != nil && t.TypeOf().Kind() == reflect.Interface
}
func isBin(t *itype) bool {
switch t.cat {
case valueT:
return true
case linkedT, ptrT:
return isBin(t.val)
default:
return false
}
}
func isStruct(t *itype) bool {
// Test first for a struct category, because a recursive interpreter struct may be
// represented by an interface{} at reflect level.
switch t.cat {
case structT:
return true
case linkedT, ptrT:
return isStruct(t.val)
case valueT:
k := t.rtype.Kind()
return k == reflect.Struct || (k == reflect.Ptr && t.rtype.Elem().Kind() == reflect.Struct)
default:
return false
}
}
func isConstType(t *itype) bool {
rt := t.TypeOf()
return isBoolean(rt) || isString(rt) || isNumber(rt)
}
func isInt(t reflect.Type) bool {
if t == nil {
return false
}
switch t.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
return true
}
return false
}
func isUint(t reflect.Type) bool {
if t == nil {
return false
}
switch t.Kind() {
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
return true
}
return false
}
func isComplex(t reflect.Type) bool {
if t == nil {
return false
}
switch t.Kind() {
case reflect.Complex64, reflect.Complex128:
return true
}
return false
}
func isFloat(t reflect.Type) bool {
if t == nil {
return false
}
switch t.Kind() {
case reflect.Float32, reflect.Float64:
return true
}
return false
}
func isByteArray(t reflect.Type) bool {
if t == nil {
return false
}
k := t.Kind()
return (k == reflect.Array || k == reflect.Slice) && t.Elem().Kind() == reflect.Uint8
}
func isFloat32(t reflect.Type) bool { return t != nil && t.Kind() == reflect.Float32 }
func isFloat64(t reflect.Type) bool { return t != nil && t.Kind() == reflect.Float64 }
func isNumber(t reflect.Type) bool {
return isInt(t) || isFloat(t) || isComplex(t) || isConstantValue(t)
}
func isBoolean(t reflect.Type) bool { return t != nil && t.Kind() == reflect.Bool }
func isString(t reflect.Type) bool { return t != nil && t.Kind() == reflect.String }
func isConstantValue(t reflect.Type) bool { return t != nil && t.Implements(constVal) }
================================================
FILE: interp/typecheck.go
================================================
package interp
import (
"errors"
"go/constant"
"go/token"
"math"
"reflect"
)
type opPredicates map[action]func(reflect.Type) bool
// typecheck handles all type checking following "go/types" logic.
//
// Due to variant type systems (itype vs reflect.Type) a single
// type system should used, namely reflect.Type with exception
// of the untyped flag on itype.
type typecheck struct {
scope *scope
}
// op type checks an expression against a set of expression predicates.
func (check typecheck) op(p opPredicates, a action, n, c *node, t reflect.Type) error {
if pred := p[a]; pred != nil {
if !pred(t) {
return n.cfgErrorf("invalid operation: operator %v not defined on %s", n.action, c.typ.id())
}
} else {
return n.cfgErrorf("invalid operation: unknown operator %v", n.action)
}
return nil
}
// assignment checks if n can be assigned to typ.
//
// Use typ == nil to indicate assignment to an untyped blank identifier.
func (check typecheck) assignment(n *node, typ *itype, context string) error {
if n.typ == nil {
return n.cfgErrorf("invalid type in %s", context)
}
if n.typ.untyped {
if typ == nil || isInterface(typ) {
if typ == nil && n.typ.cat == nilT {
return n.cfgErrorf("use of untyped nil in %s", context)
}
typ = n.typ.defaultType(n.rval, check.scope)
}
if err := check.convertUntyped(n, typ); err != nil {
return err
}
}
if typ == nil {
return nil
}
if !n.typ.assignableTo(typ) && typ.str != "*unsafe2.dummy" {
if context == "" {
return n.cfgErrorf("cannot use type %s as type %s", n.typ.id(), typ.id())
}
return n.cfgErrorf("cannot use type %s as type %s in %s", n.typ.id(), typ.id(), context)
}
return nil
}
// assignExpr type checks an assign expression.
//
// This is done per pair of assignments.
func (check typecheck) assignExpr(n, dest, src *node) error {
if n.action == aAssign {
isConst := n.anc.kind == constDecl
if !isConst {
// var operations must be typed
dest.typ = dest.typ.defaultType(src.rval, check.scope)
}
return check.assignment(src, dest.typ, "assignment")
}
// assignment operations.
if n.nleft > 1 || n.nright > 1 {
return n.cfgErrorf("assignment operation %s requires single-valued expressions", n.action)
}
return check.binaryExpr(n)
}
// addressExpr type checks a unary address expression.
func (check typecheck) addressExpr(n *node) error {
c0 := n.child[0]
found := false
for !found {
switch c0.kind {
case parenExpr:
c0 = c0.child[0]
continue
case selectorExpr:
c0 = c0.child[1]
continue
case starExpr:
c0 = c0.child[0]
continue
case indexExpr, sliceExpr:
c := c0.child[0]
if isArray(c.typ) || isMap(c.typ) {
c0 = c
found = true
continue
}
case compositeLitExpr, identExpr:
found = true
continue
}
return n.cfgErrorf("invalid operation: cannot take address of %s [kind: %s]", c0.typ.id(), kinds[c0.kind])
}
return nil
}
// starExpr type checks a star expression on a variable.
func (check typecheck) starExpr(n *node) error {
if n.typ.TypeOf().Kind() != reflect.Ptr {
return n.cfgErrorf("invalid operation: cannot indirect %q", n.name())
}
return nil
}
var unaryOpPredicates = opPredicates{
aInc: isNumber,
aDec: isNumber,
aPos: isNumber,
aNeg: isNumber,
aBitNot: isInt,
aNot: isBoolean,
}
// unaryExpr type checks a unary expression.
func (check typecheck) unaryExpr(n *node) error {
c0 := n.child[0]
if isBlank(c0) {
return n.cfgErrorf("cannot use _ as value")
}
t0 := c0.typ.TypeOf()
if n.action == aRecv {
if !isChan(c0.typ) {
return n.cfgErrorf("invalid operation: cannot receive from non-channel %s", c0.typ.id())
}
if isSendChan(c0.typ) {
return n.cfgErrorf("invalid operation: cannot receive from send-only channel %s", c0.typ.id())
}
return nil
}
return check.op(unaryOpPredicates, n.action, n, c0, t0)
}
// shift type checks a shift binary expression.
func (check typecheck) shift(n *node) error {
c0, c1 := n.child[0], n.child[1]
t0, t1 := c0.typ.TypeOf(), c1.typ.TypeOf()
var v0 constant.Value
if c0.typ.untyped && c0.rval.IsValid() {
v0 = constant.ToInt(c0.rval.Interface().(constant.Value))
c0.rval = reflect.ValueOf(v0)
}
if !(c0.typ.untyped && v0 != nil && v0.Kind() == constant.Int || isInt(t0)) {
return n.cfgErrorf("invalid operation: shift of type %v", c0.typ.id())
}
switch {
case c1.typ.untyped:
if err := check.convertUntyped(c1, check.scope.getType("uint")); err != nil {
return n.cfgErrorf("invalid operation: shift count type %v, must be integer", c1.typ.id())
}
case isInt(t1):
// nothing to do
default:
return n.cfgErrorf("invalid operation: shift count type %v, must be integer", c1.typ.id())
}
return nil
}
// comparison type checks a comparison binary expression.
func (check typecheck) comparison(n *node) error {
t0, t1 := n.child[0].typ, n.child[1].typ
if !t0.assignableTo(t1) && !t1.assignableTo(t0) {
return n.cfgErrorf("invalid operation: mismatched types %s and %s", t0.id(), t1.id())
}
ok := false
if !isInterface(t0) && !isInterface(t1) && !t0.isNil() && !t1.isNil() && t0.untyped == t1.untyped && t0.id() != t1.id() && !typeDefined(t0, t1) {
// Non interface types must be really equals.
return n.cfgErrorf("invalid operation: mismatched types %s and %s", t0.id(), t1.id())
}
switch n.action {
case aEqual, aNotEqual:
ok = t0.comparable() && t1.comparable() || t0.isNil() && t1.hasNil() || t1.isNil() && t0.hasNil()
case aLower, aLowerEqual, aGreater, aGreaterEqual:
ok = t0.ordered() && t1.ordered()
}
if !ok {
typ := t0
if typ.isNil() {
typ = t1
}
return n.cfgErrorf("invalid operation: operator %v not defined on %s", n.action, typ.id())
}
return nil
}
var binaryOpPredicates = opPredicates{
aAdd: func(typ reflect.Type) bool { return isNumber(typ) || isString(typ) },
aSub: isNumber,
aMul: isNumber,
aQuo: isNumber,
aRem: isInt,
aAnd: isInt,
aOr: isInt,
aXor: isInt,
aAndNot: isInt,
aLand: isBoolean,
aLor: isBoolean,
}
// binaryExpr type checks a binary expression.
func (check typecheck) binaryExpr(n *node) error {
c0, c1 := n.child[0], n.child[1]
if isBlank(c0) || isBlank(c1) {
return n.cfgErrorf("cannot use _ as value")
}
a := n.action
if isAssignAction(a) {
a--
}
if isShiftAction(a) {
return check.shift(n)
}
switch n.action {
case aAdd:
if n.typ == nil {
break
}
// Catch mixing string and number for "+" operator use.
k, k0, k1 := isNumber(n.typ.TypeOf()), isNumber(c0.typ.TypeOf()), isNumber(c1.typ.TypeOf())
if k != k0 || k != k1 {
return n.cfgErrorf("cannot use type %s as type %s in assignment", c0.typ.id(), n.typ.id())
}
case aRem:
if zeroConst(c1) {
return n.cfgErrorf("invalid operation: division by zero")
}
case aQuo:
if zeroConst(c1) {
return n.cfgErrorf("invalid operation: division by zero")
}
if c0.rval.IsValid() && c1.rval.IsValid() {
// Avoid constant conversions below to ensure correct constant integer quotient.
return nil
}
}
// Ensure that if values are untyped, both are converted to the same type
_ = check.convertUntyped(c0, c1.typ)
_ = check.convertUntyped(c1, c0.typ)
if isComparisonAction(a) {
return check.comparison(n)
}
if !c0.typ.equals(c1.typ) {
return n.cfgErrorf("invalid operation: mismatched types %s and %s", c0.typ.id(), c1.typ.id())
}
t0 := c0.typ.TypeOf()
return check.op(binaryOpPredicates, a, n, c0, t0)
}
func zeroConst(n *node) bool {
return n.typ.untyped && constant.Sign(n.rval.Interface().(constant.Value)) == 0
}
func (check typecheck) index(n *node, max int) error {
if err := check.convertUntyped(n, check.scope.getType("int")); err != nil {
return err
}
if !isInt(n.typ.TypeOf()) {
return n.cfgErrorf("index %s must be integer", n.typ.id())
}
if !n.rval.IsValid() || max < 1 {
return nil
}
if int(vInt(n.rval)) >= max {
return n.cfgErrorf("index %s is out of bounds", n.typ.id())
}
return nil
}
// arrayLitExpr type checks an array composite literal expression.
func (check typecheck) arrayLitExpr(child []*node, typ *itype) error {
cat := typ.cat
length := typ.length
typ = typ.val
visited := make(map[int]bool, len(child))
index := 0
for _, c := range child {
n := c
switch {
case c.kind == keyValueExpr:
if err := check.index(c.child[0], length); err != nil {
return c.cfgErrorf("index %s must be integer constant", c.child[0].typ.id())
}
n = c.child[1]
index = int(vInt(c.child[0].rval))
case cat == arrayT && index >= length:
return c.cfgErrorf("index %d is out of bounds (>= %d)", index, length)
}
if visited[index] {
return n.cfgErrorf("duplicate index %d in array or slice literal", index)
}
visited[index] = true
index++
if err := check.assignment(n, typ, "array or slice literal"); err != nil {
return err
}
}
return nil
}
// mapLitExpr type checks an map composite literal expression.
func (check typecheck) mapLitExpr(child []*node, ktyp, vtyp *itype) error {
visited := make(map[interface{}]bool, len(child))
for _, c := range child {
if c.kind != keyValueExpr {
return c.cfgErrorf("missing key in map literal")
}
key, val := c.child[0], c.child[1]
if err := check.assignment(key, ktyp, "map literal"); err != nil {
return err
}
if key.rval.IsValid() {
kval := key.rval.Interface()
if visited[kval] {
return c.cfgErrorf("duplicate key %s in map literal", kval)
}
visited[kval] = true
}
if err := check.assignment(val, vtyp, "map literal"); err != nil {
return err
}
}
return nil
}
// structLitExpr type checks a struct composite literal expression.
func (check typecheck) structLitExpr(child []*node, typ *itype) error {
if len(child) == 0 {
return nil
}
if child[0].kind == keyValueExpr {
// All children must be keyValueExpr
visited := make([]bool, len(typ.field))
for _, c := range child {
if c.kind != keyValueExpr {
return c.cfgErrorf("mixture of field:value and value elements in struct literal")
}
key, val := c.child[0], c.child[1]
name := key.ident
if name == "" {
return c.cfgErrorf("invalid field name %s in struct literal", key.typ.id())
}
i := typ.fieldIndex(name)
if i < 0 {
return c.cfgErrorf("unknown field %s in struct literal", name)
}
field := typ.field[i]
if err := check.assignment(val, field.typ, "struct literal"); err != nil {
return err
}
if visited[i] {
return c.cfgErrorf("duplicate field name %s in struct literal", name)
}
visited[i] = true
}
return nil
}
// No children can be keyValueExpr
for i, c := range child {
if c.kind == keyValueExpr {
return c.cfgErrorf("mixture of field:value and value elements in struct literal")
}
if i >= len(typ.field) {
return c.cfgErrorf("too many values in struct literal")
}
field := typ.field[i]
// TODO(nick): check if this field is not exported and in a different package.
if err := check.assignment(c, field.typ, "struct literal"); err != nil {
return err
}
}
if len(child) < len(typ.field) {
return child[len(child)-1].cfgErrorf("too few values in struct literal")
}
return nil
}
// structBinLitExpr type checks a struct composite literal expression on a binary type.
func (check typecheck) structBinLitExpr(child []*node, typ reflect.Type) error {
if len(child) == 0 {
return nil
}
if child[0].kind == keyValueExpr {
// All children must be keyValueExpr
visited := make(map[string]bool, typ.NumField())
for _, c := range child {
if c.kind != keyValueExpr {
return c.cfgErrorf("mixture of field:value and value elements in struct literal")
}
key, val := c.child[0], c.child[1]
name := key.ident
if name == "" {
return c.cfgErrorf("invalid field name %s in struct literal", key.typ.id())
}
field, ok := typ.FieldByName(name)
if !ok {
return c.cfgErrorf("unknown field %s in struct literal", name)
}
if err := check.assignment(val, valueTOf(field.Type), "struct literal"); err != nil {
return err
}
if visited[field.Name] {
return c.cfgErrorf("duplicate field name %s in struct literal", name)
}
visited[field.Name] = true
}
return nil
}
// No children can be keyValueExpr
for i, c := range child {
if c.kind == keyValueExpr {
return c.cfgErrorf("mixture of field:value and value elements in struct literal")
}
if i >= typ.NumField() {
return c.cfgErrorf("too many values in struct literal")
}
field := typ.Field(i)
if !canExport(field.Name) {
return c.cfgErrorf("implicit assignment to unexported field %s in %s literal", field.Name, typ)
}
if err := check.assignment(c, valueTOf(field.Type), "struct literal"); err != nil {
return err
}
}
if len(child) < typ.NumField() {
return child[len(child)-1].cfgErrorf("too few values in struct literal")
}
return nil
}
// sliceExpr type checks a slice expression.
func (check typecheck) sliceExpr(n *node) error {
for _, c := range n.child {
if isBlank(c) {
return n.cfgErrorf("cannot use _ as value")
}
}
c, child := n.child[0], n.child[1:]
t := c.typ.TypeOf()
var low, high, max *node
if len(child) >= 1 {
if n.action == aSlice {
low = child[0]
} else {
high = child[0]
}
}
if len(child) >= 2 {
if n.action == aSlice {
high = child[1]
} else {
max = child[1]
}
}
if len(child) == 3 && n.action == aSlice {
max = child[2]
}
l := -1
valid := false
switch t.Kind() {
case reflect.String:
valid = true
if c.rval.IsValid() {
l = len(vString(c.rval))
}
if max != nil {
return max.cfgErrorf("invalid operation: 3-index slice of string")
}
case reflect.Array:
valid = true
l = t.Len()
// TODO(marc): check addressable status of array object (i.e. composite arrays are not).
case reflect.Slice:
valid = true
case reflect.Ptr:
if t.Elem().Kind() == reflect.Array {
valid = true
l = t.Elem().Len()
}
}
if !valid {
return c.cfgErrorf("cannot slice type %s", c.typ.id())
}
var ind [3]int64
for i, nod := range []*node{low, high, max} {
x := int64(-1)
switch {
case nod != nil:
max := -1
if l >= 0 {
max = l + 1
}
if err := check.index(nod, max); err != nil {
return err
}
if nod.rval.IsValid() {
x = vInt(nod.rval)
}
case i == 0:
x = 0
case l >= 0:
x = int64(l)
}
ind[i] = x
}
for i, x := range ind[:len(ind)-1] {
if x <= 0 {
continue
}
for _, y := range ind[i+1:] {
if y < 0 || x <= y {
continue
}
return n.cfgErrorf("invalid index values, must be low <= high <= max")
}
}
return nil
}
// typeAssertionExpr type checks a type assert expression.
func (check typecheck) typeAssertionExpr(n *node, typ *itype) error {
// TODO(nick): This type check is not complete and should be revisited once
// https://github.com/golang/go/issues/39717 lands. It is currently impractical to
// type check Named types as they cannot be asserted.
if rt := n.typ.TypeOf(); rt.Kind() != reflect.Interface && rt != valueInterfaceType {
return n.cfgErrorf("invalid type assertion: non-interface type %s on left", n.typ.id())
}
ims := n.typ.methods()
if len(ims) == 0 {
// Empty interface must be a dynamic check.
return nil
}
if isInterface(typ) {
// Asserting to an interface is a dynamic check as we must look to the
// underlying struct.
return nil
}
for name := range ims {
im := lookupFieldOrMethod(n.typ, name)
tm := lookupFieldOrMethod(typ, name)
if im == nil {
// This should not be possible.
continue
}
if tm == nil {
// Lookup for non-exported methods is impossible
// for bin types, ignore them as they can't be used
// directly by the interpreted programs.
if !token.IsExported(name) && isBin(typ) {
continue
}
return n.cfgErrorf("impossible type assertion: %s does not implement %s (missing %v method)", typ.id(), n.typ.id(), name)
}
if tm.recv != nil && tm.recv.TypeOf().Kind() == reflect.Ptr && typ.TypeOf().Kind() != reflect.Ptr {
return n.cfgErrorf("impossible type assertion: %s does not implement %s as %q method has a pointer receiver", typ.id(), n.typ.id(), name)
}
if im.cat != funcT || tm.cat != funcT {
// It only makes sense to compare in/out parameter types if both types are functions.
continue
}
err := n.cfgErrorf("impossible type assertion: %s does not implement %s", typ.id(), n.typ.id())
if im.numIn() != tm.numIn() || im.numOut() != tm.numOut() {
return err
}
for i := 0; i < im.numIn(); i++ {
if !im.in(i).equals(tm.in(i)) {
return err
}
}
for i := 0; i < im.numOut(); i++ {
if !im.out(i).equals(tm.out(i)) {
return err
}
}
}
return nil
}
// conversion type checks the conversion of n to typ.
func (check typecheck) conversion(n *node, typ *itype) error {
var c constant.Value
if n.rval.IsValid() {
if con, ok := n.rval.Interface().(constant.Value); ok {
c = con
}
}
var ok bool
switch {
case c != nil && isConstType(typ):
switch t := typ.TypeOf(); {
case representableConst(c, t):
ok = true
case isInt(n.typ.TypeOf()) && isString(t):
codepoint := int64(-1)
if i, ok := constant.Int64Val(c); ok {
codepoint = i
}
n.rval = reflect.ValueOf(constant.MakeString(string(rune(codepoint))))
ok = true
}
case n.typ.convertibleTo(typ):
ok = true
}
if !ok {
return n.cfgErrorf("cannot convert expression of type %s to type %s", n.typ.id(), typ.id())
}
if !n.typ.untyped || c == nil {
return nil
}
if isInterface(typ) || !isConstType(typ) {
typ = n.typ.defaultType(n.rval, check.scope)
}
return check.convertUntyped(n, typ)
}
type param struct {
nod *node
typ *itype
}
func (p param) Type() *itype {
if p.typ != nil {
return p.typ
}
return p.nod.typ
}
// unpackParams unpacks child parameters into a slice of param.
// If there is only 1 child and it is a callExpr with an n-value return,
// the return types are returned, otherwise the original child nodes are
// returned with nil typ.
func (check typecheck) unpackParams(child []*node) (params []param) {
if len(child) == 1 && isCall(child[0]) && child[0].child[0].typ.numOut() > 1 {
c0 := child[0]
ftyp := child[0].child[0].typ
for i := 0; i < ftyp.numOut(); i++ {
params = append(params, param{nod: c0, typ: ftyp.out(i)})
}
return params
}
for _, c := range child {
params = append(params, param{nod: c})
}
return params
}
var builtinFuncs = map[string]struct {
args int
variadic bool
}{
bltnAlignof: {args: 1, variadic: false},
bltnAppend: {args: 1, variadic: true},
bltnCap: {args: 1, variadic: false},
bltnClose: {args: 1, variadic: false},
bltnComplex: {args: 2, variadic: false},
bltnImag: {args: 1, variadic: false},
bltnCopy: {args: 2, variadic: false},
bltnDelete: {args: 2, variadic: false},
bltnLen: {args: 1, variadic: false},
bltnMake: {args: 1, variadic: true},
bltnNew: {args: 1, variadic: false},
bltnOffsetof: {args: 1, variadic: false},
bltnPanic: {args: 1, variadic: false},
bltnPrint: {args: 0, variadic: true},
bltnPrintln: {args: 0, variadic: true},
bltnReal: {args: 1, variadic: false},
bltnRecover: {args: 0, variadic: false},
bltnSizeof: {args: 1, variadic: false},
}
func (check typecheck) builtin(name string, n *node, child []*node, ellipsis bool) error {
fun := builtinFuncs[name]
if ellipsis && name != bltnAppend {
return n.cfgErrorf("invalid use of ... with builtin %s", name)
}
var params []param
nparams := len(child)
switch name {
case bltnMake, bltnNew:
// Special param handling
default:
params = check.unpackParams(child)
nparams = len(params)
}
if nparams < fun.args {
return n.cfgErrorf("not enough arguments in call to %s", name)
} else if !fun.variadic && nparams > fun.args {
return n.cfgErrorf("too many arguments for %s", name)
}
switch name {
case bltnAppend:
typ := params[0].Type()
t := typ.TypeOf()
if t == nil || t.Kind() != reflect.Slice {
return params[0].nod.cfgErrorf("first argument to append must be slice; have %s", typ.id())
}
if nparams == 1 {
return nil
}
// Special case append([]byte, "test"...) is allowed.
t1 := params[1].Type()
if nparams == 2 && ellipsis && t.Elem().Kind() == reflect.Uint8 && t1.TypeOf().Kind() == reflect.String {
if t1.untyped {
return check.convertUntyped(params[1].nod, check.scope.getType("string"))
}
return nil
}
fun := &node{
typ: &itype{
cat: funcT,
arg: []*itype{
typ,
{cat: variadicT, val: valueTOf(t.Elem())},
},
ret: []*itype{typ},
},
ident: "append",
}
return check.arguments(n, child, fun, ellipsis)
case bltnCap, bltnLen:
typ := arrayDeref(params[0].Type())
ok := false
switch typ.TypeOf().Kind() {
case reflect.Array, reflect.Slice, reflect.Chan:
ok = true
case reflect.String, reflect.Map:
ok = name == bltnLen
}
if !ok {
return params[0].nod.cfgErrorf("invalid argument for %s", name)
}
case bltnClose:
p := params[0]
typ := p.Type()
t := typ.TypeOf()
if t.Kind() != reflect.Chan {
return p.nod.cfgErrorf("invalid operation: non-chan type %s", p.nod.typ.id())
}
if t.ChanDir() == reflect.RecvDir {
return p.nod.cfgErrorf("invalid operation: cannot close receive-only channel")
}
case bltnComplex:
var err error
p0, p1 := params[0], params[1]
typ0, typ1 := p0.Type(), p1.Type()
switch {
case typ0.untyped && !typ1.untyped:
err = check.convertUntyped(p0.nod, typ1)
case !typ0.untyped && typ1.untyped:
err = check.convertUntyped(p1.nod, typ0)
case typ0.untyped && typ1.untyped:
fltType := untypedFloat(nil)
err = check.convertUntyped(p0.nod, fltType)
if err != nil {
break
}
err = check.convertUntyped(p1.nod, fltType)
}
if err != nil {
return err
}
// check we have the correct types after conversion.
typ0, typ1 = p0.Type(), p1.Type()
if !typ0.equals(typ1) {
return n.cfgErrorf("invalid operation: mismatched types %s and %s", typ0.id(), typ1.id())
}
if !isFloat(typ0.TypeOf()) {
return n.cfgErrorf("invalid operation: arguments have type %s, expected floating-point", typ0.id())
}
case bltnImag, bltnReal:
p := params[0]
typ := p.Type()
if typ.untyped {
if err := check.convertUntyped(p.nod, untypedComplex(nil)); err != nil {
return err
}
}
typ = p.Type()
if !isComplex(typ.TypeOf()) {
return p.nod.cfgErrorf("invalid argument type %s for %s", typ.id(), name)
}
case bltnCopy:
typ0, typ1 := params[0].Type(), params[1].Type()
var t0, t1 reflect.Type
if t := typ0.TypeOf(); t.Kind() == reflect.Slice {
t0 = t.Elem()
}
switch t := typ1.TypeOf(); t.Kind() {
case reflect.String:
t1 = reflect.TypeOf(byte(1))
case reflect.Slice:
t1 = t.Elem()
}
if t0 == nil || t1 == nil {
return n.cfgErrorf("copy expects slice arguments")
}
if !reflect.DeepEqual(t0, t1) {
return n.cfgErrorf("arguments to copy have different element types %s and %s", typ0.id(), typ1.id())
}
case bltnDelete:
typ := params[0].Type()
if typ.TypeOf().Kind() != reflect.Map {
return params[0].nod.cfgErrorf("first argument to delete must be map; have %s", typ.id())
}
ktyp := params[1].Type()
if typ.key != nil && !ktyp.assignableTo(typ.key) {
return params[1].nod.cfgErrorf("cannot use %s as type %s in delete", ktyp.id(), typ.key.id())
}
case bltnMake:
var min int
switch child[0].typ.TypeOf().Kind() {
case reflect.Slice:
min = 2
case reflect.Map, reflect.Chan:
min = 1
default:
return child[0].cfgErrorf("cannot make %s; type must be slice, map, or channel", child[0].typ.id())
}
if nparams < min {
return n.cfgErrorf("not enough arguments in call to make")
} else if nparams > min+1 {
return n.cfgErrorf("too many arguments for make")
}
var sizes []int
for _, c := range child[1:] {
if err := check.index(c, -1); err != nil {
return err
}
if c.rval.IsValid() {
sizes = append(sizes, int(vInt(c.rval)))
}
}
for len(sizes) == 2 && sizes[0] > sizes[1] {
return n.cfgErrorf("len larger than cap in make")
}
case bltnPanic:
return check.assignment(params[0].nod, check.scope.getType("interface{}"), "argument to panic")
case bltnPrint, bltnPrintln:
for _, param := range params {
if param.typ != nil {
continue
}
if err := check.assignment(param.nod, nil, "argument to "+name); err != nil {
return err
}
}
case bltnRecover, bltnNew, bltnAlignof, bltnOffsetof, bltnSizeof:
// Nothing to do.
default:
return n.cfgErrorf("unsupported builtin %s", name)
}
return nil
}
// arrayDeref returns A if typ is *A, otherwise typ.
func arrayDeref(typ *itype) *itype {
if typ.cat == valueT && typ.TypeOf().Kind() == reflect.Ptr {
t := typ.TypeOf()
if t.Elem().Kind() == reflect.Array {
return valueTOf(t.Elem())
}
return typ
}
if typ.cat == ptrT && typ.val.cat == arrayT {
return typ.val
}
return typ
}
// arguments type checks the call expression arguments.
func (check typecheck) arguments(n *node, child []*node, fun *node, ellipsis bool) error {
params := check.unpackParams(child)
l := len(child)
if ellipsis {
if !fun.typ.isVariadic() {
return n.cfgErrorf("invalid use of ..., corresponding parameter is non-variadic")
}
if len(params) > l {
return child[0].cfgErrorf("cannot use ... with %d-valued %s", child[0].child[0].typ.numOut(), child[0].child[0].typ.id())
}
}
var cnt int
for i, param := range params {
ellip := i == l-1 && ellipsis
if err := check.argument(param, fun.typ, cnt, l, ellip); err != nil {
return err
}
cnt++
}
if fun.typ.isVariadic() {
cnt++
}
if cnt < fun.typ.numIn() {
return n.cfgErrorf("not enough arguments in call to %s", fun.name())
}
return nil
}
func (check typecheck) argument(p param, ftyp *itype, i, l int, ellipsis bool) error {
atyp := getArg(ftyp, i)
if atyp == nil {
return p.nod.cfgErrorf("too many arguments")
}
if p.typ == nil && isCall(p.nod) && p.nod.child[0].typ.numOut() != 1 {
if l == 1 {
return p.nod.cfgErrorf("cannot use %s as type %s", p.nod.child[0].typ.id(), getArgsID(ftyp))
}
return p.nod.cfgErrorf("cannot use %s as type %s", p.nod.child[0].typ.id(), atyp.id())
}
if ellipsis {
if i != ftyp.numIn()-1 {
return p.nod.cfgErrorf("can only use ... with matching parameter")
}
t := p.Type().TypeOf()
if t.Kind() != reflect.Slice || !(valueTOf(t.Elem())).assignableTo(atyp) {
return p.nod.cfgErrorf("cannot use %s as type %s", p.nod.typ.id(), (sliceOf(atyp)).id())
}
return nil
}
if p.typ != nil {
if !p.typ.assignableTo(atyp) {
return p.nod.cfgErrorf("cannot use %s as type %s", p.nod.child[0].typ.id(), getArgsID(ftyp))
}
return nil
}
return check.assignment(p.nod, atyp, "")
}
func getArg(ftyp *itype, i int) *itype {
l := ftyp.numIn()
switch {
case ftyp.isVariadic() && i >= l-1:
arg := ftyp.in(l - 1).val
return arg
case i < l:
return ftyp.in(i)
case ftyp.cat == valueT && i < ftyp.rtype.NumIn():
return valueTOf(ftyp.rtype.In(i))
default:
return nil
}
}
func getArgsID(ftyp *itype) string {
res := "("
for i, arg := range ftyp.arg {
if i > 0 {
res += ","
}
res += arg.id()
}
res += ")"
return res
}
var errCantConvert = errors.New("cannot convert")
func (check typecheck) convertUntyped(n *node, typ *itype) error {
if n.typ == nil || !n.typ.untyped || typ == nil {
return nil
}
convErr := n.cfgErrorf("cannot convert %s to %s", n.typ.id(), typ.id())
ntyp, ttyp := n.typ.TypeOf(), typ.TypeOf()
if typ.untyped {
// Both n and target are untyped.
nkind, tkind := ntyp.Kind(), ttyp.Kind()
if isNumber(ntyp) && isNumber(ttyp) {
if nkind <= tkind {
n.typ = typ
}
} else if nkind != tkind {
return convErr
}
return nil
}
var (
ityp *itype
rtyp reflect.Type
err error
)
switch {
case typ.isNil() && n.typ.isNil():
n.typ = typ
return nil
case isNumber(ttyp) || isString(ttyp) || isBoolean(ttyp):
ityp = typ
rtyp = ttyp
case isInterface(typ):
if n.typ.isNil() {
return nil
}
if len(n.typ.methods()) > 0 { // untyped cannot be set to iface
return convErr
}
ityp = n.typ.defaultType(n.rval, check.scope)
rtyp = ntyp
case isArray(typ) || isMap(typ) || isChan(typ) || isFunc(typ) || isPtr(typ):
// TODO(nick): above we are acting on itype, but really it is an rtype check. This is not clear which type
// plain we are in. Fix this later.
if !n.typ.isNil() {
return convErr
}
return nil
case n.typ.isNil() && typ.id() == "unsafe.Pointer":
n.typ = typ
return nil
default:
return convErr
}
if err := check.representable(n, rtyp); err != nil {
return err
}
n.rval, err = check.convertConst(n.rval, rtyp)
if err != nil {
if errors.Is(err, errCantConvert) {
return convErr
}
return n.cfgErrorf(err.Error())
}
n.typ = ityp
return nil
}
func (check typecheck) representable(n *node, t reflect.Type) error {
if !n.rval.IsValid() {
// TODO(nick): This should be an error as the const is in the frame which is undesirable.
return nil
}
c, ok := n.rval.Interface().(constant.Value)
if !ok {
// TODO(nick): This should be an error as untyped strings and bools should be constant.Values.
return nil
}
if !representableConst(c, t) {
typ := n.typ.TypeOf()
if isNumber(typ) && isNumber(t) {
// numeric conversion : error msg
//
// integer -> integer : overflows
// integer -> float : overflows (actually not possible)
// float -> integer : truncated
// float -> float : overflows
//
if !isInt(typ) && isInt(t) {
return n.cfgErrorf("%s truncated to %s", c.ExactString(), t.Kind().String())
}
return n.cfgErrorf("%s overflows %s", c.ExactString(), t.Kind().String())
}
return n.cfgErrorf("cannot convert %s to %s", c.ExactString(), t.Kind().String())
}
return nil
}
func (check typecheck) convertConst(v reflect.Value, t reflect.Type) (reflect.Value, error) {
if !v.IsValid() {
// TODO(nick): This should be an error as the const is in the frame which is undesirable.
return v, nil
}
c, ok := v.Interface().(constant.Value)
if !ok {
// TODO(nick): This should be an error as untyped strings and bools should be constant.Values.
return v, nil
}
kind := t.Kind()
switch kind {
case reflect.Bool:
v = reflect.ValueOf(constant.BoolVal(c))
case reflect.String:
v = reflect.ValueOf(constant.StringVal(c))
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
i, _ := constant.Int64Val(constant.ToInt(c))
v = reflect.ValueOf(i).Convert(t)
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
i, _ := constant.Uint64Val(constant.ToInt(c))
v = reflect.ValueOf(i).Convert(t)
case reflect.Float32:
f, _ := constant.Float32Val(constant.ToFloat(c))
v = reflect.ValueOf(f)
case reflect.Float64:
f, _ := constant.Float64Val(constant.ToFloat(c))
v = reflect.ValueOf(f)
case reflect.Complex64:
r, _ := constant.Float32Val(constant.Real(c))
i, _ := constant.Float32Val(constant.Imag(c))
v = reflect.ValueOf(complex(r, i)).Convert(t)
case reflect.Complex128:
r, _ := constant.Float64Val(constant.Real(c))
i, _ := constant.Float64Val(constant.Imag(c))
v = reflect.ValueOf(complex(r, i)).Convert(t)
default:
return v, errCantConvert
}
return v, nil
}
var bitlen = [...]int{
reflect.Int: 64,
reflect.Int8: 8,
reflect.Int16: 16,
reflect.Int32: 32,
reflect.Int64: 64,
reflect.Uint: 64,
reflect.Uint8: 8,
reflect.Uint16: 16,
reflect.Uint32: 32,
reflect.Uint64: 64,
reflect.Uintptr: 64,
}
func representableConst(c constant.Value, t reflect.Type) bool {
switch {
case isInt(t):
x := constant.ToInt(c)
if x.Kind() != constant.Int {
return false
}
switch t.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
if _, ok := constant.Int64Val(x); !ok {
return false
}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
if _, ok := constant.Uint64Val(x); !ok {
return false
}
default:
return false
}
return constant.BitLen(x) <= bitlen[t.Kind()]
case isFloat(t):
x := constant.ToFloat(c)
if x.Kind() != constant.Float {
return false
}
switch t.Kind() {
case reflect.Float32:
f, _ := constant.Float32Val(x)
return !math.IsInf(float64(f), 0)
case reflect.Float64:
f, _ := constant.Float64Val(x)
return !math.IsInf(f, 0)
default:
return false
}
case isComplex(t):
x := constant.ToComplex(c)
if x.Kind() != constant.Complex {
return false
}
switch t.Kind() {
case reflect.Complex64:
r, _ := constant.Float32Val(constant.Real(x))
i, _ := constant.Float32Val(constant.Imag(x))
return !math.IsInf(float64(r), 0) && !math.IsInf(float64(i), 0)
case reflect.Complex128:
r, _ := constant.Float64Val(constant.Real(x))
i, _ := constant.Float64Val(constant.Imag(x))
return !math.IsInf(r, 0) && !math.IsInf(i, 0)
default:
return false
}
case isString(t):
return c.Kind() == constant.String
case isBoolean(t):
return c.Kind() == constant.Bool
default:
return false
}
}
func isShiftAction(a action) bool {
switch a {
case aShl, aShr, aShlAssign, aShrAssign:
return true
}
return false
}
func isComparisonAction(a action) bool {
switch a {
case aEqual, aNotEqual, aGreater, aGreaterEqual, aLower, aLowerEqual:
return true
}
return false
}
================================================
FILE: interp/typestring.go
================================================
package interp
import "strings"
func paramsTypeString(params []*itype) string {
strs := make([]string, 0, len(params))
for _, param := range params {
strs = append(strs, param.str)
}
return strings.Join(strs, ",")
}
func methodsTypeString(fields []structField) string {
strs := make([]string, 0, len(fields))
for _, field := range fields {
if field.embed {
str := methodsTypeString(field.typ.field)
if str != "" {
strs = append(strs, str)
}
continue
}
strs = append(strs, field.name+field.typ.str[4:])
}
return strings.Join(strs, "; ")
}
func fieldsTypeString(fields []structField) string {
strs := make([]string, 0, len(fields))
for _, field := range fields {
var repr strings.Builder
if !field.embed {
repr.WriteString(field.name)
repr.WriteByte(' ')
}
repr.WriteString(field.typ.str)
strs = append(strs, repr.String())
}
return strings.Join(strs, "; ")
}
================================================
FILE: interp/use.go
================================================
package interp
import (
"flag"
"fmt"
"go/constant"
"log"
"math/bits"
"os"
"path"
"reflect"
gen "github.com/traefik/yaegi/stdlib/generic"
)
// Symbols returns a map of interpreter exported symbol values for the given
// import path. If the argument is the empty string, all known symbols are
// returned.
func (interp *Interpreter) Symbols(importPath string) Exports {
m := map[string]map[string]reflect.Value{}
interp.mutex.RLock()
defer interp.mutex.RUnlock()
for k, v := range interp.srcPkg {
if importPath != "" && k != importPath {
continue
}
syms := map[string]reflect.Value{}
for n, s := range v {
if !canExport(n) {
// Skip private non-exported symbols.
continue
}
switch s.kind {
case constSym:
syms[n] = s.rval
case funcSym:
syms[n] = genFunctionWrapper(s.node)(interp.frame)
case varSym:
syms[n] = interp.frame.data[s.index]
case typeSym:
syms[n] = reflect.New(s.typ.TypeOf())
}
}
if len(syms) > 0 {
m[k] = syms
}
if importPath != "" {
return m
}
}
if importPath != "" && len(m) > 0 {
return m
}
for k, v := range interp.binPkg {
if importPath != "" && k != importPath {
continue
}
m[k] = v
if importPath != "" {
return m
}
}
return m
}
// getWrapper returns the wrapper type of the corresponding interface, trying
// first the composed ones, or nil if not found.
func getWrapper(n *node, t reflect.Type) reflect.Type {
p, ok := n.interp.binPkg[t.PkgPath()]
if !ok {
return nil
}
w := p["_"+t.Name()]
lm := n.typ.methods()
// mapTypes may contain composed interfaces wrappers to test against, from
// most complex to simplest (guaranteed by construction of mapTypes). Find the
// first for which the interpreter type has all the methods.
for _, rt := range n.interp.mapTypes[w] {
match := true
for i := 1; i < rt.NumField(); i++ {
// The interpreter type must have all required wrapper methods.
if _, ok := lm[rt.Field(i).Name[1:]]; !ok {
match = false
break
}
}
if match {
return rt
}
}
// Otherwise return the direct "non-composed" interface.
return w.Type().Elem()
}
// Use loads binary runtime symbols in the interpreter context so
// they can be used in interpreted code.
func (interp *Interpreter) Use(values Exports) error {
for k, v := range values {
importPath := path.Dir(k)
packageName := path.Base(k)
if k == "." && v["MapTypes"].IsValid() {
// Use mapping for special interface wrappers.
for kk, vv := range v["MapTypes"].Interface().(map[reflect.Value][]reflect.Type) {
interp.mapTypes[kk] = vv
}
continue
}
if importPath == "." {
return fmt.Errorf("export path %[1]q is missing a package name; did you mean '%[1]s/%[1]s'?", k)
}
if importPath == selfPrefix {
interp.hooks.Parse(v)
continue
}
if interp.binPkg[importPath] == nil {
interp.binPkg[importPath] = make(map[string]reflect.Value)
interp.pkgNames[importPath] = packageName
}
for s, sym := range v {
interp.binPkg[importPath][s] = sym
}
if k == selfPath {
interp.binPkg[importPath]["Self"] = reflect.ValueOf(interp)
}
}
// Checks if input values correspond to stdlib packages by looking for one
// well known stdlib package path.
if _, ok := values["fmt/fmt"]; ok {
fixStdlib(interp)
// Load stdlib generic source.
for _, s := range gen.Sources {
if _, err := interp.Compile(s); err != nil {
return err
}
}
}
return nil
}
// fixStdlib redefines interpreter stdlib symbols to use the standard input,
// output and errror assigned to the interpreter. The changes are limited to
// the interpreter only.
// Note that it is possible to escape the virtualized stdio by
// read/write directly to file descriptors 0, 1, 2.
func fixStdlib(interp *Interpreter) {
p := interp.binPkg["fmt"]
if p == nil {
return
}
stdin, stdout, stderr := interp.stdin, interp.stdout, interp.stderr
p["Print"] = reflect.ValueOf(func(a ...interface{}) (n int, err error) { return fmt.Fprint(stdout, a...) })
p["Printf"] = reflect.ValueOf(func(f string, a ...interface{}) (n int, err error) { return fmt.Fprintf(stdout, f, a...) })
p["Println"] = reflect.ValueOf(func(a ...interface{}) (n int, err error) { return fmt.Fprintln(stdout, a...) })
p["Scan"] = reflect.ValueOf(func(a ...interface{}) (n int, err error) { return fmt.Fscan(stdin, a...) })
p["Scanf"] = reflect.ValueOf(func(f string, a ...interface{}) (n int, err error) { return fmt.Fscanf(stdin, f, a...) })
p["Scanln"] = reflect.ValueOf(func(a ...interface{}) (n int, err error) { return fmt.Fscanln(stdin, a...) })
// Update mapTypes to virtualized symbols as well.
interp.mapTypes[p["Print"]] = interp.mapTypes[reflect.ValueOf(fmt.Print)]
interp.mapTypes[p["Printf"]] = interp.mapTypes[reflect.ValueOf(fmt.Printf)]
interp.mapTypes[p["Println"]] = interp.mapTypes[reflect.ValueOf(fmt.Println)]
interp.mapTypes[p["Scan"]] = interp.mapTypes[reflect.ValueOf(fmt.Scan)]
interp.mapTypes[p["Scanf"]] = interp.mapTypes[reflect.ValueOf(fmt.Scanf)]
interp.mapTypes[p["Scanln"]] = interp.mapTypes[reflect.ValueOf(fmt.Scanln)]
if p = interp.binPkg["flag"]; p != nil {
c := flag.NewFlagSet(os.Args[0], flag.PanicOnError)
c.SetOutput(stderr)
p["CommandLine"] = reflect.ValueOf(&c).Elem()
}
if p = interp.binPkg["log"]; p != nil {
l := log.New(stderr, "", log.LstdFlags)
// Restrict Fatal symbols to panic instead of exit.
p["Fatal"] = reflect.ValueOf(l.Panic)
p["Fatalf"] = reflect.ValueOf(l.Panicf)
p["Fatalln"] = reflect.ValueOf(l.Panicln)
p["Flags"] = reflect.ValueOf(l.Flags)
p["Output"] = reflect.ValueOf(l.Output)
p["Panic"] = reflect.ValueOf(l.Panic)
p["Panicf"] = reflect.ValueOf(l.Panicf)
p["Panicln"] = reflect.ValueOf(l.Panicln)
p["Prefix"] = reflect.ValueOf(l.Prefix)
p["Print"] = reflect.ValueOf(l.Print)
p["Printf"] = reflect.ValueOf(l.Printf)
p["Println"] = reflect.ValueOf(l.Println)
p["SetFlags"] = reflect.ValueOf(l.SetFlags)
p["SetOutput"] = reflect.ValueOf(l.SetOutput)
p["SetPrefix"] = reflect.ValueOf(l.SetPrefix)
p["Writer"] = reflect.ValueOf(l.Writer)
// Update mapTypes to virtualized symbols as well.
interp.mapTypes[p["Print"]] = interp.mapTypes[reflect.ValueOf(log.Print)]
interp.mapTypes[p["Printf"]] = interp.mapTypes[reflect.ValueOf(log.Printf)]
interp.mapTypes[p["Println"]] = interp.mapTypes[reflect.ValueOf(log.Println)]
interp.mapTypes[p["Panic"]] = interp.mapTypes[reflect.ValueOf(log.Panic)]
interp.mapTypes[p["Panicf"]] = interp.mapTypes[reflect.ValueOf(log.Panicf)]
interp.mapTypes[p["Panicln"]] = interp.mapTypes[reflect.ValueOf(log.Panicln)]
}
if p = interp.binPkg["os"]; p != nil {
p["Args"] = reflect.ValueOf(&interp.args).Elem()
if interp.specialStdio {
// Inherit streams from interpreter even if they do not have a file descriptor.
p["Stdin"] = reflect.ValueOf(&stdin).Elem()
p["Stdout"] = reflect.ValueOf(&stdout).Elem()
p["Stderr"] = reflect.ValueOf(&stderr).Elem()
} else {
// Inherits streams from interpreter only if they have a file descriptor and preserve original type.
if s, ok := stdin.(*os.File); ok {
p["Stdin"] = reflect.ValueOf(&s).Elem()
}
if s, ok := stdout.(*os.File); ok {
p["Stdout"] = reflect.ValueOf(&s).Elem()
}
if s, ok := stderr.(*os.File); ok {
p["Stderr"] = reflect.ValueOf(&s).Elem()
}
}
if !interp.unrestricted {
// In restricted mode, scripts can only access to a passed virtualized env, and can not write the real one.
getenv := func(key string) string { return interp.env[key] }
p["Clearenv"] = reflect.ValueOf(func() { interp.env = map[string]string{} })
p["ExpandEnv"] = reflect.ValueOf(func(s string) string { return os.Expand(s, getenv) })
p["Getenv"] = reflect.ValueOf(getenv)
p["LookupEnv"] = reflect.ValueOf(func(key string) (s string, ok bool) { s, ok = interp.env[key]; return })
p["Setenv"] = reflect.ValueOf(func(key, value string) error { interp.env[key] = value; return nil })
p["Unsetenv"] = reflect.ValueOf(func(key string) error { delete(interp.env, key); return nil })
p["Environ"] = reflect.ValueOf(func() (a []string) {
for k, v := range interp.env {
a = append(a, k+"="+v)
}
return
})
}
}
if p = interp.binPkg["math/bits"]; p != nil {
// Do not trust extracted value maybe from another arch.
p["UintSize"] = reflect.ValueOf(constant.MakeInt64(bits.UintSize))
}
}
================================================
FILE: interp/value.go
================================================
package interp
import (
"go/constant"
"reflect"
)
const (
notInFrame = -1 // value of node.findex for literal values (not in frame)
globalFrame = -1 // value of node.level for global symbols
)
func valueGenerator(n *node, i int) func(*frame) reflect.Value {
switch n.level {
case globalFrame:
return func(f *frame) reflect.Value { return valueOf(f.root.data, i) }
case 0:
return func(f *frame) reflect.Value { return valueOf(f.data, i) }
case 1:
return func(f *frame) reflect.Value { return valueOf(f.anc.data, i) }
case 2:
return func(f *frame) reflect.Value { return valueOf(f.anc.anc.data, i) }
default:
return func(f *frame) reflect.Value {
for level := n.level; level > 0; level-- {
f = f.anc
}
return valueOf(f.data, i)
}
}
}
// valueOf safely recovers the ith element of data. This is necessary
// because a cancellation prior to any evaluation result may leave
// the frame's data empty.
func valueOf(data []reflect.Value, i int) reflect.Value {
if i < 0 || i >= len(data) {
return reflect.Value{}
}
return data[i]
}
func genValueRecv(n *node) func(*frame) reflect.Value {
var v func(*frame) reflect.Value
if n.recv.node == nil {
v = func(*frame) reflect.Value { return n.recv.val }
} else {
v = genValue(n.recv.node)
}
fi := n.recv.index
if len(fi) == 0 {
return v
}
return func(f *frame) reflect.Value {
r := v(f)
for _, i := range fi {
if r.Kind() == reflect.Ptr {
r = r.Elem()
}
// Note that we can't use reflect FieldByIndex method, as we may
// traverse valueInterface wrappers to access the embedded receiver.
r = r.Field(i)
vi, ok := r.Interface().(valueInterface)
if ok {
r = vi.value
}
}
return r
}
}
func genValueAsFunctionWrapper(n *node) func(*frame) reflect.Value {
value := genValue(n)
typ := n.typ.TypeOf()
return func(f *frame) reflect.Value {
v := value(f)
if v.IsNil() {
return reflect.New(typ).Elem()
}
if v.Kind() == reflect.Func {
return v
}
vn, ok := v.Interface().(*node)
if ok && vn.rval.Kind() == reflect.Func {
// The node value is already a callable func, no need to wrap it.
return vn.rval
}
return genFunctionWrapper(vn)(f)
}
}
func genValueAs(n *node, t reflect.Type) func(*frame) reflect.Value {
value := genValue(n)
return func(f *frame) reflect.Value {
v := value(f)
switch v.Kind() {
case reflect.Chan, reflect.Func, reflect.Interface, reflect.Ptr, reflect.Map, reflect.Slice, reflect.UnsafePointer:
if v.IsNil() {
return reflect.New(t).Elem()
}
}
return v.Convert(t)
}
}
func genValue(n *node) func(*frame) reflect.Value {
switch n.kind {
case basicLit:
convertConstantValue(n)
v := n.rval
if !v.IsValid() {
v = reflect.New(emptyInterfaceType).Elem()
}
return func(f *frame) reflect.Value { return v }
case funcDecl:
var v reflect.Value
if w, ok := n.val.(reflect.Value); ok {
v = w
} else {
v = reflect.ValueOf(n.val)
}
return func(f *frame) reflect.Value { return v }
default:
if n.rval.IsValid() {
convertConstantValue(n)
v := n.rval
return func(f *frame) reflect.Value { return v }
}
if n.sym != nil {
i := n.sym.index
if i < 0 && n != n.sym.node {
return genValue(n.sym.node)
}
if n.sym.global {
return func(f *frame) reflect.Value { return f.root.data[i] }
}
return valueGenerator(n, i)
}
if n.findex == notInFrame {
var v reflect.Value
if w, ok := n.val.(reflect.Value); ok {
v = w
} else {
v = reflect.ValueOf(n.val)
}
return func(f *frame) reflect.Value { return v }
}
return valueGenerator(n, n.findex)
}
}
func genDestValue(typ *itype, n *node) func(*frame) reflect.Value {
convertLiteralValue(n, typ.TypeOf())
switch {
case isInterfaceSrc(typ) && (!isEmptyInterface(typ) || len(n.typ.method) > 0):
return genValueInterface(n)
case isNamedFuncSrc(n.typ):
return genFunctionWrapper(n)
case isInterfaceBin(typ):
return genInterfaceWrapper(n, typ.rtype)
case n.kind == basicLit && n.val == nil:
return func(*frame) reflect.Value { return reflect.New(typ.rtype).Elem() }
case n.typ.untyped && isComplex(typ.TypeOf()):
return genValueComplex(n)
case n.typ.untyped && !typ.untyped:
return genValueAs(n, typ.TypeOf())
}
return genValue(n)
}
func genFuncValue(n *node) func(*frame) reflect.Value {
value := genValue(n)
return func(f *frame) reflect.Value {
v := value(f)
if nod, ok := v.Interface().(*node); ok {
return genFunctionWrapper(nod)(f)
}
return v
}
}
func genValueArray(n *node) func(*frame) reflect.Value {
value := genValue(n)
// dereference array pointer, to support array operations on array pointer
if n.typ.TypeOf().Kind() == reflect.Ptr {
return func(f *frame) reflect.Value {
return value(f).Elem()
}
}
return value
}
func genValueRangeArray(n *node) func(*frame) reflect.Value {
value := genValue(n)
switch {
case n.typ.TypeOf().Kind() == reflect.Ptr:
// dereference array pointer, to support array operations on array pointer
return func(f *frame) reflect.Value {
return value(f).Elem()
}
case n.typ.val != nil && n.typ.val.cat == interfaceT:
if len(n.typ.val.field) > 0 {
return func(f *frame) reflect.Value {
val := value(f)
v := []valueInterface{}
for i := 0; i < val.Len(); i++ {
switch av := val.Index(i).Interface().(type) {
case []valueInterface:
v = append(v, av...)
case valueInterface:
v = append(v, av)
default:
panic(n.cfgErrorf("invalid type %v", val.Index(i).Type()))
}
}
return reflect.ValueOf(v)
}
}
// empty interface, do not wrap.
fallthrough
default:
return func(f *frame) reflect.Value {
// This is necessary to prevent changes in the returned
// reflect.Value being reflected back to the value used
// for the range expression.
return reflect.ValueOf(value(f).Interface())
}
}
}
func genValueInterface(n *node) func(*frame) reflect.Value {
value := genValue(n)
return func(f *frame) reflect.Value {
v := value(f)
nod := n
for v.IsValid() {
// traverse interface indirections to find out concrete type
vi, ok := v.Interface().(valueInterface)
if !ok {
break
}
v = vi.value
nod = vi.node
}
// empty interface, do not wrap.
if nod != nil && isEmptyInterface(nod.typ) {
return v
}
return reflect.ValueOf(valueInterface{nod, v})
}
}
func getConcreteValue(val reflect.Value) reflect.Value {
v := val
for {
vi, ok := v.Interface().(valueInterface)
if !ok {
break
}
v = vi.value
}
if v.NumMethod() > 0 {
return v
}
if v.Kind() != reflect.Struct {
return v
}
// Search a concrete value in fields of an emulated interface.
for i := v.NumField() - 1; i >= 0; i-- {
vv := v.Field(i)
if vv.Kind() == reflect.Interface {
vv = vv.Elem()
}
if vv.IsValid() {
return vv
}
}
return v
}
func zeroInterfaceValue() reflect.Value {
n := &node{kind: basicLit, typ: &itype{cat: nilT, untyped: true, str: "nil"}}
v := reflect.New(emptyInterfaceType).Elem()
return reflect.ValueOf(valueInterface{n, v})
}
func wantEmptyInterface(n *node) bool {
return isEmptyInterface(n.typ) ||
n.anc.action == aAssign && n.anc.typ.cat == interfaceT && len(n.anc.typ.field) == 0 ||
n.anc.kind == returnStmt && n.anc.val.(*node).typ.ret[0].cat == interfaceT && len(n.anc.val.(*node).typ.ret[0].field) == 0
}
func genValueOutput(n *node, t reflect.Type) func(*frame) reflect.Value {
value := genValue(n)
switch {
case n.anc.action == aAssign && n.anc.typ.cat == interfaceT:
if len(n.anc.typ.field) == 0 {
// empty interface, do not wrap
return value
}
fallthrough
case n.anc.kind == returnStmt && n.anc.val.(*node).typ.ret[0].cat == interfaceT:
if nod, ok := n.anc.val.(*node); !ok || len(nod.typ.ret[0].field) == 0 {
// empty interface, do not wrap
return value
}
// The result of the builtin has to be returned as an interface type.
// Wrap it in a valueInterface and return the dereferenced value.
return func(f *frame) reflect.Value {
d := value(f)
v := reflect.New(t).Elem()
d.Set(reflect.ValueOf(valueInterface{n, v}))
return v
}
}
return value
}
func getBinValue(getMapType func(*itype) reflect.Type, value func(*frame) reflect.Value, f *frame) reflect.Value {
v := value(f)
if getMapType == nil {
return v
}
val, ok := v.Interface().(valueInterface)
if !ok || val.node == nil {
return v
}
if rt := getMapType(val.node.typ); rt != nil {
return genInterfaceWrapper(val.node, rt)(f)
}
return v
}
func valueInterfaceValue(v reflect.Value) reflect.Value {
for {
vv, ok := v.Interface().(valueInterface)
if !ok {
break
}
v = vv.value
}
return v
}
func genValueInterfaceValue(n *node) func(*frame) reflect.Value {
value := genValue(n)
return func(f *frame) reflect.Value {
v := value(f)
if vi, ok := v.Interface().(valueInterface); ok && vi.node == nil {
// Uninitialized interface value, set it to a correct zero value.
v.Set(zeroInterfaceValue())
v = value(f)
}
return valueInterfaceValue(v)
}
}
func vInt(v reflect.Value) (i int64) {
if c := vConstantValue(v); c != nil {
i, _ = constant.Int64Val(constant.ToInt(c))
return i
}
switch v.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
i = v.Int()
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
i = int64(v.Uint())
case reflect.Float32, reflect.Float64:
i = int64(v.Float())
case reflect.Complex64, reflect.Complex128:
i = int64(real(v.Complex()))
}
return
}
func vUint(v reflect.Value) (i uint64) {
if c := vConstantValue(v); c != nil {
i, _ = constant.Uint64Val(constant.ToInt(c))
return i
}
switch v.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
i = uint64(v.Int())
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
i = v.Uint()
case reflect.Float32, reflect.Float64:
i = uint64(v.Float())
case reflect.Complex64, reflect.Complex128:
i = uint64(real(v.Complex()))
}
return
}
func vComplex(v reflect.Value) (c complex128) {
if c := vConstantValue(v); c != nil {
c = constant.ToComplex(c)
rel, _ := constant.Float64Val(constant.Real(c))
img, _ := constant.Float64Val(constant.Imag(c))
return complex(rel, img)
}
switch v.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
c = complex(float64(v.Int()), 0)
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
c = complex(float64(v.Uint()), 0)
case reflect.Float32, reflect.Float64:
c = complex(v.Float(), 0)
case reflect.Complex64, reflect.Complex128:
c = v.Complex()
}
return
}
func vFloat(v reflect.Value) (i float64) {
if c := vConstantValue(v); c != nil {
i, _ = constant.Float64Val(constant.ToFloat(c))
return i
}
switch v.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
i = float64(v.Int())
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
i = float64(v.Uint())
case reflect.Float32, reflect.Float64:
i = v.Float()
case reflect.Complex64, reflect.Complex128:
i = real(v.Complex())
}
return
}
func vString(v reflect.Value) (s string) {
if c := vConstantValue(v); c != nil {
s = constant.StringVal(c)
return s
}
return v.String()
}
func vConstantValue(v reflect.Value) (c constant.Value) {
if v.Type().Implements(constVal) {
c = v.Interface().(constant.Value)
}
return
}
func genValueInt(n *node) func(*frame) (reflect.Value, int64) {
value := genValue(n)
switch n.typ.TypeOf().Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return func(f *frame) (reflect.Value, int64) { v := value(f); return v, v.Int() }
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
return func(f *frame) (reflect.Value, int64) { v := value(f); return v, int64(v.Uint()) }
case reflect.Float32, reflect.Float64:
return func(f *frame) (reflect.Value, int64) { v := value(f); return v, int64(v.Float()) }
case reflect.Complex64, reflect.Complex128:
if n.typ.untyped && n.rval.IsValid() && imag(n.rval.Complex()) == 0 {
return func(f *frame) (reflect.Value, int64) { v := value(f); return v, int64(real(v.Complex())) }
}
}
return nil
}
func genValueUint(n *node) func(*frame) (reflect.Value, uint64) {
value := genValue(n)
switch n.typ.TypeOf().Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return func(f *frame) (reflect.Value, uint64) { v := value(f); return v, uint64(v.Int()) }
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
return func(f *frame) (reflect.Value, uint64) { v := value(f); return v, v.Uint() }
case reflect.Float32, reflect.Float64:
return func(f *frame) (reflect.Value, uint64) { v := value(f); return v, uint64(v.Float()) }
case reflect.Complex64, reflect.Complex128:
if n.typ.untyped && n.rval.IsValid() && imag(n.rval.Complex()) == 0 {
return func(f *frame) (reflect.Value, uint64) { v := value(f); return v, uint64(real(v.Complex())) }
}
}
return nil
}
func genValueFloat(n *node) func(*frame) (reflect.Value, float64) {
value := genValue(n)
switch n.typ.TypeOf().Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return func(f *frame) (reflect.Value, float64) { v := value(f); return v, float64(v.Int()) }
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
return func(f *frame) (reflect.Value, float64) { v := value(f); return v, float64(v.Uint()) }
case reflect.Float32, reflect.Float64:
return func(f *frame) (reflect.Value, float64) { v := value(f); return v, v.Float() }
case reflect.Complex64, reflect.Complex128:
if n.typ.untyped && n.rval.IsValid() && imag(n.rval.Complex()) == 0 {
return func(f *frame) (reflect.Value, float64) { v := value(f); return v, real(v.Complex()) }
}
}
return nil
}
func genValueComplex(n *node) func(*frame) reflect.Value {
vc := genComplex(n)
return func(f *frame) reflect.Value { return reflect.ValueOf(vc(f)) }
}
func genComplex(n *node) func(*frame) complex128 {
value := genValue(n)
switch n.typ.TypeOf().Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return func(f *frame) complex128 { return complex(float64(value(f).Int()), 0) }
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
return func(f *frame) complex128 { return complex(float64(value(f).Uint()), 0) }
case reflect.Float32, reflect.Float64:
return func(f *frame) complex128 { return complex(value(f).Float(), 0) }
case reflect.Complex64, reflect.Complex128:
return func(f *frame) complex128 { return value(f).Complex() }
}
return nil
}
func genValueString(n *node) func(*frame) (reflect.Value, string) {
value := genValue(n)
return func(f *frame) (reflect.Value, string) { v := value(f); return v, v.String() }
}
================================================
FILE: stdlib/generic/go1_21_cmp.go.txt
================================================
// Copyright 2023 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// Package cmp provides types and functions related to comparing
// ordered values.
package cmp
// Ordered is a constraint that permits any ordered type: any type
// that supports the operators < <= >= >.
// If future releases of Go add new ordered types,
// this constraint will be modified to include them.
//
// Note that floating-point types may contain NaN ("not-a-number") values.
// An operator such as == or < will always report false when
// comparing a NaN value with any other value, NaN or not.
// See the [Compare] function for a consistent way to compare NaN values.
type Ordered interface {
~int | ~int8 | ~int16 | ~int32 | ~int64 |
~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr |
~float32 | ~float64 |
~string
}
// Less reports whether x is less than y.
// For floating-point types, a NaN is considered less than any non-NaN,
// and -0.0 is not less than (is equal to) 0.0.
func Less[T Ordered](x, y T) bool {
return (isNaN(x) && !isNaN(y)) || x < y
}
// Compare returns
//
// -1 if x is less than y,
// 0 if x equals y,
// +1 if x is greater than y.
//
// For floating-point types, a NaN is considered less than any non-NaN,
// a NaN is considered equal to a NaN, and -0.0 is equal to 0.0.
func Compare[T Ordered](x, y T) int {
xNaN := isNaN(x)
yNaN := isNaN(y)
if xNaN && yNaN {
return 0
}
if xNaN || x < y {
return -1
}
if yNaN || x > y {
return +1
}
return 0
}
// isNaN reports whether x is a NaN without requiring the math package.
// This will always return false if T is not floating-point.
func isNaN[T Ordered](x T) bool {
return x != x
}
================================================
FILE: stdlib/generic/go1_21_generic.go
================================================
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package generic
import _ "embed"
//go:embed go1_21_cmp.go.txt
var cmpSource string
//go:embed go1_21_maps.go.txt
var mapsSource string
//go:embed go1_21_slices.go.txt
var slicesSource string
/*
//go:embed go1_21_sync.go.txt
var syncSource string
//go:embed go1_21_sync_atomic.go.txt
var syncAtomicSource string
*/
// Sources contains the list of generic packages source strings.
var Sources = [...]string{
cmpSource,
mapsSource,
slicesSource,
// FIXME(marc): support the following.
// syncAtomicSource,
// syncSource,
}
================================================
FILE: stdlib/generic/go1_21_maps.go.txt
================================================
// Copyright 2021 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// Package maps defines various functions useful with maps of any type.
package maps
// Equal reports whether two maps contain the same key/value pairs.
// Values are compared using ==.
func Equal[M1, M2 ~map[K]V, K, V comparable](m1 M1, m2 M2) bool {
if len(m1) != len(m2) {
return false
}
for k, v1 := range m1 {
if v2, ok := m2[k]; !ok || v1 != v2 {
return false
}
}
return true
}
// EqualFunc is like Equal, but compares values using eq.
// Keys are still compared with ==.
func EqualFunc[M1 ~map[K]V1, M2 ~map[K]V2, K comparable, V1, V2 any](m1 M1, m2 M2, eq func(V1, V2) bool) bool {
if len(m1) != len(m2) {
return false
}
for k, v1 := range m1 {
if v2, ok := m2[k]; !ok || !eq(v1, v2) {
return false
}
}
return true
}
// clone is implemented in the runtime package.
func clone(m any) any { return m }
// Clone returns a copy of m. This is a shallow clone:
// the new keys and values are set using ordinary assignment.
func Clone[M ~map[K]V, K comparable, V any](m M) M {
// Preserve nil in case it matters.
if m == nil {
return nil
}
return clone(m).(M)
}
// Copy copies all key/value pairs in src adding them to dst.
// When a key in src is already present in dst,
// the value in dst will be overwritten by the value associated
// with the key in src.
func Copy[M1 ~map[K]V, M2 ~map[K]V, K comparable, V any](dst M1, src M2) {
for k, v := range src {
dst[k] = v
}
}
// DeleteFunc deletes any key/value pairs from m for which del returns true.
func DeleteFunc[M ~map[K]V, K comparable, V any](m M, del func(K, V) bool) {
for k, v := range m {
if del(k, v) {
delete(m, k)
}
}
}
================================================
FILE: stdlib/generic/go1_21_slices.go.txt
================================================
// Copyright 2021 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// Package slices defines various functions useful with slices of any type.
package slices
import (
"cmp"
"math/bits"
// "unsafe" // FIXME(marc): better handle special dependencies in generics.
)
// Equal reports whether two slices are equal: the same length and all
// elements equal. If the lengths are different, Equal returns false.
// Otherwise, the elements are compared in increasing index order, and the
// comparison stops at the first unequal pair.
// Floating point NaNs are not considered equal.
func Equal[S ~[]E, E comparable](s1, s2 S) bool {
if len(s1) != len(s2) {
return false
}
for i := range s1 {
if s1[i] != s2[i] {
return false
}
}
return true
}
// EqualFunc reports whether two slices are equal using an equality
// function on each pair of elements. If the lengths are different,
// EqualFunc returns false. Otherwise, the elements are compared in
// increasing index order, and the comparison stops at the first index
// for which eq returns false.
func EqualFunc[S1 ~[]E1, S2 ~[]E2, E1, E2 any](s1 S1, s2 S2, eq func(E1, E2) bool) bool {
if len(s1) != len(s2) {
return false
}
for i, v1 := range s1 {
v2 := s2[i]
if !eq(v1, v2) {
return false
}
}
return true
}
// Compare compares the elements of s1 and s2, using [cmp.Compare] on each pair
// of elements. The elements are compared sequentially, starting at index 0,
// until one element is not equal to the other.
// The result of comparing the first non-matching elements is returned.
// If both slices are equal until one of them ends, the shorter slice is
// considered less than the longer one.
// The result is 0 if s1 == s2, -1 if s1 < s2, and +1 if s1 > s2.
func Compare[S ~[]E, E cmp.Ordered](s1, s2 S) int {
for i, v1 := range s1 {
if i >= len(s2) {
return +1
}
v2 := s2[i]
if c := cmp.Compare(v1, v2); c != 0 {
return c
}
}
if len(s1) < len(s2) {
return -1
}
return 0
}
// CompareFunc is like [Compare] but uses a custom comparison function on each
// pair of elements.
// The result is the first non-zero result of cmp; if cmp always
// returns 0 the result is 0 if len(s1) == len(s2), -1 if len(s1) < len(s2),
// and +1 if len(s1) > len(s2).
func CompareFunc[S1 ~[]E1, S2 ~[]E2, E1, E2 any](s1 S1, s2 S2, cmp func(E1, E2) int) int {
for i, v1 := range s1 {
if i >= len(s2) {
return +1
}
v2 := s2[i]
if c := cmp(v1, v2); c != 0 {
return c
}
}
if len(s1) < len(s2) {
return -1
}
return 0
}
// Index returns the index of the first occurrence of v in s,
// or -1 if not present.
func Index[S ~[]E, E comparable](s S, v E) int {
for i := range s {
if v == s[i] {
return i
}
}
return -1
}
// IndexFunc returns the first index i satisfying f(s[i]),
// or -1 if none do.
func IndexFunc[S ~[]E, E any](s S, f func(E) bool) int {
for i := range s {
if f(s[i]) {
return i
}
}
return -1
}
// Contains reports whether v is present in s.
func Contains[S ~[]E, E comparable](s S, v E) bool {
return Index(s, v) >= 0
}
// ContainsFunc reports whether at least one
// element e of s satisfies f(e).
func ContainsFunc[S ~[]E, E any](s S, f func(E) bool) bool {
return IndexFunc(s, f) >= 0
}
// Insert inserts the values v... into s at index i,
// returning the modified slice.
// The elements at s[i:] are shifted up to make room.
// In the returned slice r, r[i] == v[0],
// and r[i+len(v)] == value originally at r[i].
// Insert panics if i is out of range.
// This function is O(len(s) + len(v)).
func Insert[S ~[]E, E any](s S, i int, v ...E) S {
m := len(v)
if m == 0 {
return s
}
n := len(s)
if i == n {
return append(s, v...)
}
if n+m > cap(s) {
// Use append rather than make so that we bump the size of
// the slice up to the next storage class.
// This is what Grow does but we don't call Grow because
// that might copy the values twice.
s2 := append(s[:i], make(S, n+m-i)...)
copy(s2[i:], v)
copy(s2[i+m:], s[i:])
return s2
}
s = s[:n+m]
// before:
// s: aaaaaaaabbbbccccccccdddd
// ^ ^ ^ ^
// i i+m n n+m
// after:
// s: aaaaaaaavvvvbbbbcccccccc
// ^ ^ ^ ^
// i i+m n n+m
//
// a are the values that don't move in s.
// v are the values copied in from v.
// b and c are the values from s that are shifted up in index.
// d are the values that get overwritten, never to be seen again.
if !overlaps(v, s[i+m:]) {
// Easy case - v does not overlap either the c or d regions.
// (It might be in some of a or b, or elsewhere entirely.)
// The data we copy up doesn't write to v at all, so just do it.
copy(s[i+m:], s[i:])
// Now we have
// s: aaaaaaaabbbbbbbbcccccccc
// ^ ^ ^ ^
// i i+m n n+m
// Note the b values are duplicated.
copy(s[i:], v)
// Now we have
// s: aaaaaaaavvvvbbbbcccccccc
// ^ ^ ^ ^
// i i+m n n+m
// That's the result we want.
return s
}
// The hard case - v overlaps c or d. We can't just shift up
// the data because we'd move or clobber the values we're trying
// to insert.
// So instead, write v on top of d, then rotate.
copy(s[n:], v)
// Now we have
// s: aaaaaaaabbbbccccccccvvvv
// ^ ^ ^ ^
// i i+m n n+m
rotateRight(s[i:], m)
// Now we have
// s: aaaaaaaavvvvbbbbcccccccc
// ^ ^ ^ ^
// i i+m n n+m
// That's the result we want.
return s
}
// Delete removes the elements s[i:j] from s, returning the modified slice.
// Delete panics if s[i:j] is not a valid slice of s.
// Delete is O(len(s)-j), so if many items must be deleted, it is better to
// make a single call deleting them all together than to delete one at a time.
// Delete might not modify the elements s[len(s)-(j-i):len(s)]. If those
// elements contain pointers you might consider zeroing those elements so that
// objects they reference can be garbage collected.
func Delete[S ~[]E, E any](s S, i, j int) S {
_ = s[i:j] // bounds check
return append(s[:i], s[j:]...)
}
// DeleteFunc removes any elements from s for which del returns true,
// returning the modified slice.
// When DeleteFunc removes m elements, it might not modify the elements
// s[len(s)-m:len(s)]. If those elements contain pointers you might consider
// zeroing those elements so that objects they reference can be garbage
// collected.
func DeleteFunc[S ~[]E, E any](s S, del func(E) bool) S {
// Don't start copying elements until we find one to delete.
for i, v := range s {
if del(v) {
j := i
for i++; i < len(s); i++ {
v = s[i]
if !del(v) {
s[j] = v
j++
}
}
return s[:j]
}
}
return s
}
// Replace replaces the elements s[i:j] by the given v, and returns the
// modified slice. Replace panics if s[i:j] is not a valid slice of s.
func Replace[S ~[]E, E any](s S, i, j int, v ...E) S {
_ = s[i:j] // verify that i:j is a valid subslice
if i == j {
return Insert(s, i, v...)
}
if j == len(s) {
return append(s[:i], v...)
}
tot := len(s[:i]) + len(v) + len(s[j:])
if tot > cap(s) {
// Too big to fit, allocate and copy over.
s2 := append(s[:i], make(S, tot-i)...) // See Insert
copy(s2[i:], v)
copy(s2[i+len(v):], s[j:])
return s2
}
r := s[:tot]
if i+len(v) <= j {
// Easy, as v fits in the deleted portion.
copy(r[i:], v)
if i+len(v) != j {
copy(r[i+len(v):], s[j:])
}
return r
}
// We are expanding (v is bigger than j-i).
// The situation is something like this:
// (example has i=4,j=8,len(s)=16,len(v)=6)
// s: aaaaxxxxbbbbbbbbyy
// ^ ^ ^ ^
// i j len(s) tot
// a: prefix of s
// x: deleted range
// b: more of s
// y: area to expand into
if !overlaps(r[i+len(v):], v) {
// Easy, as v is not clobbered by the first copy.
copy(r[i+len(v):], s[j:])
copy(r[i:], v)
return r
}
// This is a situation where we don't have a single place to which
// we can copy v. Parts of it need to go to two different places.
// We want to copy the prefix of v into y and the suffix into x, then
// rotate |y| spots to the right.
//
// v[2:] v[:2]
// | |
// s: aaaavvvvbbbbbbbbvv
// ^ ^ ^ ^
// i j len(s) tot
//
// If either of those two destinations don't alias v, then we're good.
y := len(v) - (j - i) // length of y portion
if !overlaps(r[i:j], v) {
copy(r[i:j], v[y:])
copy(r[len(s):], v[:y])
rotateRight(r[i:], y)
return r
}
if !overlaps(r[len(s):], v) {
copy(r[len(s):], v[:y])
copy(r[i:j], v[y:])
rotateRight(r[i:], y)
return r
}
// Now we know that v overlaps both x and y.
// That means that the entirety of b is *inside* v.
// So we don't need to preserve b at all; instead we
// can copy v first, then copy the b part of v out of
// v to the right destination.
k := startIdx(v, s[j:])
copy(r[i:], v)
copy(r[i+len(v):], r[i+k:])
return r
}
// Clone returns a copy of the slice.
// The elements are copied using assignment, so this is a shallow clone.
func Clone[S ~[]E, E any](s S) S {
// Preserve nil in case it matters.
if s == nil {
return nil
}
return append(S([]E{}), s...)
}
// Compact replaces consecutive runs of equal elements with a single copy.
// This is like the uniq command found on Unix.
// Compact modifies the contents of the slice s and returns the modified slice,
// which may have a smaller length.
// When Compact discards m elements in total, it might not modify the elements
// s[len(s)-m:len(s)]. If those elements contain pointers you might consider
// zeroing those elements so that objects they reference can be garbage collected.
func Compact[S ~[]E, E comparable](s S) S {
if len(s) < 2 {
return s
}
i := 1
for k := 1; k < len(s); k++ {
if s[k] != s[k-1] {
if i != k {
s[i] = s[k]
}
i++
}
}
return s[:i]
}
// CompactFunc is like [Compact] but uses an equality function to compare elements.
// For runs of elements that compare equal, CompactFunc keeps the first one.
func CompactFunc[S ~[]E, E any](s S, eq func(E, E) bool) S {
if len(s) < 2 {
return s
}
i := 1
for k := 1; k < len(s); k++ {
if !eq(s[k], s[k-1]) {
if i != k {
s[i] = s[k]
}
i++
}
}
return s[:i]
}
// Grow increases the slice's capacity, if necessary, to guarantee space for
// another n elements. After Grow(n), at least n elements can be appended
// to the slice without another allocation. If n is negative or too large to
// allocate the memory, Grow panics.
func Grow[S ~[]E, E any](s S, n int) S {
if n < 0 {
panic("cannot be negative")
}
if n -= cap(s) - len(s); n > 0 {
s = append(s[:cap(s)], make([]E, n)...)[:len(s)]
}
return s
}
// Clip removes unused capacity from the slice, returning s[:len(s):len(s)].
func Clip[S ~[]E, E any](s S) S {
return s[:len(s):len(s)]
}
// Rotation algorithm explanation:
//
// rotate left by 2
// start with
// 0123456789
// split up like this
// 01 234567 89
// swap first 2 and last 2
// 89 234567 01
// join first parts
// 89234567 01
// recursively rotate first left part by 2
// 23456789 01
// join at the end
// 2345678901
//
// rotate left by 8
// start with
// 0123456789
// split up like this
// 01 234567 89
// swap first 2 and last 2
// 89 234567 01
// join last parts
// 89 23456701
// recursively rotate second part left by 6
// 89 01234567
// join at the end
// 8901234567
// TODO: There are other rotate algorithms.
// This algorithm has the desirable property that it moves each element exactly twice.
// The triple-reverse algorithm is simpler and more cache friendly, but takes more writes.
// The follow-cycles algorithm can be 1-write but it is not very cache friendly.
// rotateLeft rotates b left by n spaces.
// s_final[i] = s_orig[i+r], wrapping around.
func rotateLeft[E any](s []E, r int) {
for r != 0 && r != len(s) {
if r*2 <= len(s) {
swap(s[:r], s[len(s)-r:])
s = s[:len(s)-r]
} else {
swap(s[:len(s)-r], s[r:])
s, r = s[len(s)-r:], r*2-len(s)
}
}
}
func rotateRight[E any](s []E, r int) {
rotateLeft(s, len(s)-r)
}
// swap swaps the contents of x and y. x and y must be equal length and disjoint.
func swap[E any](x, y []E) {
for i := 0; i < len(x); i++ {
x[i], y[i] = y[i], x[i]
}
}
// overlaps reports whether the memory ranges a[0:len(a)] and b[0:len(b)] overlap.
func overlaps[E any](a, b []E) bool {
if len(a) == 0 || len(b) == 0 {
return false
}
elemSize := unsafe.Sizeof(a[0])
if elemSize == 0 {
return false
}
// TODO: use a runtime/unsafe facility once one becomes available. See issue 12445.
// Also see crypto/internal/alias/alias.go:AnyOverlap
return uintptr(unsafe.Pointer(&a[0])) <= uintptr(unsafe.Pointer(&b[len(b)-1]))+(elemSize-1) &&
uintptr(unsafe.Pointer(&b[0])) <= uintptr(unsafe.Pointer(&a[len(a)-1]))+(elemSize-1)
}
// startIdx returns the index in haystack where the needle starts.
// prerequisite: the needle must be aliased entirely inside the haystack.
func startIdx[E any](haystack, needle []E) int {
p := &needle[0]
for i := range haystack {
if p == &haystack[i] {
return i
}
}
// TODO: what if the overlap is by a non-integral number of Es?
panic("needle not found")
}
// Reverse reverses the elements of the slice in place.
func Reverse[S ~[]E, E any](s S) {
for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 {
s[i], s[j] = s[j], s[i]
}
}
// Copyright 2023 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
//package slices
//import (
// "cmp"
// "math/bits"
//)
// Sort sorts a slice of any ordered type in ascending order.
// When sorting floating-point numbers, NaNs are ordered before other values.
func Sort[S ~[]E, E cmp.Ordered](x S) {
n := len(x)
pdqsortOrdered(x, 0, n, bits.Len(uint(n)))
}
// SortFunc sorts the slice x in ascending order as determined by the cmp
// function. This sort is not guaranteed to be stable.
// cmp(a, b) should return a negative number when a < b, a positive number when
// a > b and zero when a == b.
//
// SortFunc requires that cmp is a strict weak ordering.
// See https://en.wikipedia.org/wiki/Weak_ordering#Strict_weak_orderings.
func SortFunc[S ~[]E, E any](x S, cmp func(a, b E) int) {
n := len(x)
pdqsortCmpFunc(x, 0, n, bits.Len(uint(n)), cmp)
}
// SortStableFunc sorts the slice x while keeping the original order of equal
// elements, using cmp to compare elements in the same way as [SortFunc].
func SortStableFunc[S ~[]E, E any](x S, cmp func(a, b E) int) {
stableCmpFunc(x, len(x), cmp)
}
// IsSorted reports whether x is sorted in ascending order.
func IsSorted[S ~[]E, E cmp.Ordered](x S) bool {
for i := len(x) - 1; i > 0; i-- {
if cmp.Less(x[i], x[i-1]) {
return false
}
}
return true
}
// IsSortedFunc reports whether x is sorted in ascending order, with cmp as the
// comparison function as defined by [SortFunc].
func IsSortedFunc[S ~[]E, E any](x S, cmp func(a, b E) int) bool {
for i := len(x) - 1; i > 0; i-- {
if cmp(x[i], x[i-1]) < 0 {
return false
}
}
return true
}
// Min returns the minimal value in x. It panics if x is empty.
// For floating-point numbers, Min propagates NaNs (any NaN value in x
// forces the output to be NaN).
func Min[S ~[]E, E cmp.Ordered](x S) E {
if len(x) < 1 {
panic("slices.Min: empty list")
}
m := x[0]
for i := 1; i < len(x); i++ {
m = min(m, x[i])
}
return m
}
// MinFunc returns the minimal value in x, using cmp to compare elements.
// It panics if x is empty. If there is more than one minimal element
// according to the cmp function, MinFunc returns the first one.
func MinFunc[S ~[]E, E any](x S, cmp func(a, b E) int) E {
if len(x) < 1 {
panic("slices.MinFunc: empty list")
}
m := x[0]
for i := 1; i < len(x); i++ {
if cmp(x[i], m) < 0 {
m = x[i]
}
}
return m
}
// Max returns the maximal value in x. It panics if x is empty.
// For floating-point E, Max propagates NaNs (any NaN value in x
// forces the output to be NaN).
func Max[S ~[]E, E cmp.Ordered](x S) E {
if len(x) < 1 {
panic("slices.Max: empty list")
}
m := x[0]
for i := 1; i < len(x); i++ {
m = max(m, x[i])
}
return m
}
// MaxFunc returns the maximal value in x, using cmp to compare elements.
// It panics if x is empty. If there is more than one maximal element
// according to the cmp function, MaxFunc returns the first one.
func MaxFunc[S ~[]E, E any](x S, cmp func(a, b E) int) E {
if len(x) < 1 {
panic("slices.MaxFunc: empty list")
}
m := x[0]
for i := 1; i < len(x); i++ {
if cmp(x[i], m) > 0 {
m = x[i]
}
}
return m
}
// BinarySearch searches for target in a sorted slice and returns the position
// where target is found, or the position where target would appear in the
// sort order; it also returns a bool saying whether the target is really found
// in the slice. The slice must be sorted in increasing order.
func BinarySearch[S ~[]E, E cmp.Ordered](x S, target E) (int, bool) {
// Inlining is faster than calling BinarySearchFunc with a lambda.
n := len(x)
// Define x[-1] < target and x[n] >= target.
// Invariant: x[i-1] < target, x[j] >= target.
i, j := 0, n
for i < j {
h := int(uint(i+j) >> 1) // avoid overflow when computing h
// i ≤ h < j
if cmp.Less(x[h], target) {
i = h + 1 // preserves x[i-1] < target
} else {
j = h // preserves x[j] >= target
}
}
// i == j, x[i-1] < target, and x[j] (= x[i]) >= target => answer is i.
return i, i < n && (x[i] == target || (isNaN(x[i]) && isNaN(target)))
}
// BinarySearchFunc works like [BinarySearch], but uses a custom comparison
// function. The slice must be sorted in increasing order, where "increasing"
// is defined by cmp. cmp should return 0 if the slice element matches
// the target, a negative number if the slice element precedes the target,
// or a positive number if the slice element follows the target.
// cmp must implement the same ordering as the slice, such that if
// cmp(a, t) < 0 and cmp(b, t) >= 0, then a must precede b in the slice.
func BinarySearchFunc[S ~[]E, E, T any](x S, target T, cmp func(E, T) int) (int, bool) {
n := len(x)
// Define cmp(x[-1], target) < 0 and cmp(x[n], target) >= 0 .
// Invariant: cmp(x[i - 1], target) < 0, cmp(x[j], target) >= 0.
i, j := 0, n
for i < j {
h := int(uint(i+j) >> 1) // avoid overflow when computing h
// i ≤ h < j
if cmp(x[h], target) < 0 {
i = h + 1 // preserves cmp(x[i - 1], target) < 0
} else {
j = h // preserves cmp(x[j], target) >= 0
}
}
// i == j, cmp(x[i-1], target) < 0, and cmp(x[j], target) (= cmp(x[i], target)) >= 0 => answer is i.
return i, i < n && cmp(x[i], target) == 0
}
type sortedHint int // hint for pdqsort when choosing the pivot
const (
unknownHint sortedHint = iota
increasingHint
decreasingHint
)
// xorshift paper: https://www.jstatsoft.org/article/view/v008i14/xorshift.pdf
type xorshift uint64
func (r *xorshift) Next() uint64 {
*r ^= *r << 13
*r ^= *r >> 17
*r ^= *r << 5
return uint64(*r)
}
func nextPowerOfTwo(length int) uint {
return 1 << bits.Len(uint(length))
}
// isNaN reports whether x is a NaN without requiring the math package.
// This will always return false if T is not floating-point.
func isNaN[T cmp.Ordered](x T) bool {
return x != x
}
// Code generated by gen_sort_variants.go; DO NOT EDIT.
// Copyright 2022 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// package slices
// insertionSortCmpFunc sorts data[a:b] using insertion sort.
func insertionSortCmpFunc[E any](data []E, a, b int, cmp func(a, b E) int) {
for i := a + 1; i < b; i++ {
for j := i; j > a && (cmp(data[j], data[j-1]) < 0); j-- {
data[j], data[j-1] = data[j-1], data[j]
}
}
}
// siftDownCmpFunc implements the heap property on data[lo:hi].
// first is an offset into the array where the root of the heap lies.
func siftDownCmpFunc[E any](data []E, lo, hi, first int, cmp func(a, b E) int) {
root := lo
for {
child := 2*root + 1
if child >= hi {
break
}
if child+1 < hi && (cmp(data[first+child], data[first+child+1]) < 0) {
child++
}
if !(cmp(data[first+root], data[first+child]) < 0) {
return
}
data[first+root], data[first+child] = data[first+child], data[first+root]
root = child
}
}
func heapSortCmpFunc[E any](data []E, a, b int, cmp func(a, b E) int) {
first := a
lo := 0
hi := b - a
// Build heap with greatest element at top.
for i := (hi - 1) / 2; i >= 0; i-- {
siftDownCmpFunc(data, i, hi, first, cmp)
}
// Pop elements, largest first, into end of data.
for i := hi - 1; i >= 0; i-- {
data[first], data[first+i] = data[first+i], data[first]
siftDownCmpFunc(data, lo, i, first, cmp)
}
}
// pdqsortCmpFunc sorts data[a:b].
// The algorithm based on pattern-defeating quicksort(pdqsort), but without the optimizations from BlockQuicksort.
// pdqsort paper: https://arxiv.org/pdf/2106.05123.pdf
// C++ implementation: https://github.com/orlp/pdqsort
// Rust implementation: https://docs.rs/pdqsort/latest/pdqsort/
// limit is the number of allowed bad (very unbalanced) pivots before falling back to heapsort.
func pdqsortCmpFunc[E any](data []E, a, b, limit int, cmp func(a, b E) int) {
const maxInsertion = 12
var (
wasBalanced = true // whether the last partitioning was reasonably balanced
wasPartitioned = true // whether the slice was already partitioned
)
for {
length := b - a
if length <= maxInsertion {
insertionSortCmpFunc(data, a, b, cmp)
return
}
// Fall back to heapsort if too many bad choices were made.
if limit == 0 {
heapSortCmpFunc(data, a, b, cmp)
return
}
// If the last partitioning was imbalanced, we need to breaking patterns.
if !wasBalanced {
breakPatternsCmpFunc(data, a, b, cmp)
limit--
}
pivot, hint := choosePivotCmpFunc(data, a, b, cmp)
if hint == decreasingHint {
reverseRangeCmpFunc(data, a, b, cmp)
// The chosen pivot was pivot-a elements after the start of the array.
// After reversing it is pivot-a elements before the end of the array.
// The idea came from Rust's implementation.
pivot = (b - 1) - (pivot - a)
hint = increasingHint
}
// The slice is likely already sorted.
if wasBalanced && wasPartitioned && hint == increasingHint {
if partialInsertionSortCmpFunc(data, a, b, cmp) {
return
}
}
// Probably the slice contains many duplicate elements, partition the slice into
// elements equal to and elements greater than the pivot.
if a > 0 && !(cmp(data[a-1], data[pivot]) < 0) {
mid := partitionEqualCmpFunc(data, a, b, pivot, cmp)
a = mid
continue
}
mid, alreadyPartitioned := partitionCmpFunc(data, a, b, pivot, cmp)
wasPartitioned = alreadyPartitioned
leftLen, rightLen := mid-a, b-mid
balanceThreshold := length / 8
if leftLen < rightLen {
wasBalanced = leftLen >= balanceThreshold
pdqsortCmpFunc(data, a, mid, limit, cmp)
a = mid + 1
} else {
wasBalanced = rightLen >= balanceThreshold
pdqsortCmpFunc(data, mid+1, b, limit, cmp)
b = mid
}
}
}
// partitionCmpFunc does one quicksort partition.
// Let p = data[pivot]
// Moves elements in data[a:b] around, so that data[i]=p for inewpivot.
// On return, data[newpivot] = p
func partitionCmpFunc[E any](data []E, a, b, pivot int, cmp func(a, b E) int) (newpivot int, alreadyPartitioned bool) {
data[a], data[pivot] = data[pivot], data[a]
i, j := a+1, b-1 // i and j are inclusive of the elements remaining to be partitioned
for i <= j && (cmp(data[i], data[a]) < 0) {
i++
}
for i <= j && !(cmp(data[j], data[a]) < 0) {
j--
}
if i > j {
data[j], data[a] = data[a], data[j]
return j, true
}
data[i], data[j] = data[j], data[i]
i++
j--
for {
for i <= j && (cmp(data[i], data[a]) < 0) {
i++
}
for i <= j && !(cmp(data[j], data[a]) < 0) {
j--
}
if i > j {
break
}
data[i], data[j] = data[j], data[i]
i++
j--
}
data[j], data[a] = data[a], data[j]
return j, false
}
// partitionEqualCmpFunc partitions data[a:b] into elements equal to data[pivot] followed by elements greater than data[pivot].
// It assumed that data[a:b] does not contain elements smaller than the data[pivot].
func partitionEqualCmpFunc[E any](data []E, a, b, pivot int, cmp func(a, b E) int) (newpivot int) {
data[a], data[pivot] = data[pivot], data[a]
i, j := a+1, b-1 // i and j are inclusive of the elements remaining to be partitioned
for {
for i <= j && !(cmp(data[a], data[i]) < 0) {
i++
}
for i <= j && (cmp(data[a], data[j]) < 0) {
j--
}
if i > j {
break
}
data[i], data[j] = data[j], data[i]
i++
j--
}
return i
}
// partialInsertionSortCmpFunc partially sorts a slice, returns true if the slice is sorted at the end.
func partialInsertionSortCmpFunc[E any](data []E, a, b int, cmp func(a, b E) int) bool {
const (
maxSteps = 5 // maximum number of adjacent out-of-order pairs that will get shifted
shortestShifting = 50 // don't shift any elements on short arrays
)
i := a + 1
for j := 0; j < maxSteps; j++ {
for i < b && !(cmp(data[i], data[i-1]) < 0) {
i++
}
if i == b {
return true
}
if b-a < shortestShifting {
return false
}
data[i], data[i-1] = data[i-1], data[i]
// Shift the smaller one to the left.
if i-a >= 2 {
for j := i - 1; j >= 1; j-- {
if !(cmp(data[j], data[j-1]) < 0) {
break
}
data[j], data[j-1] = data[j-1], data[j]
}
}
// Shift the greater one to the right.
if b-i >= 2 {
for j := i + 1; j < b; j++ {
if !(cmp(data[j], data[j-1]) < 0) {
break
}
data[j], data[j-1] = data[j-1], data[j]
}
}
}
return false
}
// breakPatternsCmpFunc scatters some elements around in an attempt to break some patterns
// that might cause imbalanced partitions in quicksort.
func breakPatternsCmpFunc[E any](data []E, a, b int, cmp func(a, b E) int) {
length := b - a
if length >= 8 {
random := xorshift(length)
modulus := nextPowerOfTwo(length)
for idx := a + (length/4)*2 - 1; idx <= a+(length/4)*2+1; idx++ {
other := int(uint(random.Next()) & (modulus - 1))
if other >= length {
other -= length
}
data[idx], data[a+other] = data[a+other], data[idx]
}
}
}
// choosePivotCmpFunc chooses a pivot in data[a:b].
//
// [0,8): chooses a static pivot.
// [8,shortestNinther): uses the simple median-of-three method.
// [shortestNinther,∞): uses the Tukey ninther method.
func choosePivotCmpFunc[E any](data []E, a, b int, cmp func(a, b E) int) (pivot int, hint sortedHint) {
const (
shortestNinther = 50
maxSwaps = 4 * 3
)
l := b - a
var (
swaps int
i = a + l/4*1
j = a + l/4*2
k = a + l/4*3
)
if l >= 8 {
if l >= shortestNinther {
// Tukey ninther method, the idea came from Rust's implementation.
i = medianAdjacentCmpFunc(data, i, &swaps, cmp)
j = medianAdjacentCmpFunc(data, j, &swaps, cmp)
k = medianAdjacentCmpFunc(data, k, &swaps, cmp)
}
// Find the median among i, j, k and stores it into j.
j = medianCmpFunc(data, i, j, k, &swaps, cmp)
}
switch swaps {
case 0:
return j, increasingHint
case maxSwaps:
return j, decreasingHint
default:
return j, unknownHint
}
}
// order2CmpFunc returns x,y where data[x] <= data[y], where x,y=a,b or x,y=b,a.
func order2CmpFunc[E any](data []E, a, b int, swaps *int, cmp func(a, b E) int) (int, int) {
if cmp(data[b], data[a]) < 0 {
*swaps++
return b, a
}
return a, b
}
// medianCmpFunc returns x where data[x] is the median of data[a],data[b],data[c], where x is a, b, or c.
func medianCmpFunc[E any](data []E, a, b, c int, swaps *int, cmp func(a, b E) int) int {
a, b = order2CmpFunc(data, a, b, swaps, cmp)
b, c = order2CmpFunc(data, b, c, swaps, cmp)
a, b = order2CmpFunc(data, a, b, swaps, cmp)
return b
}
// medianAdjacentCmpFunc finds the median of data[a - 1], data[a], data[a + 1] and stores the index into a.
func medianAdjacentCmpFunc[E any](data []E, a int, swaps *int, cmp func(a, b E) int) int {
return medianCmpFunc(data, a-1, a, a+1, swaps, cmp)
}
func reverseRangeCmpFunc[E any](data []E, a, b int, cmp func(a, b E) int) {
i := a
j := b - 1
for i < j {
data[i], data[j] = data[j], data[i]
i++
j--
}
}
func swapRangeCmpFunc[E any](data []E, a, b, n int, cmp func(a, b E) int) {
for i := 0; i < n; i++ {
data[a+i], data[b+i] = data[b+i], data[a+i]
}
}
func stableCmpFunc[E any](data []E, n int, cmp func(a, b E) int) {
blockSize := 20 // must be > 0
a, b := 0, blockSize
for b <= n {
insertionSortCmpFunc(data, a, b, cmp)
a = b
b += blockSize
}
insertionSortCmpFunc(data, a, n, cmp)
for blockSize < n {
a, b = 0, 2*blockSize
for b <= n {
symMergeCmpFunc(data, a, a+blockSize, b, cmp)
a = b
b += 2 * blockSize
}
if m := a + blockSize; m < n {
symMergeCmpFunc(data, a, m, n, cmp)
}
blockSize *= 2
}
}
// symMergeCmpFunc merges the two sorted subsequences data[a:m] and data[m:b] using
// the SymMerge algorithm from Pok-Son Kim and Arne Kutzner, "Stable Minimum
// Storage Merging by Symmetric Comparisons", in Susanne Albers and Tomasz
// Radzik, editors, Algorithms - ESA 2004, volume 3221 of Lecture Notes in
// Computer Science, pages 714-723. Springer, 2004.
//
// Let M = m-a and N = b-n. Wolog M < N.
// The recursion depth is bound by ceil(log(N+M)).
// The algorithm needs O(M*log(N/M + 1)) calls to data.Less.
// The algorithm needs O((M+N)*log(M)) calls to data.Swap.
//
// The paper gives O((M+N)*log(M)) as the number of assignments assuming a
// rotation algorithm which uses O(M+N+gcd(M+N)) assignments. The argumentation
// in the paper carries through for Swap operations, especially as the block
// swapping rotate uses only O(M+N) Swaps.
//
// symMerge assumes non-degenerate arguments: a < m && m < b.
// Having the caller check this condition eliminates many leaf recursion calls,
// which improves performance.
func symMergeCmpFunc[E any](data []E, a, m, b int, cmp func(a, b E) int) {
// Avoid unnecessary recursions of symMerge
// by direct insertion of data[a] into data[m:b]
// if data[a:m] only contains one element.
if m-a == 1 {
// Use binary search to find the lowest index i
// such that data[i] >= data[a] for m <= i < b.
// Exit the search loop with i == b in case no such index exists.
i := m
j := b
for i < j {
h := int(uint(i+j) >> 1)
if cmp(data[h], data[a]) < 0 {
i = h + 1
} else {
j = h
}
}
// Swap values until data[a] reaches the position before i.
for k := a; k < i-1; k++ {
data[k], data[k+1] = data[k+1], data[k]
}
return
}
// Avoid unnecessary recursions of symMerge
// by direct insertion of data[m] into data[a:m]
// if data[m:b] only contains one element.
if b-m == 1 {
// Use binary search to find the lowest index i
// such that data[i] > data[m] for a <= i < m.
// Exit the search loop with i == m in case no such index exists.
i := a
j := m
for i < j {
h := int(uint(i+j) >> 1)
if !(cmp(data[m], data[h]) < 0) {
i = h + 1
} else {
j = h
}
}
// Swap values until data[m] reaches the position i.
for k := m; k > i; k-- {
data[k], data[k-1] = data[k-1], data[k]
}
return
}
mid := int(uint(a+b) >> 1)
n := mid + m
var start, r int
if m > mid {
start = n - b
r = mid
} else {
start = a
r = m
}
p := n - 1
for start < r {
c := int(uint(start+r) >> 1)
if !(cmp(data[p-c], data[c]) < 0) {
start = c + 1
} else {
r = c
}
}
end := n - start
if start < m && m < end {
rotateCmpFunc(data, start, m, end, cmp)
}
if a < start && start < mid {
symMergeCmpFunc(data, a, start, mid, cmp)
}
if mid < end && end < b {
symMergeCmpFunc(data, mid, end, b, cmp)
}
}
// rotateCmpFunc rotates two consecutive blocks u = data[a:m] and v = data[m:b] in data:
// Data of the form 'x u v y' is changed to 'x v u y'.
// rotate performs at most b-a many calls to data.Swap,
// and it assumes non-degenerate arguments: a < m && m < b.
func rotateCmpFunc[E any](data []E, a, m, b int, cmp func(a, b E) int) {
i := m - a
j := b - m
for i != j {
if i > j {
swapRangeCmpFunc(data, m-i, m, j, cmp)
i -= j
} else {
swapRangeCmpFunc(data, m-i, m+j-i, i, cmp)
j -= i
}
}
// i == j
swapRangeCmpFunc(data, m-i, m, i, cmp)
}
// Code generated by gen_sort_variants.go; DO NOT EDIT.
// Copyright 2022 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// package slices
// import "cmp"
// insertionSortOrdered sorts data[a:b] using insertion sort.
func insertionSortOrdered[E cmp.Ordered](data []E, a, b int) {
for i := a + 1; i < b; i++ {
for j := i; j > a && cmp.Less(data[j], data[j-1]); j-- {
data[j], data[j-1] = data[j-1], data[j]
}
}
}
// siftDownOrdered implements the heap property on data[lo:hi].
// first is an offset into the array where the root of the heap lies.
func siftDownOrdered[E cmp.Ordered](data []E, lo, hi, first int) {
root := lo
for {
child := 2*root + 1
if child >= hi {
break
}
if child+1 < hi && cmp.Less(data[first+child], data[first+child+1]) {
child++
}
if !cmp.Less(data[first+root], data[first+child]) {
return
}
data[first+root], data[first+child] = data[first+child], data[first+root]
root = child
}
}
func heapSortOrdered[E cmp.Ordered](data []E, a, b int) {
first := a
lo := 0
hi := b - a
// Build heap with greatest element at top.
for i := (hi - 1) / 2; i >= 0; i-- {
siftDownOrdered(data, i, hi, first)
}
// Pop elements, largest first, into end of data.
for i := hi - 1; i >= 0; i-- {
data[first], data[first+i] = data[first+i], data[first]
siftDownOrdered(data, lo, i, first)
}
}
// pdqsortOrdered sorts data[a:b].
// The algorithm based on pattern-defeating quicksort(pdqsort), but without the optimizations from BlockQuicksort.
// pdqsort paper: https://arxiv.org/pdf/2106.05123.pdf
// C++ implementation: https://github.com/orlp/pdqsort
// Rust implementation: https://docs.rs/pdqsort/latest/pdqsort/
// limit is the number of allowed bad (very unbalanced) pivots before falling back to heapsort.
func pdqsortOrdered[E cmp.Ordered](data []E, a, b, limit int) {
const maxInsertion = 12
var (
wasBalanced = true // whether the last partitioning was reasonably balanced
wasPartitioned = true // whether the slice was already partitioned
)
for {
length := b - a
if length <= maxInsertion {
insertionSortOrdered(data, a, b)
return
}
// Fall back to heapsort if too many bad choices were made.
if limit == 0 {
heapSortOrdered(data, a, b)
return
}
// If the last partitioning was imbalanced, we need to breaking patterns.
if !wasBalanced {
breakPatternsOrdered(data, a, b)
limit--
}
pivot, hint := choosePivotOrdered(data, a, b)
if hint == decreasingHint {
reverseRangeOrdered(data, a, b)
// The chosen pivot was pivot-a elements after the start of the array.
// After reversing it is pivot-a elements before the end of the array.
// The idea came from Rust's implementation.
pivot = (b - 1) - (pivot - a)
hint = increasingHint
}
// The slice is likely already sorted.
if wasBalanced && wasPartitioned && hint == increasingHint {
if partialInsertionSortOrdered(data, a, b) {
return
}
}
// Probably the slice contains many duplicate elements, partition the slice into
// elements equal to and elements greater than the pivot.
if a > 0 && !cmp.Less(data[a-1], data[pivot]) {
mid := partitionEqualOrdered(data, a, b, pivot)
a = mid
continue
}
mid, alreadyPartitioned := partitionOrdered(data, a, b, pivot)
wasPartitioned = alreadyPartitioned
leftLen, rightLen := mid-a, b-mid
balanceThreshold := length / 8
if leftLen < rightLen {
wasBalanced = leftLen >= balanceThreshold
pdqsortOrdered(data, a, mid, limit)
a = mid + 1
} else {
wasBalanced = rightLen >= balanceThreshold
pdqsortOrdered(data, mid+1, b, limit)
b = mid
}
}
}
// partitionOrdered does one quicksort partition.
// Let p = data[pivot]
// Moves elements in data[a:b] around, so that data[i]=p for inewpivot.
// On return, data[newpivot] = p
func partitionOrdered[E cmp.Ordered](data []E, a, b, pivot int) (newpivot int, alreadyPartitioned bool) {
data[a], data[pivot] = data[pivot], data[a]
i, j := a+1, b-1 // i and j are inclusive of the elements remaining to be partitioned
for i <= j && cmp.Less(data[i], data[a]) {
i++
}
for i <= j && !cmp.Less(data[j], data[a]) {
j--
}
if i > j {
data[j], data[a] = data[a], data[j]
return j, true
}
data[i], data[j] = data[j], data[i]
i++
j--
for {
for i <= j && cmp.Less(data[i], data[a]) {
i++
}
for i <= j && !cmp.Less(data[j], data[a]) {
j--
}
if i > j {
break
}
data[i], data[j] = data[j], data[i]
i++
j--
}
data[j], data[a] = data[a], data[j]
return j, false
}
// partitionEqualOrdered partitions data[a:b] into elements equal to data[pivot] followed by elements greater than data[pivot].
// It assumed that data[a:b] does not contain elements smaller than the data[pivot].
func partitionEqualOrdered[E cmp.Ordered](data []E, a, b, pivot int) (newpivot int) {
data[a], data[pivot] = data[pivot], data[a]
i, j := a+1, b-1 // i and j are inclusive of the elements remaining to be partitioned
for {
for i <= j && !cmp.Less(data[a], data[i]) {
i++
}
for i <= j && cmp.Less(data[a], data[j]) {
j--
}
if i > j {
break
}
data[i], data[j] = data[j], data[i]
i++
j--
}
return i
}
// partialInsertionSortOrdered partially sorts a slice, returns true if the slice is sorted at the end.
func partialInsertionSortOrdered[E cmp.Ordered](data []E, a, b int) bool {
const (
maxSteps = 5 // maximum number of adjacent out-of-order pairs that will get shifted
shortestShifting = 50 // don't shift any elements on short arrays
)
i := a + 1
for j := 0; j < maxSteps; j++ {
for i < b && !cmp.Less(data[i], data[i-1]) {
i++
}
if i == b {
return true
}
if b-a < shortestShifting {
return false
}
data[i], data[i-1] = data[i-1], data[i]
// Shift the smaller one to the left.
if i-a >= 2 {
for j := i - 1; j >= 1; j-- {
if !cmp.Less(data[j], data[j-1]) {
break
}
data[j], data[j-1] = data[j-1], data[j]
}
}
// Shift the greater one to the right.
if b-i >= 2 {
for j := i + 1; j < b; j++ {
if !cmp.Less(data[j], data[j-1]) {
break
}
data[j], data[j-1] = data[j-1], data[j]
}
}
}
return false
}
// breakPatternsOrdered scatters some elements around in an attempt to break some patterns
// that might cause imbalanced partitions in quicksort.
func breakPatternsOrdered[E cmp.Ordered](data []E, a, b int) {
length := b - a
if length >= 8 {
random := xorshift(length)
modulus := nextPowerOfTwo(length)
for idx := a + (length/4)*2 - 1; idx <= a+(length/4)*2+1; idx++ {
other := int(uint(random.Next()) & (modulus - 1))
if other >= length {
other -= length
}
data[idx], data[a+other] = data[a+other], data[idx]
}
}
}
// choosePivotOrdered chooses a pivot in data[a:b].
//
// [0,8): chooses a static pivot.
// [8,shortestNinther): uses the simple median-of-three method.
// [shortestNinther,∞): uses the Tukey ninther method.
func choosePivotOrdered[E cmp.Ordered](data []E, a, b int) (pivot int, hint sortedHint) {
const (
shortestNinther = 50
maxSwaps = 4 * 3
)
l := b - a
var (
swaps int
i = a + l/4*1
j = a + l/4*2
k = a + l/4*3
)
if l >= 8 {
if l >= shortestNinther {
// Tukey ninther method, the idea came from Rust's implementation.
i = medianAdjacentOrdered(data, i, &swaps)
j = medianAdjacentOrdered(data, j, &swaps)
k = medianAdjacentOrdered(data, k, &swaps)
}
// Find the median among i, j, k and stores it into j.
j = medianOrdered(data, i, j, k, &swaps)
}
switch swaps {
case 0:
return j, increasingHint
case maxSwaps:
return j, decreasingHint
default:
return j, unknownHint
}
}
// order2Ordered returns x,y where data[x] <= data[y], where x,y=a,b or x,y=b,a.
func order2Ordered[E cmp.Ordered](data []E, a, b int, swaps *int) (int, int) {
if cmp.Less(data[b], data[a]) {
*swaps++
return b, a
}
return a, b
}
// medianOrdered returns x where data[x] is the median of data[a],data[b],data[c], where x is a, b, or c.
func medianOrdered[E cmp.Ordered](data []E, a, b, c int, swaps *int) int {
a, b = order2Ordered(data, a, b, swaps)
b, c = order2Ordered(data, b, c, swaps)
a, b = order2Ordered(data, a, b, swaps)
return b
}
// medianAdjacentOrdered finds the median of data[a - 1], data[a], data[a + 1] and stores the index into a.
func medianAdjacentOrdered[E cmp.Ordered](data []E, a int, swaps *int) int {
return medianOrdered(data, a-1, a, a+1, swaps)
}
func reverseRangeOrdered[E cmp.Ordered](data []E, a, b int) {
i := a
j := b - 1
for i < j {
data[i], data[j] = data[j], data[i]
i++
j--
}
}
func swapRangeOrdered[E cmp.Ordered](data []E, a, b, n int) {
for i := 0; i < n; i++ {
data[a+i], data[b+i] = data[b+i], data[a+i]
}
}
func stableOrdered[E cmp.Ordered](data []E, n int) {
blockSize := 20 // must be > 0
a, b := 0, blockSize
for b <= n {
insertionSortOrdered(data, a, b)
a = b
b += blockSize
}
insertionSortOrdered(data, a, n)
for blockSize < n {
a, b = 0, 2*blockSize
for b <= n {
symMergeOrdered(data, a, a+blockSize, b)
a = b
b += 2 * blockSize
}
if m := a + blockSize; m < n {
symMergeOrdered(data, a, m, n)
}
blockSize *= 2
}
}
// symMergeOrdered merges the two sorted subsequences data[a:m] and data[m:b] using
// the SymMerge algorithm from Pok-Son Kim and Arne Kutzner, "Stable Minimum
// Storage Merging by Symmetric Comparisons", in Susanne Albers and Tomasz
// Radzik, editors, Algorithms - ESA 2004, volume 3221 of Lecture Notes in
// Computer Science, pages 714-723. Springer, 2004.
//
// Let M = m-a and N = b-n. Wolog M < N.
// The recursion depth is bound by ceil(log(N+M)).
// The algorithm needs O(M*log(N/M + 1)) calls to data.Less.
// The algorithm needs O((M+N)*log(M)) calls to data.Swap.
//
// The paper gives O((M+N)*log(M)) as the number of assignments assuming a
// rotation algorithm which uses O(M+N+gcd(M+N)) assignments. The argumentation
// in the paper carries through for Swap operations, especially as the block
// swapping rotate uses only O(M+N) Swaps.
//
// symMerge assumes non-degenerate arguments: a < m && m < b.
// Having the caller check this condition eliminates many leaf recursion calls,
// which improves performance.
func symMergeOrdered[E cmp.Ordered](data []E, a, m, b int) {
// Avoid unnecessary recursions of symMerge
// by direct insertion of data[a] into data[m:b]
// if data[a:m] only contains one element.
if m-a == 1 {
// Use binary search to find the lowest index i
// such that data[i] >= data[a] for m <= i < b.
// Exit the search loop with i == b in case no such index exists.
i := m
j := b
for i < j {
h := int(uint(i+j) >> 1)
if cmp.Less(data[h], data[a]) {
i = h + 1
} else {
j = h
}
}
// Swap values until data[a] reaches the position before i.
for k := a; k < i-1; k++ {
data[k], data[k+1] = data[k+1], data[k]
}
return
}
// Avoid unnecessary recursions of symMerge
// by direct insertion of data[m] into data[a:m]
// if data[m:b] only contains one element.
if b-m == 1 {
// Use binary search to find the lowest index i
// such that data[i] > data[m] for a <= i < m.
// Exit the search loop with i == m in case no such index exists.
i := a
j := m
for i < j {
h := int(uint(i+j) >> 1)
if !cmp.Less(data[m], data[h]) {
i = h + 1
} else {
j = h
}
}
// Swap values until data[m] reaches the position i.
for k := m; k > i; k-- {
data[k], data[k-1] = data[k-1], data[k]
}
return
}
mid := int(uint(a+b) >> 1)
n := mid + m
var start, r int
if m > mid {
start = n - b
r = mid
} else {
start = a
r = m
}
p := n - 1
for start < r {
c := int(uint(start+r) >> 1)
if !cmp.Less(data[p-c], data[c]) {
start = c + 1
} else {
r = c
}
}
end := n - start
if start < m && m < end {
rotateOrdered(data, start, m, end)
}
if a < start && start < mid {
symMergeOrdered(data, a, start, mid)
}
if mid < end && end < b {
symMergeOrdered(data, mid, end, b)
}
}
// rotateOrdered rotates two consecutive blocks u = data[a:m] and v = data[m:b] in data:
// Data of the form 'x u v y' is changed to 'x v u y'.
// rotate performs at most b-a many calls to data.Swap,
// and it assumes non-degenerate arguments: a < m && m < b.
func rotateOrdered[E cmp.Ordered](data []E, a, m, b int) {
i := m - a
j := b - m
for i != j {
if i > j {
swapRangeOrdered(data, m-i, m, j)
i -= j
} else {
swapRangeOrdered(data, m-i, m+j-i, i)
j -= i
}
}
// i == j
swapRangeOrdered(data, m-i, m, i)
}
================================================
FILE: stdlib/generic/go1_21_sync.go.txt
================================================
// Copyright 2022 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package sync
import (
"sync/atomic"
)
// OnceFunc returns a function that invokes f only once. The returned function
// may be called concurrently.
//
// If f panics, the returned function will panic with the same value on every call.
func OnceFunc(f func()) func() {
var (
once Once
valid bool
p any
)
// Construct the inner closure just once to reduce costs on the fast path.
g := func() {
defer func() {
p = recover()
if !valid {
// Re-panic immediately so on the first call the user gets a
// complete stack trace into f.
panic(p)
}
}()
f()
valid = true // Set only if f does not panic
}
return func() {
once.Do(g)
if !valid {
panic(p)
}
}
}
// OnceValue returns a function that invokes f only once and returns the value
// returned by f. The returned function may be called concurrently.
//
// If f panics, the returned function will panic with the same value on every call.
func OnceValue[T any](f func() T) func() T {
var (
once Once
valid bool
p any
result T
)
g := func() {
defer func() {
p = recover()
if !valid {
panic(p)
}
}()
result = f()
valid = true
}
return func() T {
once.Do(g)
if !valid {
panic(p)
}
return result
}
}
// OnceValues returns a function that invokes f only once and returns the values
// returned by f. The returned function may be called concurrently.
//
// If f panics, the returned function will panic with the same value on every call.
func OnceValues[T1, T2 any](f func() (T1, T2)) func() (T1, T2) {
var (
once Once
valid bool
p any
r1 T1
r2 T2
)
g := func() {
defer func() {
p = recover()
if !valid {
panic(p)
}
}()
r1, r2 = f()
valid = true
}
return func() (T1, T2) {
once.Do(g)
if !valid {
panic(p)
}
return r1, r2
}
}
// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
//package sync
// import (
// "sync/atomic"
// )
// Once is an object that will perform exactly one action.
//
// A Once must not be copied after first use.
//
// In the terminology of the Go memory model,
// the return from f “synchronizes before”
// the return from any call of once.Do(f).
type Once struct {
// done indicates whether the action has been performed.
// It is first in the struct because it is used in the hot path.
// The hot path is inlined at every call site.
// Placing done first allows more compact instructions on some architectures (amd64/386),
// and fewer instructions (to calculate offset) on other architectures.
done uint32
m Mutex
}
// Do calls the function f if and only if Do is being called for the
// first time for this instance of Once. In other words, given
//
// var once Once
//
// if once.Do(f) is called multiple times, only the first call will invoke f,
// even if f has a different value in each invocation. A new instance of
// Once is required for each function to execute.
//
// Do is intended for initialization that must be run exactly once. Since f
// is niladic, it may be necessary to use a function literal to capture the
// arguments to a function to be invoked by Do:
//
// config.once.Do(func() { config.init(filename) })
//
// Because no call to Do returns until the one call to f returns, if f causes
// Do to be called, it will deadlock.
//
// If f panics, Do considers it to have returned; future calls of Do return
// without calling f.
func (o *Once) Do(f func()) {
// Note: Here is an incorrect implementation of Do:
//
// if atomic.CompareAndSwapUint32(&o.done, 0, 1) {
// f()
// }
//
// Do guarantees that when it returns, f has finished.
// This implementation would not implement that guarantee:
// given two simultaneous calls, the winner of the cas would
// call f, and the second would return immediately, without
// waiting for the first's call to f to complete.
// This is why the slow path falls back to a mutex, and why
// the atomic.StoreUint32 must be delayed until after f returns.
if atomic.LoadUint32(&o.done) == 0 {
// Outlined slow-path to allow inlining of the fast-path.
o.doSlow(f)
}
}
func (o *Once) doSlow(f func()) {
o.m.Lock()
defer o.m.Unlock()
if o.done == 0 {
defer atomic.StoreUint32(&o.done, 1)
f()
}
}
================================================
FILE: stdlib/generic/go1_21_sync_atomic.go.txt
================================================
// Copyright 2022 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package atomic
import "unsafe"
// A Bool is an atomic boolean value.
// The zero value is false.
type Bool struct {
_ noCopy
v uint32
}
// Load atomically loads and returns the value stored in x.
func (x *Bool) Load() bool { return LoadUint32(&x.v) != 0 }
// Store atomically stores val into x.
func (x *Bool) Store(val bool) { StoreUint32(&x.v, b32(val)) }
// Swap atomically stores new into x and returns the previous value.
func (x *Bool) Swap(new bool) (old bool) { return SwapUint32(&x.v, b32(new)) != 0 }
// CompareAndSwap executes the compare-and-swap operation for the boolean value x.
func (x *Bool) CompareAndSwap(old, new bool) (swapped bool) {
return CompareAndSwapUint32(&x.v, b32(old), b32(new))
}
// b32 returns a uint32 0 or 1 representing b.
func b32(b bool) uint32 {
if b {
return 1
}
return 0
}
// For testing *Pointer[T]'s methods can be inlined.
// Keep in sync with cmd/compile/internal/test/inl_test.go:TestIntendedInlining.
var _ = &Pointer[int]{}
// A Pointer is an atomic pointer of type *T. The zero value is a nil *T.
type Pointer[T any] struct {
// Mention *T in a field to disallow conversion between Pointer types.
// See go.dev/issue/56603 for more details.
// Use *T, not T, to avoid spurious recursive type definition errors.
_ [0]*T
_ noCopy
v unsafe.Pointer
}
// Load atomically loads and returns the value stored in x.
func (x *Pointer[T]) Load() *T { return (*T)(LoadPointer(&x.v)) }
// Store atomically stores val into x.
func (x *Pointer[T]) Store(val *T) { StorePointer(&x.v, unsafe.Pointer(val)) }
// Swap atomically stores new into x and returns the previous value.
func (x *Pointer[T]) Swap(new *T) (old *T) { return (*T)(SwapPointer(&x.v, unsafe.Pointer(new))) }
// CompareAndSwap executes the compare-and-swap operation for x.
func (x *Pointer[T]) CompareAndSwap(old, new *T) (swapped bool) {
return CompareAndSwapPointer(&x.v, unsafe.Pointer(old), unsafe.Pointer(new))
}
// An Int32 is an atomic int32. The zero value is zero.
type Int32 struct {
_ noCopy
v int32
}
// Load atomically loads and returns the value stored in x.
func (x *Int32) Load() int32 { return LoadInt32(&x.v) }
// Store atomically stores val into x.
func (x *Int32) Store(val int32) { StoreInt32(&x.v, val) }
// Swap atomically stores new into x and returns the previous value.
func (x *Int32) Swap(new int32) (old int32) { return SwapInt32(&x.v, new) }
// CompareAndSwap executes the compare-and-swap operation for x.
func (x *Int32) CompareAndSwap(old, new int32) (swapped bool) {
return CompareAndSwapInt32(&x.v, old, new)
}
// Add atomically adds delta to x and returns the new value.
func (x *Int32) Add(delta int32) (new int32) { return AddInt32(&x.v, delta) }
// An Int64 is an atomic int64. The zero value is zero.
type Int64 struct {
_ noCopy
_ align64
v int64
}
// Load atomically loads and returns the value stored in x.
func (x *Int64) Load() int64 { return LoadInt64(&x.v) }
// Store atomically stores val into x.
func (x *Int64) Store(val int64) { StoreInt64(&x.v, val) }
// Swap atomically stores new into x and returns the previous value.
func (x *Int64) Swap(new int64) (old int64) { return SwapInt64(&x.v, new) }
// CompareAndSwap executes the compare-and-swap operation for x.
func (x *Int64) CompareAndSwap(old, new int64) (swapped bool) {
return CompareAndSwapInt64(&x.v, old, new)
}
// Add atomically adds delta to x and returns the new value.
func (x *Int64) Add(delta int64) (new int64) { return AddInt64(&x.v, delta) }
// A Uint32 is an atomic uint32. The zero value is zero.
type Uint32 struct {
_ noCopy
v uint32
}
// Load atomically loads and returns the value stored in x.
func (x *Uint32) Load() uint32 { return LoadUint32(&x.v) }
// Store atomically stores val into x.
func (x *Uint32) Store(val uint32) { StoreUint32(&x.v, val) }
// Swap atomically stores new into x and returns the previous value.
func (x *Uint32) Swap(new uint32) (old uint32) { return SwapUint32(&x.v, new) }
// CompareAndSwap executes the compare-and-swap operation for x.
func (x *Uint32) CompareAndSwap(old, new uint32) (swapped bool) {
return CompareAndSwapUint32(&x.v, old, new)
}
// Add atomically adds delta to x and returns the new value.
func (x *Uint32) Add(delta uint32) (new uint32) { return AddUint32(&x.v, delta) }
// A Uint64 is an atomic uint64. The zero value is zero.
type Uint64 struct {
_ noCopy
_ align64
v uint64
}
// Load atomically loads and returns the value stored in x.
func (x *Uint64) Load() uint64 { return LoadUint64(&x.v) }
// Store atomically stores val into x.
func (x *Uint64) Store(val uint64) { StoreUint64(&x.v, val) }
// Swap atomically stores new into x and returns the previous value.
func (x *Uint64) Swap(new uint64) (old uint64) { return SwapUint64(&x.v, new) }
// CompareAndSwap executes the compare-and-swap operation for x.
func (x *Uint64) CompareAndSwap(old, new uint64) (swapped bool) {
return CompareAndSwapUint64(&x.v, old, new)
}
// Add atomically adds delta to x and returns the new value.
func (x *Uint64) Add(delta uint64) (new uint64) { return AddUint64(&x.v, delta) }
// A Uintptr is an atomic uintptr. The zero value is zero.
type Uintptr struct {
_ noCopy
v uintptr
}
// Load atomically loads and returns the value stored in x.
func (x *Uintptr) Load() uintptr { return LoadUintptr(&x.v) }
// Store atomically stores val into x.
func (x *Uintptr) Store(val uintptr) { StoreUintptr(&x.v, val) }
// Swap atomically stores new into x and returns the previous value.
func (x *Uintptr) Swap(new uintptr) (old uintptr) { return SwapUintptr(&x.v, new) }
// CompareAndSwap executes the compare-and-swap operation for x.
func (x *Uintptr) CompareAndSwap(old, new uintptr) (swapped bool) {
return CompareAndSwapUintptr(&x.v, old, new)
}
// Add atomically adds delta to x and returns the new value.
func (x *Uintptr) Add(delta uintptr) (new uintptr) { return AddUintptr(&x.v, delta) }
// noCopy may be added to structs which must not be copied
// after the first use.
//
// See https://golang.org/issues/8005#issuecomment-190753527
// for details.
//
// Note that it must not be embedded, due to the Lock and Unlock methods.
type noCopy struct{}
// Lock is a no-op used by -copylocks checker from `go vet`.
func (*noCopy) Lock() {}
func (*noCopy) Unlock() {}
// align64 may be added to structs that must be 64-bit aligned.
// This struct is recognized by a special case in the compiler
// and will not work if copied to any other package.
type align64 struct{}
================================================
FILE: stdlib/generic/go1_22_cmp_cmp.go.txt
================================================
// Copyright 2023 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// Package cmp provides types and functions related to comparing
// ordered values.
package cmp
// Ordered is a constraint that permits any ordered type: any type
// that supports the operators < <= >= >.
// If future releases of Go add new ordered types,
// this constraint will be modified to include them.
//
// Note that floating-point types may contain NaN ("not-a-number") values.
// An operator such as == or < will always report false when
// comparing a NaN value with any other value, NaN or not.
// See the [Compare] function for a consistent way to compare NaN values.
type Ordered interface {
~int | ~int8 | ~int16 | ~int32 | ~int64 |
~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr |
~float32 | ~float64 |
~string
}
// Less reports whether x is less than y.
// For floating-point types, a NaN is considered less than any non-NaN,
// and -0.0 is not less than (is equal to) 0.0.
func Less[T Ordered](x, y T) bool {
return (isNaN(x) && !isNaN(y)) || x < y
}
// Compare returns
//
// -1 if x is less than y,
// 0 if x equals y,
// +1 if x is greater than y.
//
// For floating-point types, a NaN is considered less than any non-NaN,
// a NaN is considered equal to a NaN, and -0.0 is equal to 0.0.
func Compare[T Ordered](x, y T) int {
xNaN := isNaN(x)
yNaN := isNaN(y)
if xNaN && yNaN {
return 0
}
if xNaN || x < y {
return -1
}
if yNaN || x > y {
return +1
}
return 0
}
// isNaN reports whether x is a NaN without requiring the math package.
// This will always return false if T is not floating-point.
func isNaN[T Ordered](x T) bool {
return x != x
}
// Or returns the first of its arguments that is not equal to the zero value.
// If no argument is non-zero, it returns the zero value.
func Or[T comparable](vals ...T) T {
var zero T
for _, val := range vals {
if val != zero {
return val
}
}
return zero
}
================================================
FILE: stdlib/generic/go1_22_generic.go
================================================
//go:build go1.22
// +build go1.22
package generic
import _ "embed"
//go:embed go1_22_cmp_cmp.go.txt
var cmpSource string
//go:embed go1_22_maps_maps.go.txt
var mapsSource string
//go:embed go1_22_slices_slices.go.txt
var slicesSource string
/*
//go:embed go1_22_slices_sort.go.txt
var slicesSource1 string
//go:embed go1_22_slices_zsortanyfunc.go.txt
var slicesSource2 string
//go:embed go1_22_sync_oncefunc.go.txt
var syncSource string
//go:embed go1_22_sync_atomic_type.go.txt
var syncAtomicSource string
*/
// Sources contains the list of generic packages source strings.
var Sources = [...]string{
cmpSource,
mapsSource,
slicesSource,
// FIXME(marc): support the following.
// slicesSource1,
// slicesSource2,
// syncAtomicSource,
// syncSource,
}
================================================
FILE: stdlib/generic/go1_22_maps_maps.go.txt
================================================
// Copyright 2021 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// Package maps defines various functions useful with maps of any type.
package maps
// Equal reports whether two maps contain the same key/value pairs.
// Values are compared using ==.
func Equal[M1, M2 ~map[K]V, K, V comparable](m1 M1, m2 M2) bool {
if len(m1) != len(m2) {
return false
}
for k, v1 := range m1 {
if v2, ok := m2[k]; !ok || v1 != v2 {
return false
}
}
return true
}
// EqualFunc is like Equal, but compares values using eq.
// Keys are still compared with ==.
func EqualFunc[M1 ~map[K]V1, M2 ~map[K]V2, K comparable, V1, V2 any](m1 M1, m2 M2, eq func(V1, V2) bool) bool {
if len(m1) != len(m2) {
return false
}
for k, v1 := range m1 {
if v2, ok := m2[k]; !ok || !eq(v1, v2) {
return false
}
}
return true
}
// clone is implemented in the runtime package.
func clone(m any) any {
return m
}
// Clone returns a copy of m. This is a shallow clone:
// the new keys and values are set using ordinary assignment.
func Clone[M ~map[K]V, K comparable, V any](m M) M {
// Preserve nil in case it matters.
if m == nil {
return nil
}
return clone(m).(M)
}
// Copy copies all key/value pairs in src adding them to dst.
// When a key in src is already present in dst,
// the value in dst will be overwritten by the value associated
// with the key in src.
func Copy[M1 ~map[K]V, M2 ~map[K]V, K comparable, V any](dst M1, src M2) {
for k, v := range src {
dst[k] = v
}
}
// DeleteFunc deletes any key/value pairs from m for which del returns true.
func DeleteFunc[M ~map[K]V, K comparable, V any](m M, del func(K, V) bool) {
for k, v := range m {
if del(k, v) {
delete(m, k)
}
}
}
================================================
FILE: stdlib/generic/go1_22_slices_slices.go.txt
================================================
// Copyright 2021 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// Package slices defines various functions useful with slices of any type.
package slices
import (
"cmp"
// TODO(marc) fix this. "unsafe"
)
// Equal reports whether two slices are equal: the same length and all
// elements equal. If the lengths are different, Equal returns false.
// Otherwise, the elements are compared in increasing index order, and the
// comparison stops at the first unequal pair.
// Floating point NaNs are not considered equal.
func Equal[S ~[]E, E comparable](s1, s2 S) bool {
if len(s1) != len(s2) {
return false
}
for i := range s1 {
if s1[i] != s2[i] {
return false
}
}
return true
}
// EqualFunc reports whether two slices are equal using an equality
// function on each pair of elements. If the lengths are different,
// EqualFunc returns false. Otherwise, the elements are compared in
// increasing index order, and the comparison stops at the first index
// for which eq returns false.
func EqualFunc[S1 ~[]E1, S2 ~[]E2, E1, E2 any](s1 S1, s2 S2, eq func(E1, E2) bool) bool {
if len(s1) != len(s2) {
return false
}
for i, v1 := range s1 {
v2 := s2[i]
if !eq(v1, v2) {
return false
}
}
return true
}
// Compare compares the elements of s1 and s2, using [cmp.Compare] on each pair
// of elements. The elements are compared sequentially, starting at index 0,
// until one element is not equal to the other.
// The result of comparing the first non-matching elements is returned.
// If both slices are equal until one of them ends, the shorter slice is
// considered less than the longer one.
// The result is 0 if s1 == s2, -1 if s1 < s2, and +1 if s1 > s2.
func Compare[S ~[]E, E cmp.Ordered](s1, s2 S) int {
for i, v1 := range s1 {
if i >= len(s2) {
return +1
}
v2 := s2[i]
if c := cmp.Compare(v1, v2); c != 0 {
return c
}
}
if len(s1) < len(s2) {
return -1
}
return 0
}
// CompareFunc is like [Compare] but uses a custom comparison function on each
// pair of elements.
// The result is the first non-zero result of cmp; if cmp always
// returns 0 the result is 0 if len(s1) == len(s2), -1 if len(s1) < len(s2),
// and +1 if len(s1) > len(s2).
func CompareFunc[S1 ~[]E1, S2 ~[]E2, E1, E2 any](s1 S1, s2 S2, cmp func(E1, E2) int) int {
for i, v1 := range s1 {
if i >= len(s2) {
return +1
}
v2 := s2[i]
if c := cmp(v1, v2); c != 0 {
return c
}
}
if len(s1) < len(s2) {
return -1
}
return 0
}
// Index returns the index of the first occurrence of v in s,
// or -1 if not present.
func Index[S ~[]E, E comparable](s S, v E) int {
for i := range s {
if v == s[i] {
return i
}
}
return -1
}
// IndexFunc returns the first index i satisfying f(s[i]),
// or -1 if none do.
func IndexFunc[S ~[]E, E any](s S, f func(E) bool) int {
for i := range s {
if f(s[i]) {
return i
}
}
return -1
}
// Contains reports whether v is present in s.
func Contains[S ~[]E, E comparable](s S, v E) bool {
return Index(s, v) >= 0
}
// ContainsFunc reports whether at least one
// element e of s satisfies f(e).
func ContainsFunc[S ~[]E, E any](s S, f func(E) bool) bool {
return IndexFunc(s, f) >= 0
}
// Insert inserts the values v... into s at index i,
// returning the modified slice.
// The elements at s[i:] are shifted up to make room.
// In the returned slice r, r[i] == v[0],
// and r[i+len(v)] == value originally at r[i].
// Insert panics if i is out of range.
// This function is O(len(s) + len(v)).
func Insert[S ~[]E, E any](s S, i int, v ...E) S {
_ = s[i:] // bounds check
m := len(v)
if m == 0 {
return s
}
n := len(s)
if i == n {
return append(s, v...)
}
if n+m > cap(s) {
// Use append rather than make so that we bump the size of
// the slice up to the next storage class.
// This is what Grow does but we don't call Grow because
// that might copy the values twice.
s2 := append(s[:i], make(S, n+m-i)...)
copy(s2[i:], v)
copy(s2[i+m:], s[i:])
return s2
}
s = s[:n+m]
// before:
// s: aaaaaaaabbbbccccccccdddd
// ^ ^ ^ ^
// i i+m n n+m
// after:
// s: aaaaaaaavvvvbbbbcccccccc
// ^ ^ ^ ^
// i i+m n n+m
//
// a are the values that don't move in s.
// v are the values copied in from v.
// b and c are the values from s that are shifted up in index.
// d are the values that get overwritten, never to be seen again.
if !overlaps(v, s[i+m:]) {
// Easy case - v does not overlap either the c or d regions.
// (It might be in some of a or b, or elsewhere entirely.)
// The data we copy up doesn't write to v at all, so just do it.
copy(s[i+m:], s[i:])
// Now we have
// s: aaaaaaaabbbbbbbbcccccccc
// ^ ^ ^ ^
// i i+m n n+m
// Note the b values are duplicated.
copy(s[i:], v)
// Now we have
// s: aaaaaaaavvvvbbbbcccccccc
// ^ ^ ^ ^
// i i+m n n+m
// That's the result we want.
return s
}
// The hard case - v overlaps c or d. We can't just shift up
// the data because we'd move or clobber the values we're trying
// to insert.
// So instead, write v on top of d, then rotate.
copy(s[n:], v)
// Now we have
// s: aaaaaaaabbbbccccccccvvvv
// ^ ^ ^ ^
// i i+m n n+m
rotateRight(s[i:], m)
// Now we have
// s: aaaaaaaavvvvbbbbcccccccc
// ^ ^ ^ ^
// i i+m n n+m
// That's the result we want.
return s
}
// Delete removes the elements s[i:j] from s, returning the modified slice.
// Delete panics if j > len(s) or s[i:j] is not a valid slice of s.
// Delete is O(len(s)-i), so if many items must be deleted, it is better to
// make a single call deleting them all together than to delete one at a time.
// Delete zeroes the elements s[len(s)-(j-i):len(s)].
func Delete[S ~[]E, E any](s S, i, j int) S {
_ = s[i:j:len(s)] // bounds check
if i == j {
return s
}
oldlen := len(s)
s = append(s[:i], s[j:]...)
clear(s[len(s):oldlen]) // zero/nil out the obsolete elements, for GC
return s
}
// DeleteFunc removes any elements from s for which del returns true,
// returning the modified slice.
// DeleteFunc zeroes the elements between the new length and the original length.
func DeleteFunc[S ~[]E, E any](s S, del func(E) bool) S {
i := IndexFunc(s, del)
if i == -1 {
return s
}
// Don't start copying elements until we find one to delete.
for j := i + 1; j < len(s); j++ {
if v := s[j]; !del(v) {
s[i] = v
i++
}
}
clear(s[i:]) // zero/nil out the obsolete elements, for GC
return s[:i]
}
// Replace replaces the elements s[i:j] by the given v, and returns the
// modified slice.
// Replace panics if j > len(s) or s[i:j] is not a valid slice of s.
// When len(v) < (j-i), Replace zeroes the elements between the new length and the original length.
func Replace[S ~[]E, E any](s S, i, j int, v ...E) S {
_ = s[i:j] // bounds check
if i == j {
return Insert(s, i, v...)
}
if j == len(s) {
return append(s[:i], v...)
}
tot := len(s[:i]) + len(v) + len(s[j:])
if tot > cap(s) {
// Too big to fit, allocate and copy over.
s2 := append(s[:i], make(S, tot-i)...) // See Insert
copy(s2[i:], v)
copy(s2[i+len(v):], s[j:])
return s2
}
r := s[:tot]
if i+len(v) <= j {
// Easy, as v fits in the deleted portion.
copy(r[i:], v)
copy(r[i+len(v):], s[j:])
clear(s[tot:]) // zero/nil out the obsolete elements, for GC
return r
}
// We are expanding (v is bigger than j-i).
// The situation is something like this:
// (example has i=4,j=8,len(s)=16,len(v)=6)
// s: aaaaxxxxbbbbbbbbyy
// ^ ^ ^ ^
// i j len(s) tot
// a: prefix of s
// x: deleted range
// b: more of s
// y: area to expand into
if !overlaps(r[i+len(v):], v) {
// Easy, as v is not clobbered by the first copy.
copy(r[i+len(v):], s[j:])
copy(r[i:], v)
return r
}
// This is a situation where we don't have a single place to which
// we can copy v. Parts of it need to go to two different places.
// We want to copy the prefix of v into y and the suffix into x, then
// rotate |y| spots to the right.
//
// v[2:] v[:2]
// | |
// s: aaaavvvvbbbbbbbbvv
// ^ ^ ^ ^
// i j len(s) tot
//
// If either of those two destinations don't alias v, then we're good.
y := len(v) - (j - i) // length of y portion
if !overlaps(r[i:j], v) {
copy(r[i:j], v[y:])
copy(r[len(s):], v[:y])
rotateRight(r[i:], y)
return r
}
if !overlaps(r[len(s):], v) {
copy(r[len(s):], v[:y])
copy(r[i:j], v[y:])
rotateRight(r[i:], y)
return r
}
// Now we know that v overlaps both x and y.
// That means that the entirety of b is *inside* v.
// So we don't need to preserve b at all; instead we
// can copy v first, then copy the b part of v out of
// v to the right destination.
k := startIdx(v, s[j:])
copy(r[i:], v)
copy(r[i+len(v):], r[i+k:])
return r
}
// Clone returns a copy of the slice.
// The elements are copied using assignment, so this is a shallow clone.
func Clone[S ~[]E, E any](s S) S {
// The s[:0:0] preserves nil in case it matters.
return append(s[:0:0], s...)
}
// Compact replaces consecutive runs of equal elements with a single copy.
// This is like the uniq command found on Unix.
// Compact modifies the contents of the slice s and returns the modified slice,
// which may have a smaller length.
// Compact zeroes the elements between the new length and the original length.
func Compact[S ~[]E, E comparable](s S) S {
if len(s) < 2 {
return s
}
i := 1
for k := 1; k < len(s); k++ {
if s[k] != s[k-1] {
if i != k {
s[i] = s[k]
}
i++
}
}
clear(s[i:]) // zero/nil out the obsolete elements, for GC
return s[:i]
}
// CompactFunc is like [Compact] but uses an equality function to compare elements.
// For runs of elements that compare equal, CompactFunc keeps the first one.
// CompactFunc zeroes the elements between the new length and the original length.
func CompactFunc[S ~[]E, E any](s S, eq func(E, E) bool) S {
if len(s) < 2 {
return s
}
i := 1
for k := 1; k < len(s); k++ {
if !eq(s[k], s[k-1]) {
if i != k {
s[i] = s[k]
}
i++
}
}
clear(s[i:]) // zero/nil out the obsolete elements, for GC
return s[:i]
}
// Grow increases the slice's capacity, if necessary, to guarantee space for
// another n elements. After Grow(n), at least n elements can be appended
// to the slice without another allocation. If n is negative or too large to
// allocate the memory, Grow panics.
func Grow[S ~[]E, E any](s S, n int) S {
if n < 0 {
panic("cannot be negative")
}
if n -= cap(s) - len(s); n > 0 {
s = append(s[:cap(s)], make([]E, n)...)[:len(s)]
}
return s
}
// Clip removes unused capacity from the slice, returning s[:len(s):len(s)].
func Clip[S ~[]E, E any](s S) S {
return s[:len(s):len(s)]
}
// Rotation algorithm explanation:
//
// rotate left by 2
// start with
// 0123456789
// split up like this
// 01 234567 89
// swap first 2 and last 2
// 89 234567 01
// join first parts
// 89234567 01
// recursively rotate first left part by 2
// 23456789 01
// join at the end
// 2345678901
//
// rotate left by 8
// start with
// 0123456789
// split up like this
// 01 234567 89
// swap first 2 and last 2
// 89 234567 01
// join last parts
// 89 23456701
// recursively rotate second part left by 6
// 89 01234567
// join at the end
// 8901234567
// TODO: There are other rotate algorithms.
// This algorithm has the desirable property that it moves each element exactly twice.
// The triple-reverse algorithm is simpler and more cache friendly, but takes more writes.
// The follow-cycles algorithm can be 1-write but it is not very cache friendly.
// rotateLeft rotates b left by n spaces.
// s_final[i] = s_orig[i+r], wrapping around.
func rotateLeft[E any](s []E, r int) {
for r != 0 && r != len(s) {
if r*2 <= len(s) {
swap(s[:r], s[len(s)-r:])
s = s[:len(s)-r]
} else {
swap(s[:len(s)-r], s[r:])
s, r = s[len(s)-r:], r*2-len(s)
}
}
}
func rotateRight[E any](s []E, r int) {
rotateLeft(s, len(s)-r)
}
// swap swaps the contents of x and y. x and y must be equal length and disjoint.
func swap[E any](x, y []E) {
for i := 0; i < len(x); i++ {
x[i], y[i] = y[i], x[i]
}
}
// overlaps reports whether the memory ranges a[0:len(a)] and b[0:len(b)] overlap.
func overlaps[E any](a, b []E) bool {
return false
/* TODO(marc): restore the following
if len(a) == 0 || len(b) == 0 {
return false
}
elemSize := unsafe.Sizeof(a[0])
if elemSize == 0 {
return false
}
// TODO: use a runtime/unsafe facility once one becomes available. See issue 12445.
// Also see crypto/internal/alias/alias.go:AnyOverlap
return uintptr(unsafe.Pointer(&a[0])) <= uintptr(unsafe.Pointer(&b[len(b)-1]))+(elemSize-1) &&
uintptr(unsafe.Pointer(&b[0])) <= uintptr(unsafe.Pointer(&a[len(a)-1]))+(elemSize-1)
*/
}
// startIdx returns the index in haystack where the needle starts.
// prerequisite: the needle must be aliased entirely inside the haystack.
func startIdx[E any](haystack, needle []E) int {
p := &needle[0]
for i := range haystack {
if p == &haystack[i] {
return i
}
}
// TODO: what if the overlap is by a non-integral number of Es?
panic("needle not found")
}
// Reverse reverses the elements of the slice in place.
func Reverse[S ~[]E, E any](s S) {
for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 {
s[i], s[j] = s[j], s[i]
}
}
// Concat returns a new slice concatenating the passed in slices.
func Concat[S ~[]E, E any](slices ...S) S {
size := 0
for _, s := range slices {
size += len(s)
if size < 0 {
panic("len out of range")
}
}
newslice := Grow[S](nil, size)
for _, s := range slices {
newslice = append(newslice, s...)
}
return newslice
}
================================================
FILE: stdlib/generic/go1_22_slices_sort.go.txt
================================================
// Copyright 2023 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
//go:generate go run $GOROOT/src/sort/gen_sort_variants.go -generic
package slices
import (
"cmp"
"math/bits"
)
// Sort sorts a slice of any ordered type in ascending order.
// When sorting floating-point numbers, NaNs are ordered before other values.
func Sort[S ~[]E, E cmp.Ordered](x S) {
n := len(x)
pdqsortOrdered(x, 0, n, bits.Len(uint(n)))
}
// SortFunc sorts the slice x in ascending order as determined by the cmp
// function. This sort is not guaranteed to be stable.
// cmp(a, b) should return a negative number when a < b, a positive number when
// a > b and zero when a == b.
//
// SortFunc requires that cmp is a strict weak ordering.
// See https://en.wikipedia.org/wiki/Weak_ordering#Strict_weak_orderings.
func SortFunc[S ~[]E, E any](x S, cmp func(a, b E) int) {
n := len(x)
pdqsortCmpFunc(x, 0, n, bits.Len(uint(n)), cmp)
}
// SortStableFunc sorts the slice x while keeping the original order of equal
// elements, using cmp to compare elements in the same way as [SortFunc].
func SortStableFunc[S ~[]E, E any](x S, cmp func(a, b E) int) {
stableCmpFunc(x, len(x), cmp)
}
// IsSorted reports whether x is sorted in ascending order.
func IsSorted[S ~[]E, E cmp.Ordered](x S) bool {
for i := len(x) - 1; i > 0; i-- {
if cmp.Less(x[i], x[i-1]) {
return false
}
}
return true
}
// IsSortedFunc reports whether x is sorted in ascending order, with cmp as the
// comparison function as defined by [SortFunc].
func IsSortedFunc[S ~[]E, E any](x S, cmp func(a, b E) int) bool {
for i := len(x) - 1; i > 0; i-- {
if cmp(x[i], x[i-1]) < 0 {
return false
}
}
return true
}
// Min returns the minimal value in x. It panics if x is empty.
// For floating-point numbers, Min propagates NaNs (any NaN value in x
// forces the output to be NaN).
func Min[S ~[]E, E cmp.Ordered](x S) E {
if len(x) < 1 {
panic("slices.Min: empty list")
}
m := x[0]
for i := 1; i < len(x); i++ {
m = min(m, x[i])
}
return m
}
// MinFunc returns the minimal value in x, using cmp to compare elements.
// It panics if x is empty. If there is more than one minimal element
// according to the cmp function, MinFunc returns the first one.
func MinFunc[S ~[]E, E any](x S, cmp func(a, b E) int) E {
if len(x) < 1 {
panic("slices.MinFunc: empty list")
}
m := x[0]
for i := 1; i < len(x); i++ {
if cmp(x[i], m) < 0 {
m = x[i]
}
}
return m
}
// Max returns the maximal value in x. It panics if x is empty.
// For floating-point E, Max propagates NaNs (any NaN value in x
// forces the output to be NaN).
func Max[S ~[]E, E cmp.Ordered](x S) E {
if len(x) < 1 {
panic("slices.Max: empty list")
}
m := x[0]
for i := 1; i < len(x); i++ {
m = max(m, x[i])
}
return m
}
// MaxFunc returns the maximal value in x, using cmp to compare elements.
// It panics if x is empty. If there is more than one maximal element
// according to the cmp function, MaxFunc returns the first one.
func MaxFunc[S ~[]E, E any](x S, cmp func(a, b E) int) E {
if len(x) < 1 {
panic("slices.MaxFunc: empty list")
}
m := x[0]
for i := 1; i < len(x); i++ {
if cmp(x[i], m) > 0 {
m = x[i]
}
}
return m
}
// BinarySearch searches for target in a sorted slice and returns the position
// where target is found, or the position where target would appear in the
// sort order; it also returns a bool saying whether the target is really found
// in the slice. The slice must be sorted in increasing order.
func BinarySearch[S ~[]E, E cmp.Ordered](x S, target E) (int, bool) {
// Inlining is faster than calling BinarySearchFunc with a lambda.
n := len(x)
// Define x[-1] < target and x[n] >= target.
// Invariant: x[i-1] < target, x[j] >= target.
i, j := 0, n
for i < j {
h := int(uint(i+j) >> 1) // avoid overflow when computing h
// i ≤ h < j
if cmp.Less(x[h], target) {
i = h + 1 // preserves x[i-1] < target
} else {
j = h // preserves x[j] >= target
}
}
// i == j, x[i-1] < target, and x[j] (= x[i]) >= target => answer is i.
return i, i < n && (x[i] == target || (isNaN(x[i]) && isNaN(target)))
}
// BinarySearchFunc works like [BinarySearch], but uses a custom comparison
// function. The slice must be sorted in increasing order, where "increasing"
// is defined by cmp. cmp should return 0 if the slice element matches
// the target, a negative number if the slice element precedes the target,
// or a positive number if the slice element follows the target.
// cmp must implement the same ordering as the slice, such that if
// cmp(a, t) < 0 and cmp(b, t) >= 0, then a must precede b in the slice.
func BinarySearchFunc[S ~[]E, E, T any](x S, target T, cmp func(E, T) int) (int, bool) {
n := len(x)
// Define cmp(x[-1], target) < 0 and cmp(x[n], target) >= 0 .
// Invariant: cmp(x[i - 1], target) < 0, cmp(x[j], target) >= 0.
i, j := 0, n
for i < j {
h := int(uint(i+j) >> 1) // avoid overflow when computing h
// i ≤ h < j
if cmp(x[h], target) < 0 {
i = h + 1 // preserves cmp(x[i - 1], target) < 0
} else {
j = h // preserves cmp(x[j], target) >= 0
}
}
// i == j, cmp(x[i-1], target) < 0, and cmp(x[j], target) (= cmp(x[i], target)) >= 0 => answer is i.
return i, i < n && cmp(x[i], target) == 0
}
type sortedHint int // hint for pdqsort when choosing the pivot
const (
unknownHint sortedHint = iota
increasingHint
decreasingHint
)
// xorshift paper: https://www.jstatsoft.org/article/view/v008i14/xorshift.pdf
type xorshift uint64
func (r *xorshift) Next() uint64 {
*r ^= *r << 13
*r ^= *r >> 17
*r ^= *r << 5
return uint64(*r)
}
func nextPowerOfTwo(length int) uint {
return 1 << bits.Len(uint(length))
}
// isNaN reports whether x is a NaN without requiring the math package.
// This will always return false if T is not floating-point.
func isNaN[T cmp.Ordered](x T) bool {
return x != x
}
================================================
FILE: stdlib/generic/go1_22_slices_zsortanyfunc.go.txt
================================================
// Code generated by gen_sort_variants.go; DO NOT EDIT.
// Copyright 2022 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package slices
// insertionSortCmpFunc sorts data[a:b] using insertion sort.
func insertionSortCmpFunc[E any](data []E, a, b int, cmp func(a, b E) int) {
for i := a + 1; i < b; i++ {
for j := i; j > a && (cmp(data[j], data[j-1]) < 0); j-- {
data[j], data[j-1] = data[j-1], data[j]
}
}
}
// siftDownCmpFunc implements the heap property on data[lo:hi].
// first is an offset into the array where the root of the heap lies.
func siftDownCmpFunc[E any](data []E, lo, hi, first int, cmp func(a, b E) int) {
root := lo
for {
child := 2*root + 1
if child >= hi {
break
}
if child+1 < hi && (cmp(data[first+child], data[first+child+1]) < 0) {
child++
}
if !(cmp(data[first+root], data[first+child]) < 0) {
return
}
data[first+root], data[first+child] = data[first+child], data[first+root]
root = child
}
}
func heapSortCmpFunc[E any](data []E, a, b int, cmp func(a, b E) int) {
first := a
lo := 0
hi := b - a
// Build heap with greatest element at top.
for i := (hi - 1) / 2; i >= 0; i-- {
siftDownCmpFunc(data, i, hi, first, cmp)
}
// Pop elements, largest first, into end of data.
for i := hi - 1; i >= 0; i-- {
data[first], data[first+i] = data[first+i], data[first]
siftDownCmpFunc(data, lo, i, first, cmp)
}
}
// pdqsortCmpFunc sorts data[a:b].
// The algorithm based on pattern-defeating quicksort(pdqsort), but without the optimizations from BlockQuicksort.
// pdqsort paper: https://arxiv.org/pdf/2106.05123.pdf
// C++ implementation: https://github.com/orlp/pdqsort
// Rust implementation: https://docs.rs/pdqsort/latest/pdqsort/
// limit is the number of allowed bad (very unbalanced) pivots before falling back to heapsort.
func pdqsortCmpFunc[E any](data []E, a, b, limit int, cmp func(a, b E) int) {
const maxInsertion = 12
var (
wasBalanced = true // whether the last partitioning was reasonably balanced
wasPartitioned = true // whether the slice was already partitioned
)
for {
length := b - a
if length <= maxInsertion {
insertionSortCmpFunc(data, a, b, cmp)
return
}
// Fall back to heapsort if too many bad choices were made.
if limit == 0 {
heapSortCmpFunc(data, a, b, cmp)
return
}
// If the last partitioning was imbalanced, we need to breaking patterns.
if !wasBalanced {
breakPatternsCmpFunc(data, a, b, cmp)
limit--
}
pivot, hint := choosePivotCmpFunc(data, a, b, cmp)
if hint == decreasingHint {
reverseRangeCmpFunc(data, a, b, cmp)
// The chosen pivot was pivot-a elements after the start of the array.
// After reversing it is pivot-a elements before the end of the array.
// The idea came from Rust's implementation.
pivot = (b - 1) - (pivot - a)
hint = increasingHint
}
// The slice is likely already sorted.
if wasBalanced && wasPartitioned && hint == increasingHint {
if partialInsertionSortCmpFunc(data, a, b, cmp) {
return
}
}
// Probably the slice contains many duplicate elements, partition the slice into
// elements equal to and elements greater than the pivot.
if a > 0 && !(cmp(data[a-1], data[pivot]) < 0) {
mid := partitionEqualCmpFunc(data, a, b, pivot, cmp)
a = mid
continue
}
mid, alreadyPartitioned := partitionCmpFunc(data, a, b, pivot, cmp)
wasPartitioned = alreadyPartitioned
leftLen, rightLen := mid-a, b-mid
balanceThreshold := length / 8
if leftLen < rightLen {
wasBalanced = leftLen >= balanceThreshold
pdqsortCmpFunc(data, a, mid, limit, cmp)
a = mid + 1
} else {
wasBalanced = rightLen >= balanceThreshold
pdqsortCmpFunc(data, mid+1, b, limit, cmp)
b = mid
}
}
}
// partitionCmpFunc does one quicksort partition.
// Let p = data[pivot]
// Moves elements in data[a:b] around, so that data[i]=p for inewpivot.
// On return, data[newpivot] = p
func partitionCmpFunc[E any](data []E, a, b, pivot int, cmp func(a, b E) int) (newpivot int, alreadyPartitioned bool) {
data[a], data[pivot] = data[pivot], data[a]
i, j := a+1, b-1 // i and j are inclusive of the elements remaining to be partitioned
for i <= j && (cmp(data[i], data[a]) < 0) {
i++
}
for i <= j && !(cmp(data[j], data[a]) < 0) {
j--
}
if i > j {
data[j], data[a] = data[a], data[j]
return j, true
}
data[i], data[j] = data[j], data[i]
i++
j--
for {
for i <= j && (cmp(data[i], data[a]) < 0) {
i++
}
for i <= j && !(cmp(data[j], data[a]) < 0) {
j--
}
if i > j {
break
}
data[i], data[j] = data[j], data[i]
i++
j--
}
data[j], data[a] = data[a], data[j]
return j, false
}
// partitionEqualCmpFunc partitions data[a:b] into elements equal to data[pivot] followed by elements greater than data[pivot].
// It assumed that data[a:b] does not contain elements smaller than the data[pivot].
func partitionEqualCmpFunc[E any](data []E, a, b, pivot int, cmp func(a, b E) int) (newpivot int) {
data[a], data[pivot] = data[pivot], data[a]
i, j := a+1, b-1 // i and j are inclusive of the elements remaining to be partitioned
for {
for i <= j && !(cmp(data[a], data[i]) < 0) {
i++
}
for i <= j && (cmp(data[a], data[j]) < 0) {
j--
}
if i > j {
break
}
data[i], data[j] = data[j], data[i]
i++
j--
}
return i
}
// partialInsertionSortCmpFunc partially sorts a slice, returns true if the slice is sorted at the end.
func partialInsertionSortCmpFunc[E any](data []E, a, b int, cmp func(a, b E) int) bool {
const (
maxSteps = 5 // maximum number of adjacent out-of-order pairs that will get shifted
shortestShifting = 50 // don't shift any elements on short arrays
)
i := a + 1
for j := 0; j < maxSteps; j++ {
for i < b && !(cmp(data[i], data[i-1]) < 0) {
i++
}
if i == b {
return true
}
if b-a < shortestShifting {
return false
}
data[i], data[i-1] = data[i-1], data[i]
// Shift the smaller one to the left.
if i-a >= 2 {
for j := i - 1; j >= 1; j-- {
if !(cmp(data[j], data[j-1]) < 0) {
break
}
data[j], data[j-1] = data[j-1], data[j]
}
}
// Shift the greater one to the right.
if b-i >= 2 {
for j := i + 1; j < b; j++ {
if !(cmp(data[j], data[j-1]) < 0) {
break
}
data[j], data[j-1] = data[j-1], data[j]
}
}
}
return false
}
// breakPatternsCmpFunc scatters some elements around in an attempt to break some patterns
// that might cause imbalanced partitions in quicksort.
func breakPatternsCmpFunc[E any](data []E, a, b int, cmp func(a, b E) int) {
length := b - a
if length >= 8 {
random := xorshift(length)
modulus := nextPowerOfTwo(length)
for idx := a + (length/4)*2 - 1; idx <= a+(length/4)*2+1; idx++ {
other := int(uint(random.Next()) & (modulus - 1))
if other >= length {
other -= length
}
data[idx], data[a+other] = data[a+other], data[idx]
}
}
}
// choosePivotCmpFunc chooses a pivot in data[a:b].
//
// [0,8): chooses a static pivot.
// [8,shortestNinther): uses the simple median-of-three method.
// [shortestNinther,∞): uses the Tukey ninther method.
func choosePivotCmpFunc[E any](data []E, a, b int, cmp func(a, b E) int) (pivot int, hint sortedHint) {
const (
shortestNinther = 50
maxSwaps = 4 * 3
)
l := b - a
var (
swaps int
i = a + l/4*1
j = a + l/4*2
k = a + l/4*3
)
if l >= 8 {
if l >= shortestNinther {
// Tukey ninther method, the idea came from Rust's implementation.
i = medianAdjacentCmpFunc(data, i, &swaps, cmp)
j = medianAdjacentCmpFunc(data, j, &swaps, cmp)
k = medianAdjacentCmpFunc(data, k, &swaps, cmp)
}
// Find the median among i, j, k and stores it into j.
j = medianCmpFunc(data, i, j, k, &swaps, cmp)
}
switch swaps {
case 0:
return j, increasingHint
case maxSwaps:
return j, decreasingHint
default:
return j, unknownHint
}
}
// order2CmpFunc returns x,y where data[x] <= data[y], where x,y=a,b or x,y=b,a.
func order2CmpFunc[E any](data []E, a, b int, swaps *int, cmp func(a, b E) int) (int, int) {
if cmp(data[b], data[a]) < 0 {
*swaps++
return b, a
}
return a, b
}
// medianCmpFunc returns x where data[x] is the median of data[a],data[b],data[c], where x is a, b, or c.
func medianCmpFunc[E any](data []E, a, b, c int, swaps *int, cmp func(a, b E) int) int {
a, b = order2CmpFunc(data, a, b, swaps, cmp)
b, c = order2CmpFunc(data, b, c, swaps, cmp)
a, b = order2CmpFunc(data, a, b, swaps, cmp)
return b
}
// medianAdjacentCmpFunc finds the median of data[a - 1], data[a], data[a + 1] and stores the index into a.
func medianAdjacentCmpFunc[E any](data []E, a int, swaps *int, cmp func(a, b E) int) int {
return medianCmpFunc(data, a-1, a, a+1, swaps, cmp)
}
func reverseRangeCmpFunc[E any](data []E, a, b int, cmp func(a, b E) int) {
i := a
j := b - 1
for i < j {
data[i], data[j] = data[j], data[i]
i++
j--
}
}
func swapRangeCmpFunc[E any](data []E, a, b, n int, cmp func(a, b E) int) {
for i := 0; i < n; i++ {
data[a+i], data[b+i] = data[b+i], data[a+i]
}
}
func stableCmpFunc[E any](data []E, n int, cmp func(a, b E) int) {
blockSize := 20 // must be > 0
a, b := 0, blockSize
for b <= n {
insertionSortCmpFunc(data, a, b, cmp)
a = b
b += blockSize
}
insertionSortCmpFunc(data, a, n, cmp)
for blockSize < n {
a, b = 0, 2*blockSize
for b <= n {
symMergeCmpFunc(data, a, a+blockSize, b, cmp)
a = b
b += 2 * blockSize
}
if m := a + blockSize; m < n {
symMergeCmpFunc(data, a, m, n, cmp)
}
blockSize *= 2
}
}
// symMergeCmpFunc merges the two sorted subsequences data[a:m] and data[m:b] using
// the SymMerge algorithm from Pok-Son Kim and Arne Kutzner, "Stable Minimum
// Storage Merging by Symmetric Comparisons", in Susanne Albers and Tomasz
// Radzik, editors, Algorithms - ESA 2004, volume 3221 of Lecture Notes in
// Computer Science, pages 714-723. Springer, 2004.
//
// Let M = m-a and N = b-n. Wolog M < N.
// The recursion depth is bound by ceil(log(N+M)).
// The algorithm needs O(M*log(N/M + 1)) calls to data.Less.
// The algorithm needs O((M+N)*log(M)) calls to data.Swap.
//
// The paper gives O((M+N)*log(M)) as the number of assignments assuming a
// rotation algorithm which uses O(M+N+gcd(M+N)) assignments. The argumentation
// in the paper carries through for Swap operations, especially as the block
// swapping rotate uses only O(M+N) Swaps.
//
// symMerge assumes non-degenerate arguments: a < m && m < b.
// Having the caller check this condition eliminates many leaf recursion calls,
// which improves performance.
func symMergeCmpFunc[E any](data []E, a, m, b int, cmp func(a, b E) int) {
// Avoid unnecessary recursions of symMerge
// by direct insertion of data[a] into data[m:b]
// if data[a:m] only contains one element.
if m-a == 1 {
// Use binary search to find the lowest index i
// such that data[i] >= data[a] for m <= i < b.
// Exit the search loop with i == b in case no such index exists.
i := m
j := b
for i < j {
h := int(uint(i+j) >> 1)
if cmp(data[h], data[a]) < 0 {
i = h + 1
} else {
j = h
}
}
// Swap values until data[a] reaches the position before i.
for k := a; k < i-1; k++ {
data[k], data[k+1] = data[k+1], data[k]
}
return
}
// Avoid unnecessary recursions of symMerge
// by direct insertion of data[m] into data[a:m]
// if data[m:b] only contains one element.
if b-m == 1 {
// Use binary search to find the lowest index i
// such that data[i] > data[m] for a <= i < m.
// Exit the search loop with i == m in case no such index exists.
i := a
j := m
for i < j {
h := int(uint(i+j) >> 1)
if !(cmp(data[m], data[h]) < 0) {
i = h + 1
} else {
j = h
}
}
// Swap values until data[m] reaches the position i.
for k := m; k > i; k-- {
data[k], data[k-1] = data[k-1], data[k]
}
return
}
mid := int(uint(a+b) >> 1)
n := mid + m
var start, r int
if m > mid {
start = n - b
r = mid
} else {
start = a
r = m
}
p := n - 1
for start < r {
c := int(uint(start+r) >> 1)
if !(cmp(data[p-c], data[c]) < 0) {
start = c + 1
} else {
r = c
}
}
end := n - start
if start < m && m < end {
rotateCmpFunc(data, start, m, end, cmp)
}
if a < start && start < mid {
symMergeCmpFunc(data, a, start, mid, cmp)
}
if mid < end && end < b {
symMergeCmpFunc(data, mid, end, b, cmp)
}
}
// rotateCmpFunc rotates two consecutive blocks u = data[a:m] and v = data[m:b] in data:
// Data of the form 'x u v y' is changed to 'x v u y'.
// rotate performs at most b-a many calls to data.Swap,
// and it assumes non-degenerate arguments: a < m && m < b.
func rotateCmpFunc[E any](data []E, a, m, b int, cmp func(a, b E) int) {
i := m - a
j := b - m
for i != j {
if i > j {
swapRangeCmpFunc(data, m-i, m, j, cmp)
i -= j
} else {
swapRangeCmpFunc(data, m-i, m+j-i, i, cmp)
j -= i
}
}
// i == j
swapRangeCmpFunc(data, m-i, m, i, cmp)
}
================================================
FILE: stdlib/generic/go1_22_sync_atomic_type.go.txt
================================================
// Copyright 2022 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package atomic
import "unsafe"
// A Bool is an atomic boolean value.
// The zero value is false.
type Bool struct {
_ noCopy
v uint32
}
// Load atomically loads and returns the value stored in x.
func (x *Bool) Load() bool { return LoadUint32(&x.v) != 0 }
// Store atomically stores val into x.
func (x *Bool) Store(val bool) { StoreUint32(&x.v, b32(val)) }
// Swap atomically stores new into x and returns the previous value.
func (x *Bool) Swap(new bool) (old bool) { return SwapUint32(&x.v, b32(new)) != 0 }
// CompareAndSwap executes the compare-and-swap operation for the boolean value x.
func (x *Bool) CompareAndSwap(old, new bool) (swapped bool) {
return CompareAndSwapUint32(&x.v, b32(old), b32(new))
}
// b32 returns a uint32 0 or 1 representing b.
func b32(b bool) uint32 {
if b {
return 1
}
return 0
}
// For testing *Pointer[T]'s methods can be inlined.
// Keep in sync with cmd/compile/internal/test/inl_test.go:TestIntendedInlining.
var _ = &Pointer[int]{}
// A Pointer is an atomic pointer of type *T. The zero value is a nil *T.
type Pointer[T any] struct {
// Mention *T in a field to disallow conversion between Pointer types.
// See go.dev/issue/56603 for more details.
// Use *T, not T, to avoid spurious recursive type definition errors.
_ [0]*T
_ noCopy
v unsafe.Pointer
}
// Load atomically loads and returns the value stored in x.
func (x *Pointer[T]) Load() *T { return (*T)(LoadPointer(&x.v)) }
// Store atomically stores val into x.
func (x *Pointer[T]) Store(val *T) { StorePointer(&x.v, unsafe.Pointer(val)) }
// Swap atomically stores new into x and returns the previous value.
func (x *Pointer[T]) Swap(new *T) (old *T) { return (*T)(SwapPointer(&x.v, unsafe.Pointer(new))) }
// CompareAndSwap executes the compare-and-swap operation for x.
func (x *Pointer[T]) CompareAndSwap(old, new *T) (swapped bool) {
return CompareAndSwapPointer(&x.v, unsafe.Pointer(old), unsafe.Pointer(new))
}
// An Int32 is an atomic int32. The zero value is zero.
type Int32 struct {
_ noCopy
v int32
}
// Load atomically loads and returns the value stored in x.
func (x *Int32) Load() int32 { return LoadInt32(&x.v) }
// Store atomically stores val into x.
func (x *Int32) Store(val int32) { StoreInt32(&x.v, val) }
// Swap atomically stores new into x and returns the previous value.
func (x *Int32) Swap(new int32) (old int32) { return SwapInt32(&x.v, new) }
// CompareAndSwap executes the compare-and-swap operation for x.
func (x *Int32) CompareAndSwap(old, new int32) (swapped bool) {
return CompareAndSwapInt32(&x.v, old, new)
}
// Add atomically adds delta to x and returns the new value.
func (x *Int32) Add(delta int32) (new int32) { return AddInt32(&x.v, delta) }
// An Int64 is an atomic int64. The zero value is zero.
type Int64 struct {
_ noCopy
_ align64
v int64
}
// Load atomically loads and returns the value stored in x.
func (x *Int64) Load() int64 { return LoadInt64(&x.v) }
// Store atomically stores val into x.
func (x *Int64) Store(val int64) { StoreInt64(&x.v, val) }
// Swap atomically stores new into x and returns the previous value.
func (x *Int64) Swap(new int64) (old int64) { return SwapInt64(&x.v, new) }
// CompareAndSwap executes the compare-and-swap operation for x.
func (x *Int64) CompareAndSwap(old, new int64) (swapped bool) {
return CompareAndSwapInt64(&x.v, old, new)
}
// Add atomically adds delta to x and returns the new value.
func (x *Int64) Add(delta int64) (new int64) { return AddInt64(&x.v, delta) }
// A Uint32 is an atomic uint32. The zero value is zero.
type Uint32 struct {
_ noCopy
v uint32
}
// Load atomically loads and returns the value stored in x.
func (x *Uint32) Load() uint32 { return LoadUint32(&x.v) }
// Store atomically stores val into x.
func (x *Uint32) Store(val uint32) { StoreUint32(&x.v, val) }
// Swap atomically stores new into x and returns the previous value.
func (x *Uint32) Swap(new uint32) (old uint32) { return SwapUint32(&x.v, new) }
// CompareAndSwap executes the compare-and-swap operation for x.
func (x *Uint32) CompareAndSwap(old, new uint32) (swapped bool) {
return CompareAndSwapUint32(&x.v, old, new)
}
// Add atomically adds delta to x and returns the new value.
func (x *Uint32) Add(delta uint32) (new uint32) { return AddUint32(&x.v, delta) }
// A Uint64 is an atomic uint64. The zero value is zero.
type Uint64 struct {
_ noCopy
_ align64
v uint64
}
// Load atomically loads and returns the value stored in x.
func (x *Uint64) Load() uint64 { return LoadUint64(&x.v) }
// Store atomically stores val into x.
func (x *Uint64) Store(val uint64) { StoreUint64(&x.v, val) }
// Swap atomically stores new into x and returns the previous value.
func (x *Uint64) Swap(new uint64) (old uint64) { return SwapUint64(&x.v, new) }
// CompareAndSwap executes the compare-and-swap operation for x.
func (x *Uint64) CompareAndSwap(old, new uint64) (swapped bool) {
return CompareAndSwapUint64(&x.v, old, new)
}
// Add atomically adds delta to x and returns the new value.
func (x *Uint64) Add(delta uint64) (new uint64) { return AddUint64(&x.v, delta) }
// A Uintptr is an atomic uintptr. The zero value is zero.
type Uintptr struct {
_ noCopy
v uintptr
}
// Load atomically loads and returns the value stored in x.
func (x *Uintptr) Load() uintptr { return LoadUintptr(&x.v) }
// Store atomically stores val into x.
func (x *Uintptr) Store(val uintptr) { StoreUintptr(&x.v, val) }
// Swap atomically stores new into x and returns the previous value.
func (x *Uintptr) Swap(new uintptr) (old uintptr) { return SwapUintptr(&x.v, new) }
// CompareAndSwap executes the compare-and-swap operation for x.
func (x *Uintptr) CompareAndSwap(old, new uintptr) (swapped bool) {
return CompareAndSwapUintptr(&x.v, old, new)
}
// Add atomically adds delta to x and returns the new value.
func (x *Uintptr) Add(delta uintptr) (new uintptr) { return AddUintptr(&x.v, delta) }
// noCopy may be added to structs which must not be copied
// after the first use.
//
// See https://golang.org/issues/8005#issuecomment-190753527
// for details.
//
// Note that it must not be embedded, due to the Lock and Unlock methods.
type noCopy struct{}
// Lock is a no-op used by -copylocks checker from `go vet`.
func (*noCopy) Lock() {}
func (*noCopy) Unlock() {}
// align64 may be added to structs that must be 64-bit aligned.
// This struct is recognized by a special case in the compiler
// and will not work if copied to any other package.
type align64 struct{}
================================================
FILE: stdlib/generic/go1_22_sync_oncefunc.go.txt
================================================
// Copyright 2022 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package sync
// OnceFunc returns a function that invokes f only once. The returned function
// may be called concurrently.
//
// If f panics, the returned function will panic with the same value on every call.
func OnceFunc(f func()) func() {
var (
once Once
valid bool
p any
)
// Construct the inner closure just once to reduce costs on the fast path.
g := func() {
defer func() {
p = recover()
if !valid {
// Re-panic immediately so on the first call the user gets a
// complete stack trace into f.
panic(p)
}
}()
f()
f = nil // Do not keep f alive after invoking it.
valid = true // Set only if f does not panic.
}
return func() {
once.Do(g)
if !valid {
panic(p)
}
}
}
// OnceValue returns a function that invokes f only once and returns the value
// returned by f. The returned function may be called concurrently.
//
// If f panics, the returned function will panic with the same value on every call.
func OnceValue[T any](f func() T) func() T {
var (
once Once
valid bool
p any
result T
)
g := func() {
defer func() {
p = recover()
if !valid {
panic(p)
}
}()
result = f()
f = nil
valid = true
}
return func() T {
once.Do(g)
if !valid {
panic(p)
}
return result
}
}
// OnceValues returns a function that invokes f only once and returns the values
// returned by f. The returned function may be called concurrently.
//
// If f panics, the returned function will panic with the same value on every call.
func OnceValues[T1, T2 any](f func() (T1, T2)) func() (T1, T2) {
var (
once Once
valid bool
p any
r1 T1
r2 T2
)
g := func() {
defer func() {
p = recover()
if !valid {
panic(p)
}
}()
r1, r2 = f()
f = nil
valid = true
}
return func() (T1, T2) {
once.Do(g)
if !valid {
panic(p)
}
return r1, r2
}
}
================================================
FILE: stdlib/go1_21_archive_tar.go
================================================
// Code generated by 'yaegi extract archive/tar'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"archive/tar"
"go/constant"
"go/token"
"reflect"
)
func init() {
Symbols["archive/tar/tar"] = map[string]reflect.Value{
// function, constant and variable definitions
"ErrFieldTooLong": reflect.ValueOf(&tar.ErrFieldTooLong).Elem(),
"ErrHeader": reflect.ValueOf(&tar.ErrHeader).Elem(),
"ErrInsecurePath": reflect.ValueOf(&tar.ErrInsecurePath).Elem(),
"ErrWriteAfterClose": reflect.ValueOf(&tar.ErrWriteAfterClose).Elem(),
"ErrWriteTooLong": reflect.ValueOf(&tar.ErrWriteTooLong).Elem(),
"FileInfoHeader": reflect.ValueOf(tar.FileInfoHeader),
"FormatGNU": reflect.ValueOf(tar.FormatGNU),
"FormatPAX": reflect.ValueOf(tar.FormatPAX),
"FormatUSTAR": reflect.ValueOf(tar.FormatUSTAR),
"FormatUnknown": reflect.ValueOf(tar.FormatUnknown),
"NewReader": reflect.ValueOf(tar.NewReader),
"NewWriter": reflect.ValueOf(tar.NewWriter),
"TypeBlock": reflect.ValueOf(constant.MakeFromLiteral("52", token.INT, 0)),
"TypeChar": reflect.ValueOf(constant.MakeFromLiteral("51", token.INT, 0)),
"TypeCont": reflect.ValueOf(constant.MakeFromLiteral("55", token.INT, 0)),
"TypeDir": reflect.ValueOf(constant.MakeFromLiteral("53", token.INT, 0)),
"TypeFifo": reflect.ValueOf(constant.MakeFromLiteral("54", token.INT, 0)),
"TypeGNULongLink": reflect.ValueOf(constant.MakeFromLiteral("75", token.INT, 0)),
"TypeGNULongName": reflect.ValueOf(constant.MakeFromLiteral("76", token.INT, 0)),
"TypeGNUSparse": reflect.ValueOf(constant.MakeFromLiteral("83", token.INT, 0)),
"TypeLink": reflect.ValueOf(constant.MakeFromLiteral("49", token.INT, 0)),
"TypeReg": reflect.ValueOf(constant.MakeFromLiteral("48", token.INT, 0)),
"TypeRegA": reflect.ValueOf(constant.MakeFromLiteral("0", token.INT, 0)),
"TypeSymlink": reflect.ValueOf(constant.MakeFromLiteral("50", token.INT, 0)),
"TypeXGlobalHeader": reflect.ValueOf(constant.MakeFromLiteral("103", token.INT, 0)),
"TypeXHeader": reflect.ValueOf(constant.MakeFromLiteral("120", token.INT, 0)),
// type definitions
"Format": reflect.ValueOf((*tar.Format)(nil)),
"Header": reflect.ValueOf((*tar.Header)(nil)),
"Reader": reflect.ValueOf((*tar.Reader)(nil)),
"Writer": reflect.ValueOf((*tar.Writer)(nil)),
}
}
================================================
FILE: stdlib/go1_21_archive_zip.go
================================================
// Code generated by 'yaegi extract archive/zip'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"archive/zip"
"reflect"
)
func init() {
Symbols["archive/zip/zip"] = map[string]reflect.Value{
// function, constant and variable definitions
"Deflate": reflect.ValueOf(zip.Deflate),
"ErrAlgorithm": reflect.ValueOf(&zip.ErrAlgorithm).Elem(),
"ErrChecksum": reflect.ValueOf(&zip.ErrChecksum).Elem(),
"ErrFormat": reflect.ValueOf(&zip.ErrFormat).Elem(),
"ErrInsecurePath": reflect.ValueOf(&zip.ErrInsecurePath).Elem(),
"FileInfoHeader": reflect.ValueOf(zip.FileInfoHeader),
"NewReader": reflect.ValueOf(zip.NewReader),
"NewWriter": reflect.ValueOf(zip.NewWriter),
"OpenReader": reflect.ValueOf(zip.OpenReader),
"RegisterCompressor": reflect.ValueOf(zip.RegisterCompressor),
"RegisterDecompressor": reflect.ValueOf(zip.RegisterDecompressor),
"Store": reflect.ValueOf(zip.Store),
// type definitions
"Compressor": reflect.ValueOf((*zip.Compressor)(nil)),
"Decompressor": reflect.ValueOf((*zip.Decompressor)(nil)),
"File": reflect.ValueOf((*zip.File)(nil)),
"FileHeader": reflect.ValueOf((*zip.FileHeader)(nil)),
"ReadCloser": reflect.ValueOf((*zip.ReadCloser)(nil)),
"Reader": reflect.ValueOf((*zip.Reader)(nil)),
"Writer": reflect.ValueOf((*zip.Writer)(nil)),
}
}
================================================
FILE: stdlib/go1_21_bufio.go
================================================
// Code generated by 'yaegi extract bufio'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"bufio"
"go/constant"
"go/token"
"reflect"
)
func init() {
Symbols["bufio/bufio"] = map[string]reflect.Value{
// function, constant and variable definitions
"ErrAdvanceTooFar": reflect.ValueOf(&bufio.ErrAdvanceTooFar).Elem(),
"ErrBadReadCount": reflect.ValueOf(&bufio.ErrBadReadCount).Elem(),
"ErrBufferFull": reflect.ValueOf(&bufio.ErrBufferFull).Elem(),
"ErrFinalToken": reflect.ValueOf(&bufio.ErrFinalToken).Elem(),
"ErrInvalidUnreadByte": reflect.ValueOf(&bufio.ErrInvalidUnreadByte).Elem(),
"ErrInvalidUnreadRune": reflect.ValueOf(&bufio.ErrInvalidUnreadRune).Elem(),
"ErrNegativeAdvance": reflect.ValueOf(&bufio.ErrNegativeAdvance).Elem(),
"ErrNegativeCount": reflect.ValueOf(&bufio.ErrNegativeCount).Elem(),
"ErrTooLong": reflect.ValueOf(&bufio.ErrTooLong).Elem(),
"MaxScanTokenSize": reflect.ValueOf(constant.MakeFromLiteral("65536", token.INT, 0)),
"NewReadWriter": reflect.ValueOf(bufio.NewReadWriter),
"NewReader": reflect.ValueOf(bufio.NewReader),
"NewReaderSize": reflect.ValueOf(bufio.NewReaderSize),
"NewScanner": reflect.ValueOf(bufio.NewScanner),
"NewWriter": reflect.ValueOf(bufio.NewWriter),
"NewWriterSize": reflect.ValueOf(bufio.NewWriterSize),
"ScanBytes": reflect.ValueOf(bufio.ScanBytes),
"ScanLines": reflect.ValueOf(bufio.ScanLines),
"ScanRunes": reflect.ValueOf(bufio.ScanRunes),
"ScanWords": reflect.ValueOf(bufio.ScanWords),
// type definitions
"ReadWriter": reflect.ValueOf((*bufio.ReadWriter)(nil)),
"Reader": reflect.ValueOf((*bufio.Reader)(nil)),
"Scanner": reflect.ValueOf((*bufio.Scanner)(nil)),
"SplitFunc": reflect.ValueOf((*bufio.SplitFunc)(nil)),
"Writer": reflect.ValueOf((*bufio.Writer)(nil)),
}
}
================================================
FILE: stdlib/go1_21_bytes.go
================================================
// Code generated by 'yaegi extract bytes'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"bytes"
"go/constant"
"go/token"
"reflect"
)
func init() {
Symbols["bytes/bytes"] = map[string]reflect.Value{
// function, constant and variable definitions
"Clone": reflect.ValueOf(bytes.Clone),
"Compare": reflect.ValueOf(bytes.Compare),
"Contains": reflect.ValueOf(bytes.Contains),
"ContainsAny": reflect.ValueOf(bytes.ContainsAny),
"ContainsFunc": reflect.ValueOf(bytes.ContainsFunc),
"ContainsRune": reflect.ValueOf(bytes.ContainsRune),
"Count": reflect.ValueOf(bytes.Count),
"Cut": reflect.ValueOf(bytes.Cut),
"CutPrefix": reflect.ValueOf(bytes.CutPrefix),
"CutSuffix": reflect.ValueOf(bytes.CutSuffix),
"Equal": reflect.ValueOf(bytes.Equal),
"EqualFold": reflect.ValueOf(bytes.EqualFold),
"ErrTooLarge": reflect.ValueOf(&bytes.ErrTooLarge).Elem(),
"Fields": reflect.ValueOf(bytes.Fields),
"FieldsFunc": reflect.ValueOf(bytes.FieldsFunc),
"HasPrefix": reflect.ValueOf(bytes.HasPrefix),
"HasSuffix": reflect.ValueOf(bytes.HasSuffix),
"Index": reflect.ValueOf(bytes.Index),
"IndexAny": reflect.ValueOf(bytes.IndexAny),
"IndexByte": reflect.ValueOf(bytes.IndexByte),
"IndexFunc": reflect.ValueOf(bytes.IndexFunc),
"IndexRune": reflect.ValueOf(bytes.IndexRune),
"Join": reflect.ValueOf(bytes.Join),
"LastIndex": reflect.ValueOf(bytes.LastIndex),
"LastIndexAny": reflect.ValueOf(bytes.LastIndexAny),
"LastIndexByte": reflect.ValueOf(bytes.LastIndexByte),
"LastIndexFunc": reflect.ValueOf(bytes.LastIndexFunc),
"Map": reflect.ValueOf(bytes.Map),
"MinRead": reflect.ValueOf(constant.MakeFromLiteral("512", token.INT, 0)),
"NewBuffer": reflect.ValueOf(bytes.NewBuffer),
"NewBufferString": reflect.ValueOf(bytes.NewBufferString),
"NewReader": reflect.ValueOf(bytes.NewReader),
"Repeat": reflect.ValueOf(bytes.Repeat),
"Replace": reflect.ValueOf(bytes.Replace),
"ReplaceAll": reflect.ValueOf(bytes.ReplaceAll),
"Runes": reflect.ValueOf(bytes.Runes),
"Split": reflect.ValueOf(bytes.Split),
"SplitAfter": reflect.ValueOf(bytes.SplitAfter),
"SplitAfterN": reflect.ValueOf(bytes.SplitAfterN),
"SplitN": reflect.ValueOf(bytes.SplitN),
"Title": reflect.ValueOf(bytes.Title),
"ToLower": reflect.ValueOf(bytes.ToLower),
"ToLowerSpecial": reflect.ValueOf(bytes.ToLowerSpecial),
"ToTitle": reflect.ValueOf(bytes.ToTitle),
"ToTitleSpecial": reflect.ValueOf(bytes.ToTitleSpecial),
"ToUpper": reflect.ValueOf(bytes.ToUpper),
"ToUpperSpecial": reflect.ValueOf(bytes.ToUpperSpecial),
"ToValidUTF8": reflect.ValueOf(bytes.ToValidUTF8),
"Trim": reflect.ValueOf(bytes.Trim),
"TrimFunc": reflect.ValueOf(bytes.TrimFunc),
"TrimLeft": reflect.ValueOf(bytes.TrimLeft),
"TrimLeftFunc": reflect.ValueOf(bytes.TrimLeftFunc),
"TrimPrefix": reflect.ValueOf(bytes.TrimPrefix),
"TrimRight": reflect.ValueOf(bytes.TrimRight),
"TrimRightFunc": reflect.ValueOf(bytes.TrimRightFunc),
"TrimSpace": reflect.ValueOf(bytes.TrimSpace),
"TrimSuffix": reflect.ValueOf(bytes.TrimSuffix),
// type definitions
"Buffer": reflect.ValueOf((*bytes.Buffer)(nil)),
"Reader": reflect.ValueOf((*bytes.Reader)(nil)),
}
}
================================================
FILE: stdlib/go1_21_cmp.go
================================================
// Code generated by 'yaegi extract cmp'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"reflect"
)
func init() {
Symbols["cmp/cmp"] = map[string]reflect.Value{}
}
================================================
FILE: stdlib/go1_21_compress_bzip2.go
================================================
// Code generated by 'yaegi extract compress/bzip2'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"compress/bzip2"
"reflect"
)
func init() {
Symbols["compress/bzip2/bzip2"] = map[string]reflect.Value{
// function, constant and variable definitions
"NewReader": reflect.ValueOf(bzip2.NewReader),
// type definitions
"StructuralError": reflect.ValueOf((*bzip2.StructuralError)(nil)),
}
}
================================================
FILE: stdlib/go1_21_compress_flate.go
================================================
// Code generated by 'yaegi extract compress/flate'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"compress/flate"
"go/constant"
"go/token"
"io"
"reflect"
)
func init() {
Symbols["compress/flate/flate"] = map[string]reflect.Value{
// function, constant and variable definitions
"BestCompression": reflect.ValueOf(constant.MakeFromLiteral("9", token.INT, 0)),
"BestSpeed": reflect.ValueOf(constant.MakeFromLiteral("1", token.INT, 0)),
"DefaultCompression": reflect.ValueOf(constant.MakeFromLiteral("-1", token.INT, 0)),
"HuffmanOnly": reflect.ValueOf(constant.MakeFromLiteral("-2", token.INT, 0)),
"NewReader": reflect.ValueOf(flate.NewReader),
"NewReaderDict": reflect.ValueOf(flate.NewReaderDict),
"NewWriter": reflect.ValueOf(flate.NewWriter),
"NewWriterDict": reflect.ValueOf(flate.NewWriterDict),
"NoCompression": reflect.ValueOf(constant.MakeFromLiteral("0", token.INT, 0)),
// type definitions
"CorruptInputError": reflect.ValueOf((*flate.CorruptInputError)(nil)),
"InternalError": reflect.ValueOf((*flate.InternalError)(nil)),
"ReadError": reflect.ValueOf((*flate.ReadError)(nil)),
"Reader": reflect.ValueOf((*flate.Reader)(nil)),
"Resetter": reflect.ValueOf((*flate.Resetter)(nil)),
"WriteError": reflect.ValueOf((*flate.WriteError)(nil)),
"Writer": reflect.ValueOf((*flate.Writer)(nil)),
// interface wrapper definitions
"_Reader": reflect.ValueOf((*_compress_flate_Reader)(nil)),
"_Resetter": reflect.ValueOf((*_compress_flate_Resetter)(nil)),
}
}
// _compress_flate_Reader is an interface wrapper for Reader type
type _compress_flate_Reader struct {
IValue interface{}
WRead func(p []byte) (n int, err error)
WReadByte func() (byte, error)
}
func (W _compress_flate_Reader) Read(p []byte) (n int, err error) { return W.WRead(p) }
func (W _compress_flate_Reader) ReadByte() (byte, error) { return W.WReadByte() }
// _compress_flate_Resetter is an interface wrapper for Resetter type
type _compress_flate_Resetter struct {
IValue interface{}
WReset func(r io.Reader, dict []byte) error
}
func (W _compress_flate_Resetter) Reset(r io.Reader, dict []byte) error { return W.WReset(r, dict) }
================================================
FILE: stdlib/go1_21_compress_gzip.go
================================================
// Code generated by 'yaegi extract compress/gzip'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"compress/gzip"
"go/constant"
"go/token"
"reflect"
)
func init() {
Symbols["compress/gzip/gzip"] = map[string]reflect.Value{
// function, constant and variable definitions
"BestCompression": reflect.ValueOf(constant.MakeFromLiteral("9", token.INT, 0)),
"BestSpeed": reflect.ValueOf(constant.MakeFromLiteral("1", token.INT, 0)),
"DefaultCompression": reflect.ValueOf(constant.MakeFromLiteral("-1", token.INT, 0)),
"ErrChecksum": reflect.ValueOf(&gzip.ErrChecksum).Elem(),
"ErrHeader": reflect.ValueOf(&gzip.ErrHeader).Elem(),
"HuffmanOnly": reflect.ValueOf(constant.MakeFromLiteral("-2", token.INT, 0)),
"NewReader": reflect.ValueOf(gzip.NewReader),
"NewWriter": reflect.ValueOf(gzip.NewWriter),
"NewWriterLevel": reflect.ValueOf(gzip.NewWriterLevel),
"NoCompression": reflect.ValueOf(constant.MakeFromLiteral("0", token.INT, 0)),
// type definitions
"Header": reflect.ValueOf((*gzip.Header)(nil)),
"Reader": reflect.ValueOf((*gzip.Reader)(nil)),
"Writer": reflect.ValueOf((*gzip.Writer)(nil)),
}
}
================================================
FILE: stdlib/go1_21_compress_lzw.go
================================================
// Code generated by 'yaegi extract compress/lzw'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"compress/lzw"
"reflect"
)
func init() {
Symbols["compress/lzw/lzw"] = map[string]reflect.Value{
// function, constant and variable definitions
"LSB": reflect.ValueOf(lzw.LSB),
"MSB": reflect.ValueOf(lzw.MSB),
"NewReader": reflect.ValueOf(lzw.NewReader),
"NewWriter": reflect.ValueOf(lzw.NewWriter),
// type definitions
"Order": reflect.ValueOf((*lzw.Order)(nil)),
"Reader": reflect.ValueOf((*lzw.Reader)(nil)),
"Writer": reflect.ValueOf((*lzw.Writer)(nil)),
}
}
================================================
FILE: stdlib/go1_21_compress_zlib.go
================================================
// Code generated by 'yaegi extract compress/zlib'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"compress/zlib"
"go/constant"
"go/token"
"io"
"reflect"
)
func init() {
Symbols["compress/zlib/zlib"] = map[string]reflect.Value{
// function, constant and variable definitions
"BestCompression": reflect.ValueOf(constant.MakeFromLiteral("9", token.INT, 0)),
"BestSpeed": reflect.ValueOf(constant.MakeFromLiteral("1", token.INT, 0)),
"DefaultCompression": reflect.ValueOf(constant.MakeFromLiteral("-1", token.INT, 0)),
"ErrChecksum": reflect.ValueOf(&zlib.ErrChecksum).Elem(),
"ErrDictionary": reflect.ValueOf(&zlib.ErrDictionary).Elem(),
"ErrHeader": reflect.ValueOf(&zlib.ErrHeader).Elem(),
"HuffmanOnly": reflect.ValueOf(constant.MakeFromLiteral("-2", token.INT, 0)),
"NewReader": reflect.ValueOf(zlib.NewReader),
"NewReaderDict": reflect.ValueOf(zlib.NewReaderDict),
"NewWriter": reflect.ValueOf(zlib.NewWriter),
"NewWriterLevel": reflect.ValueOf(zlib.NewWriterLevel),
"NewWriterLevelDict": reflect.ValueOf(zlib.NewWriterLevelDict),
"NoCompression": reflect.ValueOf(constant.MakeFromLiteral("0", token.INT, 0)),
// type definitions
"Resetter": reflect.ValueOf((*zlib.Resetter)(nil)),
"Writer": reflect.ValueOf((*zlib.Writer)(nil)),
// interface wrapper definitions
"_Resetter": reflect.ValueOf((*_compress_zlib_Resetter)(nil)),
}
}
// _compress_zlib_Resetter is an interface wrapper for Resetter type
type _compress_zlib_Resetter struct {
IValue interface{}
WReset func(r io.Reader, dict []byte) error
}
func (W _compress_zlib_Resetter) Reset(r io.Reader, dict []byte) error { return W.WReset(r, dict) }
================================================
FILE: stdlib/go1_21_container_heap.go
================================================
// Code generated by 'yaegi extract container/heap'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"container/heap"
"reflect"
)
func init() {
Symbols["container/heap/heap"] = map[string]reflect.Value{
// function, constant and variable definitions
"Fix": reflect.ValueOf(heap.Fix),
"Init": reflect.ValueOf(heap.Init),
"Pop": reflect.ValueOf(heap.Pop),
"Push": reflect.ValueOf(heap.Push),
"Remove": reflect.ValueOf(heap.Remove),
// type definitions
"Interface": reflect.ValueOf((*heap.Interface)(nil)),
// interface wrapper definitions
"_Interface": reflect.ValueOf((*_container_heap_Interface)(nil)),
}
}
// _container_heap_Interface is an interface wrapper for Interface type
type _container_heap_Interface struct {
IValue interface{}
WLen func() int
WLess func(i int, j int) bool
WPop func() any
WPush func(x any)
WSwap func(i int, j int)
}
func (W _container_heap_Interface) Len() int { return W.WLen() }
func (W _container_heap_Interface) Less(i int, j int) bool { return W.WLess(i, j) }
func (W _container_heap_Interface) Pop() any { return W.WPop() }
func (W _container_heap_Interface) Push(x any) { W.WPush(x) }
func (W _container_heap_Interface) Swap(i int, j int) { W.WSwap(i, j) }
================================================
FILE: stdlib/go1_21_container_list.go
================================================
// Code generated by 'yaegi extract container/list'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"container/list"
"reflect"
)
func init() {
Symbols["container/list/list"] = map[string]reflect.Value{
// function, constant and variable definitions
"New": reflect.ValueOf(list.New),
// type definitions
"Element": reflect.ValueOf((*list.Element)(nil)),
"List": reflect.ValueOf((*list.List)(nil)),
}
}
================================================
FILE: stdlib/go1_21_container_ring.go
================================================
// Code generated by 'yaegi extract container/ring'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"container/ring"
"reflect"
)
func init() {
Symbols["container/ring/ring"] = map[string]reflect.Value{
// function, constant and variable definitions
"New": reflect.ValueOf(ring.New),
// type definitions
"Ring": reflect.ValueOf((*ring.Ring)(nil)),
}
}
================================================
FILE: stdlib/go1_21_context.go
================================================
// Code generated by 'yaegi extract context'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"context"
"reflect"
"time"
)
func init() {
Symbols["context/context"] = map[string]reflect.Value{
// function, constant and variable definitions
"AfterFunc": reflect.ValueOf(context.AfterFunc),
"Background": reflect.ValueOf(context.Background),
"Canceled": reflect.ValueOf(&context.Canceled).Elem(),
"Cause": reflect.ValueOf(context.Cause),
"DeadlineExceeded": reflect.ValueOf(&context.DeadlineExceeded).Elem(),
"TODO": reflect.ValueOf(context.TODO),
"WithCancel": reflect.ValueOf(context.WithCancel),
"WithCancelCause": reflect.ValueOf(context.WithCancelCause),
"WithDeadline": reflect.ValueOf(context.WithDeadline),
"WithDeadlineCause": reflect.ValueOf(context.WithDeadlineCause),
"WithTimeout": reflect.ValueOf(context.WithTimeout),
"WithTimeoutCause": reflect.ValueOf(context.WithTimeoutCause),
"WithValue": reflect.ValueOf(context.WithValue),
"WithoutCancel": reflect.ValueOf(context.WithoutCancel),
// type definitions
"CancelCauseFunc": reflect.ValueOf((*context.CancelCauseFunc)(nil)),
"CancelFunc": reflect.ValueOf((*context.CancelFunc)(nil)),
"Context": reflect.ValueOf((*context.Context)(nil)),
// interface wrapper definitions
"_Context": reflect.ValueOf((*_context_Context)(nil)),
}
}
// _context_Context is an interface wrapper for Context type
type _context_Context struct {
IValue interface{}
WDeadline func() (deadline time.Time, ok bool)
WDone func() <-chan struct{}
WErr func() error
WValue func(key any) any
}
func (W _context_Context) Deadline() (deadline time.Time, ok bool) { return W.WDeadline() }
func (W _context_Context) Done() <-chan struct{} { return W.WDone() }
func (W _context_Context) Err() error { return W.WErr() }
func (W _context_Context) Value(key any) any { return W.WValue(key) }
================================================
FILE: stdlib/go1_21_crypto.go
================================================
// Code generated by 'yaegi extract crypto'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"crypto"
"io"
"reflect"
)
func init() {
Symbols["crypto/crypto"] = map[string]reflect.Value{
// function, constant and variable definitions
"BLAKE2b_256": reflect.ValueOf(crypto.BLAKE2b_256),
"BLAKE2b_384": reflect.ValueOf(crypto.BLAKE2b_384),
"BLAKE2b_512": reflect.ValueOf(crypto.BLAKE2b_512),
"BLAKE2s_256": reflect.ValueOf(crypto.BLAKE2s_256),
"MD4": reflect.ValueOf(crypto.MD4),
"MD5": reflect.ValueOf(crypto.MD5),
"MD5SHA1": reflect.ValueOf(crypto.MD5SHA1),
"RIPEMD160": reflect.ValueOf(crypto.RIPEMD160),
"RegisterHash": reflect.ValueOf(crypto.RegisterHash),
"SHA1": reflect.ValueOf(crypto.SHA1),
"SHA224": reflect.ValueOf(crypto.SHA224),
"SHA256": reflect.ValueOf(crypto.SHA256),
"SHA384": reflect.ValueOf(crypto.SHA384),
"SHA3_224": reflect.ValueOf(crypto.SHA3_224),
"SHA3_256": reflect.ValueOf(crypto.SHA3_256),
"SHA3_384": reflect.ValueOf(crypto.SHA3_384),
"SHA3_512": reflect.ValueOf(crypto.SHA3_512),
"SHA512": reflect.ValueOf(crypto.SHA512),
"SHA512_224": reflect.ValueOf(crypto.SHA512_224),
"SHA512_256": reflect.ValueOf(crypto.SHA512_256),
// type definitions
"Decrypter": reflect.ValueOf((*crypto.Decrypter)(nil)),
"DecrypterOpts": reflect.ValueOf((*crypto.DecrypterOpts)(nil)),
"Hash": reflect.ValueOf((*crypto.Hash)(nil)),
"PrivateKey": reflect.ValueOf((*crypto.PrivateKey)(nil)),
"PublicKey": reflect.ValueOf((*crypto.PublicKey)(nil)),
"Signer": reflect.ValueOf((*crypto.Signer)(nil)),
"SignerOpts": reflect.ValueOf((*crypto.SignerOpts)(nil)),
// interface wrapper definitions
"_Decrypter": reflect.ValueOf((*_crypto_Decrypter)(nil)),
"_DecrypterOpts": reflect.ValueOf((*_crypto_DecrypterOpts)(nil)),
"_PrivateKey": reflect.ValueOf((*_crypto_PrivateKey)(nil)),
"_PublicKey": reflect.ValueOf((*_crypto_PublicKey)(nil)),
"_Signer": reflect.ValueOf((*_crypto_Signer)(nil)),
"_SignerOpts": reflect.ValueOf((*_crypto_SignerOpts)(nil)),
}
}
// _crypto_Decrypter is an interface wrapper for Decrypter type
type _crypto_Decrypter struct {
IValue interface{}
WDecrypt func(rand io.Reader, msg []byte, opts crypto.DecrypterOpts) (plaintext []byte, err error)
WPublic func() crypto.PublicKey
}
func (W _crypto_Decrypter) Decrypt(rand io.Reader, msg []byte, opts crypto.DecrypterOpts) (plaintext []byte, err error) {
return W.WDecrypt(rand, msg, opts)
}
func (W _crypto_Decrypter) Public() crypto.PublicKey { return W.WPublic() }
// _crypto_DecrypterOpts is an interface wrapper for DecrypterOpts type
type _crypto_DecrypterOpts struct {
IValue interface{}
}
// _crypto_PrivateKey is an interface wrapper for PrivateKey type
type _crypto_PrivateKey struct {
IValue interface{}
}
// _crypto_PublicKey is an interface wrapper for PublicKey type
type _crypto_PublicKey struct {
IValue interface{}
}
// _crypto_Signer is an interface wrapper for Signer type
type _crypto_Signer struct {
IValue interface{}
WPublic func() crypto.PublicKey
WSign func(rand io.Reader, digest []byte, opts crypto.SignerOpts) (signature []byte, err error)
}
func (W _crypto_Signer) Public() crypto.PublicKey { return W.WPublic() }
func (W _crypto_Signer) Sign(rand io.Reader, digest []byte, opts crypto.SignerOpts) (signature []byte, err error) {
return W.WSign(rand, digest, opts)
}
// _crypto_SignerOpts is an interface wrapper for SignerOpts type
type _crypto_SignerOpts struct {
IValue interface{}
WHashFunc func() crypto.Hash
}
func (W _crypto_SignerOpts) HashFunc() crypto.Hash { return W.WHashFunc() }
================================================
FILE: stdlib/go1_21_crypto_aes.go
================================================
// Code generated by 'yaegi extract crypto/aes'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"crypto/aes"
"go/constant"
"go/token"
"reflect"
)
func init() {
Symbols["crypto/aes/aes"] = map[string]reflect.Value{
// function, constant and variable definitions
"BlockSize": reflect.ValueOf(constant.MakeFromLiteral("16", token.INT, 0)),
"NewCipher": reflect.ValueOf(aes.NewCipher),
// type definitions
"KeySizeError": reflect.ValueOf((*aes.KeySizeError)(nil)),
}
}
================================================
FILE: stdlib/go1_21_crypto_cipher.go
================================================
// Code generated by 'yaegi extract crypto/cipher'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"crypto/cipher"
"reflect"
)
func init() {
Symbols["crypto/cipher/cipher"] = map[string]reflect.Value{
// function, constant and variable definitions
"NewCBCDecrypter": reflect.ValueOf(cipher.NewCBCDecrypter),
"NewCBCEncrypter": reflect.ValueOf(cipher.NewCBCEncrypter),
"NewCFBDecrypter": reflect.ValueOf(cipher.NewCFBDecrypter),
"NewCFBEncrypter": reflect.ValueOf(cipher.NewCFBEncrypter),
"NewCTR": reflect.ValueOf(cipher.NewCTR),
"NewGCM": reflect.ValueOf(cipher.NewGCM),
"NewGCMWithNonceSize": reflect.ValueOf(cipher.NewGCMWithNonceSize),
"NewGCMWithTagSize": reflect.ValueOf(cipher.NewGCMWithTagSize),
"NewOFB": reflect.ValueOf(cipher.NewOFB),
// type definitions
"AEAD": reflect.ValueOf((*cipher.AEAD)(nil)),
"Block": reflect.ValueOf((*cipher.Block)(nil)),
"BlockMode": reflect.ValueOf((*cipher.BlockMode)(nil)),
"Stream": reflect.ValueOf((*cipher.Stream)(nil)),
"StreamReader": reflect.ValueOf((*cipher.StreamReader)(nil)),
"StreamWriter": reflect.ValueOf((*cipher.StreamWriter)(nil)),
// interface wrapper definitions
"_AEAD": reflect.ValueOf((*_crypto_cipher_AEAD)(nil)),
"_Block": reflect.ValueOf((*_crypto_cipher_Block)(nil)),
"_BlockMode": reflect.ValueOf((*_crypto_cipher_BlockMode)(nil)),
"_Stream": reflect.ValueOf((*_crypto_cipher_Stream)(nil)),
}
}
// _crypto_cipher_AEAD is an interface wrapper for AEAD type
type _crypto_cipher_AEAD struct {
IValue interface{}
WNonceSize func() int
WOpen func(dst []byte, nonce []byte, ciphertext []byte, additionalData []byte) ([]byte, error)
WOverhead func() int
WSeal func(dst []byte, nonce []byte, plaintext []byte, additionalData []byte) []byte
}
func (W _crypto_cipher_AEAD) NonceSize() int { return W.WNonceSize() }
func (W _crypto_cipher_AEAD) Open(dst []byte, nonce []byte, ciphertext []byte, additionalData []byte) ([]byte, error) {
return W.WOpen(dst, nonce, ciphertext, additionalData)
}
func (W _crypto_cipher_AEAD) Overhead() int { return W.WOverhead() }
func (W _crypto_cipher_AEAD) Seal(dst []byte, nonce []byte, plaintext []byte, additionalData []byte) []byte {
return W.WSeal(dst, nonce, plaintext, additionalData)
}
// _crypto_cipher_Block is an interface wrapper for Block type
type _crypto_cipher_Block struct {
IValue interface{}
WBlockSize func() int
WDecrypt func(dst []byte, src []byte)
WEncrypt func(dst []byte, src []byte)
}
func (W _crypto_cipher_Block) BlockSize() int { return W.WBlockSize() }
func (W _crypto_cipher_Block) Decrypt(dst []byte, src []byte) { W.WDecrypt(dst, src) }
func (W _crypto_cipher_Block) Encrypt(dst []byte, src []byte) { W.WEncrypt(dst, src) }
// _crypto_cipher_BlockMode is an interface wrapper for BlockMode type
type _crypto_cipher_BlockMode struct {
IValue interface{}
WBlockSize func() int
WCryptBlocks func(dst []byte, src []byte)
}
func (W _crypto_cipher_BlockMode) BlockSize() int { return W.WBlockSize() }
func (W _crypto_cipher_BlockMode) CryptBlocks(dst []byte, src []byte) { W.WCryptBlocks(dst, src) }
// _crypto_cipher_Stream is an interface wrapper for Stream type
type _crypto_cipher_Stream struct {
IValue interface{}
WXORKeyStream func(dst []byte, src []byte)
}
func (W _crypto_cipher_Stream) XORKeyStream(dst []byte, src []byte) { W.WXORKeyStream(dst, src) }
================================================
FILE: stdlib/go1_21_crypto_des.go
================================================
// Code generated by 'yaegi extract crypto/des'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"crypto/des"
"go/constant"
"go/token"
"reflect"
)
func init() {
Symbols["crypto/des/des"] = map[string]reflect.Value{
// function, constant and variable definitions
"BlockSize": reflect.ValueOf(constant.MakeFromLiteral("8", token.INT, 0)),
"NewCipher": reflect.ValueOf(des.NewCipher),
"NewTripleDESCipher": reflect.ValueOf(des.NewTripleDESCipher),
// type definitions
"KeySizeError": reflect.ValueOf((*des.KeySizeError)(nil)),
}
}
================================================
FILE: stdlib/go1_21_crypto_dsa.go
================================================
// Code generated by 'yaegi extract crypto/dsa'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"crypto/dsa"
"reflect"
)
func init() {
Symbols["crypto/dsa/dsa"] = map[string]reflect.Value{
// function, constant and variable definitions
"ErrInvalidPublicKey": reflect.ValueOf(&dsa.ErrInvalidPublicKey).Elem(),
"GenerateKey": reflect.ValueOf(dsa.GenerateKey),
"GenerateParameters": reflect.ValueOf(dsa.GenerateParameters),
"L1024N160": reflect.ValueOf(dsa.L1024N160),
"L2048N224": reflect.ValueOf(dsa.L2048N224),
"L2048N256": reflect.ValueOf(dsa.L2048N256),
"L3072N256": reflect.ValueOf(dsa.L3072N256),
"Sign": reflect.ValueOf(dsa.Sign),
"Verify": reflect.ValueOf(dsa.Verify),
// type definitions
"ParameterSizes": reflect.ValueOf((*dsa.ParameterSizes)(nil)),
"Parameters": reflect.ValueOf((*dsa.Parameters)(nil)),
"PrivateKey": reflect.ValueOf((*dsa.PrivateKey)(nil)),
"PublicKey": reflect.ValueOf((*dsa.PublicKey)(nil)),
}
}
================================================
FILE: stdlib/go1_21_crypto_ecdh.go
================================================
// Code generated by 'yaegi extract crypto/ecdh'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"crypto/ecdh"
"io"
"reflect"
)
func init() {
Symbols["crypto/ecdh/ecdh"] = map[string]reflect.Value{
// function, constant and variable definitions
"P256": reflect.ValueOf(ecdh.P256),
"P384": reflect.ValueOf(ecdh.P384),
"P521": reflect.ValueOf(ecdh.P521),
"X25519": reflect.ValueOf(ecdh.X25519),
// type definitions
"Curve": reflect.ValueOf((*ecdh.Curve)(nil)),
"PrivateKey": reflect.ValueOf((*ecdh.PrivateKey)(nil)),
"PublicKey": reflect.ValueOf((*ecdh.PublicKey)(nil)),
// interface wrapper definitions
"_Curve": reflect.ValueOf((*_crypto_ecdh_Curve)(nil)),
}
}
// _crypto_ecdh_Curve is an interface wrapper for Curve type
type _crypto_ecdh_Curve struct {
IValue interface{}
WGenerateKey func(rand io.Reader) (*ecdh.PrivateKey, error)
WNewPrivateKey func(key []byte) (*ecdh.PrivateKey, error)
WNewPublicKey func(key []byte) (*ecdh.PublicKey, error)
}
func (W _crypto_ecdh_Curve) GenerateKey(rand io.Reader) (*ecdh.PrivateKey, error) {
return W.WGenerateKey(rand)
}
func (W _crypto_ecdh_Curve) NewPrivateKey(key []byte) (*ecdh.PrivateKey, error) {
return W.WNewPrivateKey(key)
}
func (W _crypto_ecdh_Curve) NewPublicKey(key []byte) (*ecdh.PublicKey, error) {
return W.WNewPublicKey(key)
}
================================================
FILE: stdlib/go1_21_crypto_ecdsa.go
================================================
// Code generated by 'yaegi extract crypto/ecdsa'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"crypto/ecdsa"
"reflect"
)
func init() {
Symbols["crypto/ecdsa/ecdsa"] = map[string]reflect.Value{
// function, constant and variable definitions
"GenerateKey": reflect.ValueOf(ecdsa.GenerateKey),
"Sign": reflect.ValueOf(ecdsa.Sign),
"SignASN1": reflect.ValueOf(ecdsa.SignASN1),
"Verify": reflect.ValueOf(ecdsa.Verify),
"VerifyASN1": reflect.ValueOf(ecdsa.VerifyASN1),
// type definitions
"PrivateKey": reflect.ValueOf((*ecdsa.PrivateKey)(nil)),
"PublicKey": reflect.ValueOf((*ecdsa.PublicKey)(nil)),
}
}
================================================
FILE: stdlib/go1_21_crypto_ed25519.go
================================================
// Code generated by 'yaegi extract crypto/ed25519'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"crypto/ed25519"
"go/constant"
"go/token"
"reflect"
)
func init() {
Symbols["crypto/ed25519/ed25519"] = map[string]reflect.Value{
// function, constant and variable definitions
"GenerateKey": reflect.ValueOf(ed25519.GenerateKey),
"NewKeyFromSeed": reflect.ValueOf(ed25519.NewKeyFromSeed),
"PrivateKeySize": reflect.ValueOf(constant.MakeFromLiteral("64", token.INT, 0)),
"PublicKeySize": reflect.ValueOf(constant.MakeFromLiteral("32", token.INT, 0)),
"SeedSize": reflect.ValueOf(constant.MakeFromLiteral("32", token.INT, 0)),
"Sign": reflect.ValueOf(ed25519.Sign),
"SignatureSize": reflect.ValueOf(constant.MakeFromLiteral("64", token.INT, 0)),
"Verify": reflect.ValueOf(ed25519.Verify),
"VerifyWithOptions": reflect.ValueOf(ed25519.VerifyWithOptions),
// type definitions
"Options": reflect.ValueOf((*ed25519.Options)(nil)),
"PrivateKey": reflect.ValueOf((*ed25519.PrivateKey)(nil)),
"PublicKey": reflect.ValueOf((*ed25519.PublicKey)(nil)),
}
}
================================================
FILE: stdlib/go1_21_crypto_elliptic.go
================================================
// Code generated by 'yaegi extract crypto/elliptic'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"crypto/elliptic"
"math/big"
"reflect"
)
func init() {
Symbols["crypto/elliptic/elliptic"] = map[string]reflect.Value{
// function, constant and variable definitions
"GenerateKey": reflect.ValueOf(elliptic.GenerateKey),
"Marshal": reflect.ValueOf(elliptic.Marshal),
"MarshalCompressed": reflect.ValueOf(elliptic.MarshalCompressed),
"P224": reflect.ValueOf(elliptic.P224),
"P256": reflect.ValueOf(elliptic.P256),
"P384": reflect.ValueOf(elliptic.P384),
"P521": reflect.ValueOf(elliptic.P521),
"Unmarshal": reflect.ValueOf(elliptic.Unmarshal),
"UnmarshalCompressed": reflect.ValueOf(elliptic.UnmarshalCompressed),
// type definitions
"Curve": reflect.ValueOf((*elliptic.Curve)(nil)),
"CurveParams": reflect.ValueOf((*elliptic.CurveParams)(nil)),
// interface wrapper definitions
"_Curve": reflect.ValueOf((*_crypto_elliptic_Curve)(nil)),
}
}
// _crypto_elliptic_Curve is an interface wrapper for Curve type
type _crypto_elliptic_Curve struct {
IValue interface{}
WAdd func(x1 *big.Int, y1 *big.Int, x2 *big.Int, y2 *big.Int) (x *big.Int, y *big.Int)
WDouble func(x1 *big.Int, y1 *big.Int) (x *big.Int, y *big.Int)
WIsOnCurve func(x *big.Int, y *big.Int) bool
WParams func() *elliptic.CurveParams
WScalarBaseMult func(k []byte) (x *big.Int, y *big.Int)
WScalarMult func(x1 *big.Int, y1 *big.Int, k []byte) (x *big.Int, y *big.Int)
}
func (W _crypto_elliptic_Curve) Add(x1 *big.Int, y1 *big.Int, x2 *big.Int, y2 *big.Int) (x *big.Int, y *big.Int) {
return W.WAdd(x1, y1, x2, y2)
}
func (W _crypto_elliptic_Curve) Double(x1 *big.Int, y1 *big.Int) (x *big.Int, y *big.Int) {
return W.WDouble(x1, y1)
}
func (W _crypto_elliptic_Curve) IsOnCurve(x *big.Int, y *big.Int) bool { return W.WIsOnCurve(x, y) }
func (W _crypto_elliptic_Curve) Params() *elliptic.CurveParams { return W.WParams() }
func (W _crypto_elliptic_Curve) ScalarBaseMult(k []byte) (x *big.Int, y *big.Int) {
return W.WScalarBaseMult(k)
}
func (W _crypto_elliptic_Curve) ScalarMult(x1 *big.Int, y1 *big.Int, k []byte) (x *big.Int, y *big.Int) {
return W.WScalarMult(x1, y1, k)
}
================================================
FILE: stdlib/go1_21_crypto_hmac.go
================================================
// Code generated by 'yaegi extract crypto/hmac'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"crypto/hmac"
"reflect"
)
func init() {
Symbols["crypto/hmac/hmac"] = map[string]reflect.Value{
// function, constant and variable definitions
"Equal": reflect.ValueOf(hmac.Equal),
"New": reflect.ValueOf(hmac.New),
}
}
================================================
FILE: stdlib/go1_21_crypto_md5.go
================================================
// Code generated by 'yaegi extract crypto/md5'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"crypto/md5"
"go/constant"
"go/token"
"reflect"
)
func init() {
Symbols["crypto/md5/md5"] = map[string]reflect.Value{
// function, constant and variable definitions
"BlockSize": reflect.ValueOf(constant.MakeFromLiteral("64", token.INT, 0)),
"New": reflect.ValueOf(md5.New),
"Size": reflect.ValueOf(constant.MakeFromLiteral("16", token.INT, 0)),
"Sum": reflect.ValueOf(md5.Sum),
}
}
================================================
FILE: stdlib/go1_21_crypto_rand.go
================================================
// Code generated by 'yaegi extract crypto/rand'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"crypto/rand"
"reflect"
)
func init() {
Symbols["crypto/rand/rand"] = map[string]reflect.Value{
// function, constant and variable definitions
"Int": reflect.ValueOf(rand.Int),
"Prime": reflect.ValueOf(rand.Prime),
"Read": reflect.ValueOf(rand.Read),
"Reader": reflect.ValueOf(&rand.Reader).Elem(),
}
}
================================================
FILE: stdlib/go1_21_crypto_rc4.go
================================================
// Code generated by 'yaegi extract crypto/rc4'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"crypto/rc4"
"reflect"
)
func init() {
Symbols["crypto/rc4/rc4"] = map[string]reflect.Value{
// function, constant and variable definitions
"NewCipher": reflect.ValueOf(rc4.NewCipher),
// type definitions
"Cipher": reflect.ValueOf((*rc4.Cipher)(nil)),
"KeySizeError": reflect.ValueOf((*rc4.KeySizeError)(nil)),
}
}
================================================
FILE: stdlib/go1_21_crypto_rsa.go
================================================
// Code generated by 'yaegi extract crypto/rsa'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"crypto/rsa"
"go/constant"
"go/token"
"reflect"
)
func init() {
Symbols["crypto/rsa/rsa"] = map[string]reflect.Value{
// function, constant and variable definitions
"DecryptOAEP": reflect.ValueOf(rsa.DecryptOAEP),
"DecryptPKCS1v15": reflect.ValueOf(rsa.DecryptPKCS1v15),
"DecryptPKCS1v15SessionKey": reflect.ValueOf(rsa.DecryptPKCS1v15SessionKey),
"EncryptOAEP": reflect.ValueOf(rsa.EncryptOAEP),
"EncryptPKCS1v15": reflect.ValueOf(rsa.EncryptPKCS1v15),
"ErrDecryption": reflect.ValueOf(&rsa.ErrDecryption).Elem(),
"ErrMessageTooLong": reflect.ValueOf(&rsa.ErrMessageTooLong).Elem(),
"ErrVerification": reflect.ValueOf(&rsa.ErrVerification).Elem(),
"GenerateKey": reflect.ValueOf(rsa.GenerateKey),
"GenerateMultiPrimeKey": reflect.ValueOf(rsa.GenerateMultiPrimeKey),
"PSSSaltLengthAuto": reflect.ValueOf(constant.MakeFromLiteral("0", token.INT, 0)),
"PSSSaltLengthEqualsHash": reflect.ValueOf(constant.MakeFromLiteral("-1", token.INT, 0)),
"SignPKCS1v15": reflect.ValueOf(rsa.SignPKCS1v15),
"SignPSS": reflect.ValueOf(rsa.SignPSS),
"VerifyPKCS1v15": reflect.ValueOf(rsa.VerifyPKCS1v15),
"VerifyPSS": reflect.ValueOf(rsa.VerifyPSS),
// type definitions
"CRTValue": reflect.ValueOf((*rsa.CRTValue)(nil)),
"OAEPOptions": reflect.ValueOf((*rsa.OAEPOptions)(nil)),
"PKCS1v15DecryptOptions": reflect.ValueOf((*rsa.PKCS1v15DecryptOptions)(nil)),
"PSSOptions": reflect.ValueOf((*rsa.PSSOptions)(nil)),
"PrecomputedValues": reflect.ValueOf((*rsa.PrecomputedValues)(nil)),
"PrivateKey": reflect.ValueOf((*rsa.PrivateKey)(nil)),
"PublicKey": reflect.ValueOf((*rsa.PublicKey)(nil)),
}
}
================================================
FILE: stdlib/go1_21_crypto_sha1.go
================================================
// Code generated by 'yaegi extract crypto/sha1'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"crypto/sha1"
"go/constant"
"go/token"
"reflect"
)
func init() {
Symbols["crypto/sha1/sha1"] = map[string]reflect.Value{
// function, constant and variable definitions
"BlockSize": reflect.ValueOf(constant.MakeFromLiteral("64", token.INT, 0)),
"New": reflect.ValueOf(sha1.New),
"Size": reflect.ValueOf(constant.MakeFromLiteral("20", token.INT, 0)),
"Sum": reflect.ValueOf(sha1.Sum),
}
}
================================================
FILE: stdlib/go1_21_crypto_sha256.go
================================================
// Code generated by 'yaegi extract crypto/sha256'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"crypto/sha256"
"go/constant"
"go/token"
"reflect"
)
func init() {
Symbols["crypto/sha256/sha256"] = map[string]reflect.Value{
// function, constant and variable definitions
"BlockSize": reflect.ValueOf(constant.MakeFromLiteral("64", token.INT, 0)),
"New": reflect.ValueOf(sha256.New),
"New224": reflect.ValueOf(sha256.New224),
"Size": reflect.ValueOf(constant.MakeFromLiteral("32", token.INT, 0)),
"Size224": reflect.ValueOf(constant.MakeFromLiteral("28", token.INT, 0)),
"Sum224": reflect.ValueOf(sha256.Sum224),
"Sum256": reflect.ValueOf(sha256.Sum256),
}
}
================================================
FILE: stdlib/go1_21_crypto_sha512.go
================================================
// Code generated by 'yaegi extract crypto/sha512'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"crypto/sha512"
"go/constant"
"go/token"
"reflect"
)
func init() {
Symbols["crypto/sha512/sha512"] = map[string]reflect.Value{
// function, constant and variable definitions
"BlockSize": reflect.ValueOf(constant.MakeFromLiteral("128", token.INT, 0)),
"New": reflect.ValueOf(sha512.New),
"New384": reflect.ValueOf(sha512.New384),
"New512_224": reflect.ValueOf(sha512.New512_224),
"New512_256": reflect.ValueOf(sha512.New512_256),
"Size": reflect.ValueOf(constant.MakeFromLiteral("64", token.INT, 0)),
"Size224": reflect.ValueOf(constant.MakeFromLiteral("28", token.INT, 0)),
"Size256": reflect.ValueOf(constant.MakeFromLiteral("32", token.INT, 0)),
"Size384": reflect.ValueOf(constant.MakeFromLiteral("48", token.INT, 0)),
"Sum384": reflect.ValueOf(sha512.Sum384),
"Sum512": reflect.ValueOf(sha512.Sum512),
"Sum512_224": reflect.ValueOf(sha512.Sum512_224),
"Sum512_256": reflect.ValueOf(sha512.Sum512_256),
}
}
================================================
FILE: stdlib/go1_21_crypto_subtle.go
================================================
// Code generated by 'yaegi extract crypto/subtle'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"crypto/subtle"
"reflect"
)
func init() {
Symbols["crypto/subtle/subtle"] = map[string]reflect.Value{
// function, constant and variable definitions
"ConstantTimeByteEq": reflect.ValueOf(subtle.ConstantTimeByteEq),
"ConstantTimeCompare": reflect.ValueOf(subtle.ConstantTimeCompare),
"ConstantTimeCopy": reflect.ValueOf(subtle.ConstantTimeCopy),
"ConstantTimeEq": reflect.ValueOf(subtle.ConstantTimeEq),
"ConstantTimeLessOrEq": reflect.ValueOf(subtle.ConstantTimeLessOrEq),
"ConstantTimeSelect": reflect.ValueOf(subtle.ConstantTimeSelect),
"XORBytes": reflect.ValueOf(subtle.XORBytes),
}
}
================================================
FILE: stdlib/go1_21_crypto_tls.go
================================================
// Code generated by 'yaegi extract crypto/tls'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"crypto/tls"
"go/constant"
"go/token"
"reflect"
)
func init() {
Symbols["crypto/tls/tls"] = map[string]reflect.Value{
// function, constant and variable definitions
"CipherSuiteName": reflect.ValueOf(tls.CipherSuiteName),
"CipherSuites": reflect.ValueOf(tls.CipherSuites),
"Client": reflect.ValueOf(tls.Client),
"CurveP256": reflect.ValueOf(tls.CurveP256),
"CurveP384": reflect.ValueOf(tls.CurveP384),
"CurveP521": reflect.ValueOf(tls.CurveP521),
"Dial": reflect.ValueOf(tls.Dial),
"DialWithDialer": reflect.ValueOf(tls.DialWithDialer),
"ECDSAWithP256AndSHA256": reflect.ValueOf(tls.ECDSAWithP256AndSHA256),
"ECDSAWithP384AndSHA384": reflect.ValueOf(tls.ECDSAWithP384AndSHA384),
"ECDSAWithP521AndSHA512": reflect.ValueOf(tls.ECDSAWithP521AndSHA512),
"ECDSAWithSHA1": reflect.ValueOf(tls.ECDSAWithSHA1),
"Ed25519": reflect.ValueOf(tls.Ed25519),
"InsecureCipherSuites": reflect.ValueOf(tls.InsecureCipherSuites),
"Listen": reflect.ValueOf(tls.Listen),
"LoadX509KeyPair": reflect.ValueOf(tls.LoadX509KeyPair),
"NewLRUClientSessionCache": reflect.ValueOf(tls.NewLRUClientSessionCache),
"NewListener": reflect.ValueOf(tls.NewListener),
"NewResumptionState": reflect.ValueOf(tls.NewResumptionState),
"NoClientCert": reflect.ValueOf(tls.NoClientCert),
"PKCS1WithSHA1": reflect.ValueOf(tls.PKCS1WithSHA1),
"PKCS1WithSHA256": reflect.ValueOf(tls.PKCS1WithSHA256),
"PKCS1WithSHA384": reflect.ValueOf(tls.PKCS1WithSHA384),
"PKCS1WithSHA512": reflect.ValueOf(tls.PKCS1WithSHA512),
"PSSWithSHA256": reflect.ValueOf(tls.PSSWithSHA256),
"PSSWithSHA384": reflect.ValueOf(tls.PSSWithSHA384),
"PSSWithSHA512": reflect.ValueOf(tls.PSSWithSHA512),
"ParseSessionState": reflect.ValueOf(tls.ParseSessionState),
"QUICClient": reflect.ValueOf(tls.QUICClient),
"QUICEncryptionLevelApplication": reflect.ValueOf(tls.QUICEncryptionLevelApplication),
"QUICEncryptionLevelEarly": reflect.ValueOf(tls.QUICEncryptionLevelEarly),
"QUICEncryptionLevelHandshake": reflect.ValueOf(tls.QUICEncryptionLevelHandshake),
"QUICEncryptionLevelInitial": reflect.ValueOf(tls.QUICEncryptionLevelInitial),
"QUICHandshakeDone": reflect.ValueOf(tls.QUICHandshakeDone),
"QUICNoEvent": reflect.ValueOf(tls.QUICNoEvent),
"QUICRejectedEarlyData": reflect.ValueOf(tls.QUICRejectedEarlyData),
"QUICServer": reflect.ValueOf(tls.QUICServer),
"QUICSetReadSecret": reflect.ValueOf(tls.QUICSetReadSecret),
"QUICSetWriteSecret": reflect.ValueOf(tls.QUICSetWriteSecret),
"QUICTransportParameters": reflect.ValueOf(tls.QUICTransportParameters),
"QUICTransportParametersRequired": reflect.ValueOf(tls.QUICTransportParametersRequired),
"QUICWriteData": reflect.ValueOf(tls.QUICWriteData),
"RenegotiateFreelyAsClient": reflect.ValueOf(tls.RenegotiateFreelyAsClient),
"RenegotiateNever": reflect.ValueOf(tls.RenegotiateNever),
"RenegotiateOnceAsClient": reflect.ValueOf(tls.RenegotiateOnceAsClient),
"RequestClientCert": reflect.ValueOf(tls.RequestClientCert),
"RequireAndVerifyClientCert": reflect.ValueOf(tls.RequireAndVerifyClientCert),
"RequireAnyClientCert": reflect.ValueOf(tls.RequireAnyClientCert),
"Server": reflect.ValueOf(tls.Server),
"TLS_AES_128_GCM_SHA256": reflect.ValueOf(tls.TLS_AES_128_GCM_SHA256),
"TLS_AES_256_GCM_SHA384": reflect.ValueOf(tls.TLS_AES_256_GCM_SHA384),
"TLS_CHACHA20_POLY1305_SHA256": reflect.ValueOf(tls.TLS_CHACHA20_POLY1305_SHA256),
"TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA": reflect.ValueOf(tls.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA),
"TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256": reflect.ValueOf(tls.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256),
"TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256": reflect.ValueOf(tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256),
"TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA": reflect.ValueOf(tls.TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA),
"TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384": reflect.ValueOf(tls.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384),
"TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305": reflect.ValueOf(tls.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305),
"TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256": reflect.ValueOf(tls.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256),
"TLS_ECDHE_ECDSA_WITH_RC4_128_SHA": reflect.ValueOf(tls.TLS_ECDHE_ECDSA_WITH_RC4_128_SHA),
"TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA": reflect.ValueOf(tls.TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA),
"TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA": reflect.ValueOf(tls.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA),
"TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256": reflect.ValueOf(tls.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256),
"TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256": reflect.ValueOf(tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256),
"TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA": reflect.ValueOf(tls.TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA),
"TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384": reflect.ValueOf(tls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384),
"TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305": reflect.ValueOf(tls.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305),
"TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256": reflect.ValueOf(tls.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256),
"TLS_ECDHE_RSA_WITH_RC4_128_SHA": reflect.ValueOf(tls.TLS_ECDHE_RSA_WITH_RC4_128_SHA),
"TLS_FALLBACK_SCSV": reflect.ValueOf(tls.TLS_FALLBACK_SCSV),
"TLS_RSA_WITH_3DES_EDE_CBC_SHA": reflect.ValueOf(tls.TLS_RSA_WITH_3DES_EDE_CBC_SHA),
"TLS_RSA_WITH_AES_128_CBC_SHA": reflect.ValueOf(tls.TLS_RSA_WITH_AES_128_CBC_SHA),
"TLS_RSA_WITH_AES_128_CBC_SHA256": reflect.ValueOf(tls.TLS_RSA_WITH_AES_128_CBC_SHA256),
"TLS_RSA_WITH_AES_128_GCM_SHA256": reflect.ValueOf(tls.TLS_RSA_WITH_AES_128_GCM_SHA256),
"TLS_RSA_WITH_AES_256_CBC_SHA": reflect.ValueOf(tls.TLS_RSA_WITH_AES_256_CBC_SHA),
"TLS_RSA_WITH_AES_256_GCM_SHA384": reflect.ValueOf(tls.TLS_RSA_WITH_AES_256_GCM_SHA384),
"TLS_RSA_WITH_RC4_128_SHA": reflect.ValueOf(tls.TLS_RSA_WITH_RC4_128_SHA),
"VerifyClientCertIfGiven": reflect.ValueOf(tls.VerifyClientCertIfGiven),
"VersionName": reflect.ValueOf(tls.VersionName),
"VersionSSL30": reflect.ValueOf(constant.MakeFromLiteral("768", token.INT, 0)),
"VersionTLS10": reflect.ValueOf(constant.MakeFromLiteral("769", token.INT, 0)),
"VersionTLS11": reflect.ValueOf(constant.MakeFromLiteral("770", token.INT, 0)),
"VersionTLS12": reflect.ValueOf(constant.MakeFromLiteral("771", token.INT, 0)),
"VersionTLS13": reflect.ValueOf(constant.MakeFromLiteral("772", token.INT, 0)),
"X25519": reflect.ValueOf(tls.X25519),
"X509KeyPair": reflect.ValueOf(tls.X509KeyPair),
// type definitions
"AlertError": reflect.ValueOf((*tls.AlertError)(nil)),
"Certificate": reflect.ValueOf((*tls.Certificate)(nil)),
"CertificateRequestInfo": reflect.ValueOf((*tls.CertificateRequestInfo)(nil)),
"CertificateVerificationError": reflect.ValueOf((*tls.CertificateVerificationError)(nil)),
"CipherSuite": reflect.ValueOf((*tls.CipherSuite)(nil)),
"ClientAuthType": reflect.ValueOf((*tls.ClientAuthType)(nil)),
"ClientHelloInfo": reflect.ValueOf((*tls.ClientHelloInfo)(nil)),
"ClientSessionCache": reflect.ValueOf((*tls.ClientSessionCache)(nil)),
"ClientSessionState": reflect.ValueOf((*tls.ClientSessionState)(nil)),
"Config": reflect.ValueOf((*tls.Config)(nil)),
"Conn": reflect.ValueOf((*tls.Conn)(nil)),
"ConnectionState": reflect.ValueOf((*tls.ConnectionState)(nil)),
"CurveID": reflect.ValueOf((*tls.CurveID)(nil)),
"Dialer": reflect.ValueOf((*tls.Dialer)(nil)),
"QUICConfig": reflect.ValueOf((*tls.QUICConfig)(nil)),
"QUICConn": reflect.ValueOf((*tls.QUICConn)(nil)),
"QUICEncryptionLevel": reflect.ValueOf((*tls.QUICEncryptionLevel)(nil)),
"QUICEvent": reflect.ValueOf((*tls.QUICEvent)(nil)),
"QUICEventKind": reflect.ValueOf((*tls.QUICEventKind)(nil)),
"QUICSessionTicketOptions": reflect.ValueOf((*tls.QUICSessionTicketOptions)(nil)),
"RecordHeaderError": reflect.ValueOf((*tls.RecordHeaderError)(nil)),
"RenegotiationSupport": reflect.ValueOf((*tls.RenegotiationSupport)(nil)),
"SessionState": reflect.ValueOf((*tls.SessionState)(nil)),
"SignatureScheme": reflect.ValueOf((*tls.SignatureScheme)(nil)),
// interface wrapper definitions
"_ClientSessionCache": reflect.ValueOf((*_crypto_tls_ClientSessionCache)(nil)),
}
}
// _crypto_tls_ClientSessionCache is an interface wrapper for ClientSessionCache type
type _crypto_tls_ClientSessionCache struct {
IValue interface{}
WGet func(sessionKey string) (session *tls.ClientSessionState, ok bool)
WPut func(sessionKey string, cs *tls.ClientSessionState)
}
func (W _crypto_tls_ClientSessionCache) Get(sessionKey string) (session *tls.ClientSessionState, ok bool) {
return W.WGet(sessionKey)
}
func (W _crypto_tls_ClientSessionCache) Put(sessionKey string, cs *tls.ClientSessionState) {
W.WPut(sessionKey, cs)
}
================================================
FILE: stdlib/go1_21_crypto_x509.go
================================================
// Code generated by 'yaegi extract crypto/x509'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"crypto/x509"
"reflect"
)
func init() {
Symbols["crypto/x509/x509"] = map[string]reflect.Value{
// function, constant and variable definitions
"CANotAuthorizedForExtKeyUsage": reflect.ValueOf(x509.CANotAuthorizedForExtKeyUsage),
"CANotAuthorizedForThisName": reflect.ValueOf(x509.CANotAuthorizedForThisName),
"CreateCertificate": reflect.ValueOf(x509.CreateCertificate),
"CreateCertificateRequest": reflect.ValueOf(x509.CreateCertificateRequest),
"CreateRevocationList": reflect.ValueOf(x509.CreateRevocationList),
"DSA": reflect.ValueOf(x509.DSA),
"DSAWithSHA1": reflect.ValueOf(x509.DSAWithSHA1),
"DSAWithSHA256": reflect.ValueOf(x509.DSAWithSHA256),
"DecryptPEMBlock": reflect.ValueOf(x509.DecryptPEMBlock),
"ECDSA": reflect.ValueOf(x509.ECDSA),
"ECDSAWithSHA1": reflect.ValueOf(x509.ECDSAWithSHA1),
"ECDSAWithSHA256": reflect.ValueOf(x509.ECDSAWithSHA256),
"ECDSAWithSHA384": reflect.ValueOf(x509.ECDSAWithSHA384),
"ECDSAWithSHA512": reflect.ValueOf(x509.ECDSAWithSHA512),
"Ed25519": reflect.ValueOf(x509.Ed25519),
"EncryptPEMBlock": reflect.ValueOf(x509.EncryptPEMBlock),
"ErrUnsupportedAlgorithm": reflect.ValueOf(&x509.ErrUnsupportedAlgorithm).Elem(),
"Expired": reflect.ValueOf(x509.Expired),
"ExtKeyUsageAny": reflect.ValueOf(x509.ExtKeyUsageAny),
"ExtKeyUsageClientAuth": reflect.ValueOf(x509.ExtKeyUsageClientAuth),
"ExtKeyUsageCodeSigning": reflect.ValueOf(x509.ExtKeyUsageCodeSigning),
"ExtKeyUsageEmailProtection": reflect.ValueOf(x509.ExtKeyUsageEmailProtection),
"ExtKeyUsageIPSECEndSystem": reflect.ValueOf(x509.ExtKeyUsageIPSECEndSystem),
"ExtKeyUsageIPSECTunnel": reflect.ValueOf(x509.ExtKeyUsageIPSECTunnel),
"ExtKeyUsageIPSECUser": reflect.ValueOf(x509.ExtKeyUsageIPSECUser),
"ExtKeyUsageMicrosoftCommercialCodeSigning": reflect.ValueOf(x509.ExtKeyUsageMicrosoftCommercialCodeSigning),
"ExtKeyUsageMicrosoftKernelCodeSigning": reflect.ValueOf(x509.ExtKeyUsageMicrosoftKernelCodeSigning),
"ExtKeyUsageMicrosoftServerGatedCrypto": reflect.ValueOf(x509.ExtKeyUsageMicrosoftServerGatedCrypto),
"ExtKeyUsageNetscapeServerGatedCrypto": reflect.ValueOf(x509.ExtKeyUsageNetscapeServerGatedCrypto),
"ExtKeyUsageOCSPSigning": reflect.ValueOf(x509.ExtKeyUsageOCSPSigning),
"ExtKeyUsageServerAuth": reflect.ValueOf(x509.ExtKeyUsageServerAuth),
"ExtKeyUsageTimeStamping": reflect.ValueOf(x509.ExtKeyUsageTimeStamping),
"IncompatibleUsage": reflect.ValueOf(x509.IncompatibleUsage),
"IncorrectPasswordError": reflect.ValueOf(&x509.IncorrectPasswordError).Elem(),
"IsEncryptedPEMBlock": reflect.ValueOf(x509.IsEncryptedPEMBlock),
"KeyUsageCRLSign": reflect.ValueOf(x509.KeyUsageCRLSign),
"KeyUsageCertSign": reflect.ValueOf(x509.KeyUsageCertSign),
"KeyUsageContentCommitment": reflect.ValueOf(x509.KeyUsageContentCommitment),
"KeyUsageDataEncipherment": reflect.ValueOf(x509.KeyUsageDataEncipherment),
"KeyUsageDecipherOnly": reflect.ValueOf(x509.KeyUsageDecipherOnly),
"KeyUsageDigitalSignature": reflect.ValueOf(x509.KeyUsageDigitalSignature),
"KeyUsageEncipherOnly": reflect.ValueOf(x509.KeyUsageEncipherOnly),
"KeyUsageKeyAgreement": reflect.ValueOf(x509.KeyUsageKeyAgreement),
"KeyUsageKeyEncipherment": reflect.ValueOf(x509.KeyUsageKeyEncipherment),
"MD2WithRSA": reflect.ValueOf(x509.MD2WithRSA),
"MD5WithRSA": reflect.ValueOf(x509.MD5WithRSA),
"MarshalECPrivateKey": reflect.ValueOf(x509.MarshalECPrivateKey),
"MarshalPKCS1PrivateKey": reflect.ValueOf(x509.MarshalPKCS1PrivateKey),
"MarshalPKCS1PublicKey": reflect.ValueOf(x509.MarshalPKCS1PublicKey),
"MarshalPKCS8PrivateKey": reflect.ValueOf(x509.MarshalPKCS8PrivateKey),
"MarshalPKIXPublicKey": reflect.ValueOf(x509.MarshalPKIXPublicKey),
"NameConstraintsWithoutSANs": reflect.ValueOf(x509.NameConstraintsWithoutSANs),
"NameMismatch": reflect.ValueOf(x509.NameMismatch),
"NewCertPool": reflect.ValueOf(x509.NewCertPool),
"NotAuthorizedToSign": reflect.ValueOf(x509.NotAuthorizedToSign),
"PEMCipher3DES": reflect.ValueOf(x509.PEMCipher3DES),
"PEMCipherAES128": reflect.ValueOf(x509.PEMCipherAES128),
"PEMCipherAES192": reflect.ValueOf(x509.PEMCipherAES192),
"PEMCipherAES256": reflect.ValueOf(x509.PEMCipherAES256),
"PEMCipherDES": reflect.ValueOf(x509.PEMCipherDES),
"ParseCRL": reflect.ValueOf(x509.ParseCRL),
"ParseCertificate": reflect.ValueOf(x509.ParseCertificate),
"ParseCertificateRequest": reflect.ValueOf(x509.ParseCertificateRequest),
"ParseCertificates": reflect.ValueOf(x509.ParseCertificates),
"ParseDERCRL": reflect.ValueOf(x509.ParseDERCRL),
"ParseECPrivateKey": reflect.ValueOf(x509.ParseECPrivateKey),
"ParsePKCS1PrivateKey": reflect.ValueOf(x509.ParsePKCS1PrivateKey),
"ParsePKCS1PublicKey": reflect.ValueOf(x509.ParsePKCS1PublicKey),
"ParsePKCS8PrivateKey": reflect.ValueOf(x509.ParsePKCS8PrivateKey),
"ParsePKIXPublicKey": reflect.ValueOf(x509.ParsePKIXPublicKey),
"ParseRevocationList": reflect.ValueOf(x509.ParseRevocationList),
"PureEd25519": reflect.ValueOf(x509.PureEd25519),
"RSA": reflect.ValueOf(x509.RSA),
"SHA1WithRSA": reflect.ValueOf(x509.SHA1WithRSA),
"SHA256WithRSA": reflect.ValueOf(x509.SHA256WithRSA),
"SHA256WithRSAPSS": reflect.ValueOf(x509.SHA256WithRSAPSS),
"SHA384WithRSA": reflect.ValueOf(x509.SHA384WithRSA),
"SHA384WithRSAPSS": reflect.ValueOf(x509.SHA384WithRSAPSS),
"SHA512WithRSA": reflect.ValueOf(x509.SHA512WithRSA),
"SHA512WithRSAPSS": reflect.ValueOf(x509.SHA512WithRSAPSS),
"SetFallbackRoots": reflect.ValueOf(x509.SetFallbackRoots),
"SystemCertPool": reflect.ValueOf(x509.SystemCertPool),
"TooManyConstraints": reflect.ValueOf(x509.TooManyConstraints),
"TooManyIntermediates": reflect.ValueOf(x509.TooManyIntermediates),
"UnconstrainedName": reflect.ValueOf(x509.UnconstrainedName),
"UnknownPublicKeyAlgorithm": reflect.ValueOf(x509.UnknownPublicKeyAlgorithm),
"UnknownSignatureAlgorithm": reflect.ValueOf(x509.UnknownSignatureAlgorithm),
// type definitions
"CertPool": reflect.ValueOf((*x509.CertPool)(nil)),
"Certificate": reflect.ValueOf((*x509.Certificate)(nil)),
"CertificateInvalidError": reflect.ValueOf((*x509.CertificateInvalidError)(nil)),
"CertificateRequest": reflect.ValueOf((*x509.CertificateRequest)(nil)),
"ConstraintViolationError": reflect.ValueOf((*x509.ConstraintViolationError)(nil)),
"ExtKeyUsage": reflect.ValueOf((*x509.ExtKeyUsage)(nil)),
"HostnameError": reflect.ValueOf((*x509.HostnameError)(nil)),
"InsecureAlgorithmError": reflect.ValueOf((*x509.InsecureAlgorithmError)(nil)),
"InvalidReason": reflect.ValueOf((*x509.InvalidReason)(nil)),
"KeyUsage": reflect.ValueOf((*x509.KeyUsage)(nil)),
"PEMCipher": reflect.ValueOf((*x509.PEMCipher)(nil)),
"PublicKeyAlgorithm": reflect.ValueOf((*x509.PublicKeyAlgorithm)(nil)),
"RevocationList": reflect.ValueOf((*x509.RevocationList)(nil)),
"RevocationListEntry": reflect.ValueOf((*x509.RevocationListEntry)(nil)),
"SignatureAlgorithm": reflect.ValueOf((*x509.SignatureAlgorithm)(nil)),
"SystemRootsError": reflect.ValueOf((*x509.SystemRootsError)(nil)),
"UnhandledCriticalExtension": reflect.ValueOf((*x509.UnhandledCriticalExtension)(nil)),
"UnknownAuthorityError": reflect.ValueOf((*x509.UnknownAuthorityError)(nil)),
"VerifyOptions": reflect.ValueOf((*x509.VerifyOptions)(nil)),
}
}
================================================
FILE: stdlib/go1_21_crypto_x509_pkix.go
================================================
// Code generated by 'yaegi extract crypto/x509/pkix'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"crypto/x509/pkix"
"reflect"
)
func init() {
Symbols["crypto/x509/pkix/pkix"] = map[string]reflect.Value{
// type definitions
"AlgorithmIdentifier": reflect.ValueOf((*pkix.AlgorithmIdentifier)(nil)),
"AttributeTypeAndValue": reflect.ValueOf((*pkix.AttributeTypeAndValue)(nil)),
"AttributeTypeAndValueSET": reflect.ValueOf((*pkix.AttributeTypeAndValueSET)(nil)),
"CertificateList": reflect.ValueOf((*pkix.CertificateList)(nil)),
"Extension": reflect.ValueOf((*pkix.Extension)(nil)),
"Name": reflect.ValueOf((*pkix.Name)(nil)),
"RDNSequence": reflect.ValueOf((*pkix.RDNSequence)(nil)),
"RelativeDistinguishedNameSET": reflect.ValueOf((*pkix.RelativeDistinguishedNameSET)(nil)),
"RevokedCertificate": reflect.ValueOf((*pkix.RevokedCertificate)(nil)),
"TBSCertificateList": reflect.ValueOf((*pkix.TBSCertificateList)(nil)),
}
}
================================================
FILE: stdlib/go1_21_database_sql.go
================================================
// Code generated by 'yaegi extract database/sql'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"database/sql"
"reflect"
)
func init() {
Symbols["database/sql/sql"] = map[string]reflect.Value{
// function, constant and variable definitions
"Drivers": reflect.ValueOf(sql.Drivers),
"ErrConnDone": reflect.ValueOf(&sql.ErrConnDone).Elem(),
"ErrNoRows": reflect.ValueOf(&sql.ErrNoRows).Elem(),
"ErrTxDone": reflect.ValueOf(&sql.ErrTxDone).Elem(),
"LevelDefault": reflect.ValueOf(sql.LevelDefault),
"LevelLinearizable": reflect.ValueOf(sql.LevelLinearizable),
"LevelReadCommitted": reflect.ValueOf(sql.LevelReadCommitted),
"LevelReadUncommitted": reflect.ValueOf(sql.LevelReadUncommitted),
"LevelRepeatableRead": reflect.ValueOf(sql.LevelRepeatableRead),
"LevelSerializable": reflect.ValueOf(sql.LevelSerializable),
"LevelSnapshot": reflect.ValueOf(sql.LevelSnapshot),
"LevelWriteCommitted": reflect.ValueOf(sql.LevelWriteCommitted),
"Named": reflect.ValueOf(sql.Named),
"Open": reflect.ValueOf(sql.Open),
"OpenDB": reflect.ValueOf(sql.OpenDB),
"Register": reflect.ValueOf(sql.Register),
// type definitions
"ColumnType": reflect.ValueOf((*sql.ColumnType)(nil)),
"Conn": reflect.ValueOf((*sql.Conn)(nil)),
"DB": reflect.ValueOf((*sql.DB)(nil)),
"DBStats": reflect.ValueOf((*sql.DBStats)(nil)),
"IsolationLevel": reflect.ValueOf((*sql.IsolationLevel)(nil)),
"NamedArg": reflect.ValueOf((*sql.NamedArg)(nil)),
"NullBool": reflect.ValueOf((*sql.NullBool)(nil)),
"NullByte": reflect.ValueOf((*sql.NullByte)(nil)),
"NullFloat64": reflect.ValueOf((*sql.NullFloat64)(nil)),
"NullInt16": reflect.ValueOf((*sql.NullInt16)(nil)),
"NullInt32": reflect.ValueOf((*sql.NullInt32)(nil)),
"NullInt64": reflect.ValueOf((*sql.NullInt64)(nil)),
"NullString": reflect.ValueOf((*sql.NullString)(nil)),
"NullTime": reflect.ValueOf((*sql.NullTime)(nil)),
"Out": reflect.ValueOf((*sql.Out)(nil)),
"RawBytes": reflect.ValueOf((*sql.RawBytes)(nil)),
"Result": reflect.ValueOf((*sql.Result)(nil)),
"Row": reflect.ValueOf((*sql.Row)(nil)),
"Rows": reflect.ValueOf((*sql.Rows)(nil)),
"Scanner": reflect.ValueOf((*sql.Scanner)(nil)),
"Stmt": reflect.ValueOf((*sql.Stmt)(nil)),
"Tx": reflect.ValueOf((*sql.Tx)(nil)),
"TxOptions": reflect.ValueOf((*sql.TxOptions)(nil)),
// interface wrapper definitions
"_Result": reflect.ValueOf((*_database_sql_Result)(nil)),
"_Scanner": reflect.ValueOf((*_database_sql_Scanner)(nil)),
}
}
// _database_sql_Result is an interface wrapper for Result type
type _database_sql_Result struct {
IValue interface{}
WLastInsertId func() (int64, error)
WRowsAffected func() (int64, error)
}
func (W _database_sql_Result) LastInsertId() (int64, error) { return W.WLastInsertId() }
func (W _database_sql_Result) RowsAffected() (int64, error) { return W.WRowsAffected() }
// _database_sql_Scanner is an interface wrapper for Scanner type
type _database_sql_Scanner struct {
IValue interface{}
WScan func(src any) error
}
func (W _database_sql_Scanner) Scan(src any) error { return W.WScan(src) }
================================================
FILE: stdlib/go1_21_database_sql_driver.go
================================================
// Code generated by 'yaegi extract database/sql/driver'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"context"
"database/sql/driver"
"reflect"
)
func init() {
Symbols["database/sql/driver/driver"] = map[string]reflect.Value{
// function, constant and variable definitions
"Bool": reflect.ValueOf(&driver.Bool).Elem(),
"DefaultParameterConverter": reflect.ValueOf(&driver.DefaultParameterConverter).Elem(),
"ErrBadConn": reflect.ValueOf(&driver.ErrBadConn).Elem(),
"ErrRemoveArgument": reflect.ValueOf(&driver.ErrRemoveArgument).Elem(),
"ErrSkip": reflect.ValueOf(&driver.ErrSkip).Elem(),
"Int32": reflect.ValueOf(&driver.Int32).Elem(),
"IsScanValue": reflect.ValueOf(driver.IsScanValue),
"IsValue": reflect.ValueOf(driver.IsValue),
"ResultNoRows": reflect.ValueOf(&driver.ResultNoRows).Elem(),
"String": reflect.ValueOf(&driver.String).Elem(),
// type definitions
"ColumnConverter": reflect.ValueOf((*driver.ColumnConverter)(nil)),
"Conn": reflect.ValueOf((*driver.Conn)(nil)),
"ConnBeginTx": reflect.ValueOf((*driver.ConnBeginTx)(nil)),
"ConnPrepareContext": reflect.ValueOf((*driver.ConnPrepareContext)(nil)),
"Connector": reflect.ValueOf((*driver.Connector)(nil)),
"Driver": reflect.ValueOf((*driver.Driver)(nil)),
"DriverContext": reflect.ValueOf((*driver.DriverContext)(nil)),
"Execer": reflect.ValueOf((*driver.Execer)(nil)),
"ExecerContext": reflect.ValueOf((*driver.ExecerContext)(nil)),
"IsolationLevel": reflect.ValueOf((*driver.IsolationLevel)(nil)),
"NamedValue": reflect.ValueOf((*driver.NamedValue)(nil)),
"NamedValueChecker": reflect.ValueOf((*driver.NamedValueChecker)(nil)),
"NotNull": reflect.ValueOf((*driver.NotNull)(nil)),
"Null": reflect.ValueOf((*driver.Null)(nil)),
"Pinger": reflect.ValueOf((*driver.Pinger)(nil)),
"Queryer": reflect.ValueOf((*driver.Queryer)(nil)),
"QueryerContext": reflect.ValueOf((*driver.QueryerContext)(nil)),
"Result": reflect.ValueOf((*driver.Result)(nil)),
"Rows": reflect.ValueOf((*driver.Rows)(nil)),
"RowsAffected": reflect.ValueOf((*driver.RowsAffected)(nil)),
"RowsColumnTypeDatabaseTypeName": reflect.ValueOf((*driver.RowsColumnTypeDatabaseTypeName)(nil)),
"RowsColumnTypeLength": reflect.ValueOf((*driver.RowsColumnTypeLength)(nil)),
"RowsColumnTypeNullable": reflect.ValueOf((*driver.RowsColumnTypeNullable)(nil)),
"RowsColumnTypePrecisionScale": reflect.ValueOf((*driver.RowsColumnTypePrecisionScale)(nil)),
"RowsColumnTypeScanType": reflect.ValueOf((*driver.RowsColumnTypeScanType)(nil)),
"RowsNextResultSet": reflect.ValueOf((*driver.RowsNextResultSet)(nil)),
"SessionResetter": reflect.ValueOf((*driver.SessionResetter)(nil)),
"Stmt": reflect.ValueOf((*driver.Stmt)(nil)),
"StmtExecContext": reflect.ValueOf((*driver.StmtExecContext)(nil)),
"StmtQueryContext": reflect.ValueOf((*driver.StmtQueryContext)(nil)),
"Tx": reflect.ValueOf((*driver.Tx)(nil)),
"TxOptions": reflect.ValueOf((*driver.TxOptions)(nil)),
"Validator": reflect.ValueOf((*driver.Validator)(nil)),
"Value": reflect.ValueOf((*driver.Value)(nil)),
"ValueConverter": reflect.ValueOf((*driver.ValueConverter)(nil)),
"Valuer": reflect.ValueOf((*driver.Valuer)(nil)),
// interface wrapper definitions
"_ColumnConverter": reflect.ValueOf((*_database_sql_driver_ColumnConverter)(nil)),
"_Conn": reflect.ValueOf((*_database_sql_driver_Conn)(nil)),
"_ConnBeginTx": reflect.ValueOf((*_database_sql_driver_ConnBeginTx)(nil)),
"_ConnPrepareContext": reflect.ValueOf((*_database_sql_driver_ConnPrepareContext)(nil)),
"_Connector": reflect.ValueOf((*_database_sql_driver_Connector)(nil)),
"_Driver": reflect.ValueOf((*_database_sql_driver_Driver)(nil)),
"_DriverContext": reflect.ValueOf((*_database_sql_driver_DriverContext)(nil)),
"_Execer": reflect.ValueOf((*_database_sql_driver_Execer)(nil)),
"_ExecerContext": reflect.ValueOf((*_database_sql_driver_ExecerContext)(nil)),
"_NamedValueChecker": reflect.ValueOf((*_database_sql_driver_NamedValueChecker)(nil)),
"_Pinger": reflect.ValueOf((*_database_sql_driver_Pinger)(nil)),
"_Queryer": reflect.ValueOf((*_database_sql_driver_Queryer)(nil)),
"_QueryerContext": reflect.ValueOf((*_database_sql_driver_QueryerContext)(nil)),
"_Result": reflect.ValueOf((*_database_sql_driver_Result)(nil)),
"_Rows": reflect.ValueOf((*_database_sql_driver_Rows)(nil)),
"_RowsColumnTypeDatabaseTypeName": reflect.ValueOf((*_database_sql_driver_RowsColumnTypeDatabaseTypeName)(nil)),
"_RowsColumnTypeLength": reflect.ValueOf((*_database_sql_driver_RowsColumnTypeLength)(nil)),
"_RowsColumnTypeNullable": reflect.ValueOf((*_database_sql_driver_RowsColumnTypeNullable)(nil)),
"_RowsColumnTypePrecisionScale": reflect.ValueOf((*_database_sql_driver_RowsColumnTypePrecisionScale)(nil)),
"_RowsColumnTypeScanType": reflect.ValueOf((*_database_sql_driver_RowsColumnTypeScanType)(nil)),
"_RowsNextResultSet": reflect.ValueOf((*_database_sql_driver_RowsNextResultSet)(nil)),
"_SessionResetter": reflect.ValueOf((*_database_sql_driver_SessionResetter)(nil)),
"_Stmt": reflect.ValueOf((*_database_sql_driver_Stmt)(nil)),
"_StmtExecContext": reflect.ValueOf((*_database_sql_driver_StmtExecContext)(nil)),
"_StmtQueryContext": reflect.ValueOf((*_database_sql_driver_StmtQueryContext)(nil)),
"_Tx": reflect.ValueOf((*_database_sql_driver_Tx)(nil)),
"_Validator": reflect.ValueOf((*_database_sql_driver_Validator)(nil)),
"_Value": reflect.ValueOf((*_database_sql_driver_Value)(nil)),
"_ValueConverter": reflect.ValueOf((*_database_sql_driver_ValueConverter)(nil)),
"_Valuer": reflect.ValueOf((*_database_sql_driver_Valuer)(nil)),
}
}
// _database_sql_driver_ColumnConverter is an interface wrapper for ColumnConverter type
type _database_sql_driver_ColumnConverter struct {
IValue interface{}
WColumnConverter func(idx int) driver.ValueConverter
}
func (W _database_sql_driver_ColumnConverter) ColumnConverter(idx int) driver.ValueConverter {
return W.WColumnConverter(idx)
}
// _database_sql_driver_Conn is an interface wrapper for Conn type
type _database_sql_driver_Conn struct {
IValue interface{}
WBegin func() (driver.Tx, error)
WClose func() error
WPrepare func(query string) (driver.Stmt, error)
}
func (W _database_sql_driver_Conn) Begin() (driver.Tx, error) { return W.WBegin() }
func (W _database_sql_driver_Conn) Close() error { return W.WClose() }
func (W _database_sql_driver_Conn) Prepare(query string) (driver.Stmt, error) {
return W.WPrepare(query)
}
// _database_sql_driver_ConnBeginTx is an interface wrapper for ConnBeginTx type
type _database_sql_driver_ConnBeginTx struct {
IValue interface{}
WBeginTx func(ctx context.Context, opts driver.TxOptions) (driver.Tx, error)
}
func (W _database_sql_driver_ConnBeginTx) BeginTx(ctx context.Context, opts driver.TxOptions) (driver.Tx, error) {
return W.WBeginTx(ctx, opts)
}
// _database_sql_driver_ConnPrepareContext is an interface wrapper for ConnPrepareContext type
type _database_sql_driver_ConnPrepareContext struct {
IValue interface{}
WPrepareContext func(ctx context.Context, query string) (driver.Stmt, error)
}
func (W _database_sql_driver_ConnPrepareContext) PrepareContext(ctx context.Context, query string) (driver.Stmt, error) {
return W.WPrepareContext(ctx, query)
}
// _database_sql_driver_Connector is an interface wrapper for Connector type
type _database_sql_driver_Connector struct {
IValue interface{}
WConnect func(a0 context.Context) (driver.Conn, error)
WDriver func() driver.Driver
}
func (W _database_sql_driver_Connector) Connect(a0 context.Context) (driver.Conn, error) {
return W.WConnect(a0)
}
func (W _database_sql_driver_Connector) Driver() driver.Driver { return W.WDriver() }
// _database_sql_driver_Driver is an interface wrapper for Driver type
type _database_sql_driver_Driver struct {
IValue interface{}
WOpen func(name string) (driver.Conn, error)
}
func (W _database_sql_driver_Driver) Open(name string) (driver.Conn, error) { return W.WOpen(name) }
// _database_sql_driver_DriverContext is an interface wrapper for DriverContext type
type _database_sql_driver_DriverContext struct {
IValue interface{}
WOpenConnector func(name string) (driver.Connector, error)
}
func (W _database_sql_driver_DriverContext) OpenConnector(name string) (driver.Connector, error) {
return W.WOpenConnector(name)
}
// _database_sql_driver_Execer is an interface wrapper for Execer type
type _database_sql_driver_Execer struct {
IValue interface{}
WExec func(query string, args []driver.Value) (driver.Result, error)
}
func (W _database_sql_driver_Execer) Exec(query string, args []driver.Value) (driver.Result, error) {
return W.WExec(query, args)
}
// _database_sql_driver_ExecerContext is an interface wrapper for ExecerContext type
type _database_sql_driver_ExecerContext struct {
IValue interface{}
WExecContext func(ctx context.Context, query string, args []driver.NamedValue) (driver.Result, error)
}
func (W _database_sql_driver_ExecerContext) ExecContext(ctx context.Context, query string, args []driver.NamedValue) (driver.Result, error) {
return W.WExecContext(ctx, query, args)
}
// _database_sql_driver_NamedValueChecker is an interface wrapper for NamedValueChecker type
type _database_sql_driver_NamedValueChecker struct {
IValue interface{}
WCheckNamedValue func(a0 *driver.NamedValue) error
}
func (W _database_sql_driver_NamedValueChecker) CheckNamedValue(a0 *driver.NamedValue) error {
return W.WCheckNamedValue(a0)
}
// _database_sql_driver_Pinger is an interface wrapper for Pinger type
type _database_sql_driver_Pinger struct {
IValue interface{}
WPing func(ctx context.Context) error
}
func (W _database_sql_driver_Pinger) Ping(ctx context.Context) error { return W.WPing(ctx) }
// _database_sql_driver_Queryer is an interface wrapper for Queryer type
type _database_sql_driver_Queryer struct {
IValue interface{}
WQuery func(query string, args []driver.Value) (driver.Rows, error)
}
func (W _database_sql_driver_Queryer) Query(query string, args []driver.Value) (driver.Rows, error) {
return W.WQuery(query, args)
}
// _database_sql_driver_QueryerContext is an interface wrapper for QueryerContext type
type _database_sql_driver_QueryerContext struct {
IValue interface{}
WQueryContext func(ctx context.Context, query string, args []driver.NamedValue) (driver.Rows, error)
}
func (W _database_sql_driver_QueryerContext) QueryContext(ctx context.Context, query string, args []driver.NamedValue) (driver.Rows, error) {
return W.WQueryContext(ctx, query, args)
}
// _database_sql_driver_Result is an interface wrapper for Result type
type _database_sql_driver_Result struct {
IValue interface{}
WLastInsertId func() (int64, error)
WRowsAffected func() (int64, error)
}
func (W _database_sql_driver_Result) LastInsertId() (int64, error) { return W.WLastInsertId() }
func (W _database_sql_driver_Result) RowsAffected() (int64, error) { return W.WRowsAffected() }
// _database_sql_driver_Rows is an interface wrapper for Rows type
type _database_sql_driver_Rows struct {
IValue interface{}
WClose func() error
WColumns func() []string
WNext func(dest []driver.Value) error
}
func (W _database_sql_driver_Rows) Close() error { return W.WClose() }
func (W _database_sql_driver_Rows) Columns() []string { return W.WColumns() }
func (W _database_sql_driver_Rows) Next(dest []driver.Value) error { return W.WNext(dest) }
// _database_sql_driver_RowsColumnTypeDatabaseTypeName is an interface wrapper for RowsColumnTypeDatabaseTypeName type
type _database_sql_driver_RowsColumnTypeDatabaseTypeName struct {
IValue interface{}
WClose func() error
WColumnTypeDatabaseTypeName func(index int) string
WColumns func() []string
WNext func(dest []driver.Value) error
}
func (W _database_sql_driver_RowsColumnTypeDatabaseTypeName) Close() error { return W.WClose() }
func (W _database_sql_driver_RowsColumnTypeDatabaseTypeName) ColumnTypeDatabaseTypeName(index int) string {
return W.WColumnTypeDatabaseTypeName(index)
}
func (W _database_sql_driver_RowsColumnTypeDatabaseTypeName) Columns() []string { return W.WColumns() }
func (W _database_sql_driver_RowsColumnTypeDatabaseTypeName) Next(dest []driver.Value) error {
return W.WNext(dest)
}
// _database_sql_driver_RowsColumnTypeLength is an interface wrapper for RowsColumnTypeLength type
type _database_sql_driver_RowsColumnTypeLength struct {
IValue interface{}
WClose func() error
WColumnTypeLength func(index int) (length int64, ok bool)
WColumns func() []string
WNext func(dest []driver.Value) error
}
func (W _database_sql_driver_RowsColumnTypeLength) Close() error { return W.WClose() }
func (W _database_sql_driver_RowsColumnTypeLength) ColumnTypeLength(index int) (length int64, ok bool) {
return W.WColumnTypeLength(index)
}
func (W _database_sql_driver_RowsColumnTypeLength) Columns() []string { return W.WColumns() }
func (W _database_sql_driver_RowsColumnTypeLength) Next(dest []driver.Value) error {
return W.WNext(dest)
}
// _database_sql_driver_RowsColumnTypeNullable is an interface wrapper for RowsColumnTypeNullable type
type _database_sql_driver_RowsColumnTypeNullable struct {
IValue interface{}
WClose func() error
WColumnTypeNullable func(index int) (nullable bool, ok bool)
WColumns func() []string
WNext func(dest []driver.Value) error
}
func (W _database_sql_driver_RowsColumnTypeNullable) Close() error { return W.WClose() }
func (W _database_sql_driver_RowsColumnTypeNullable) ColumnTypeNullable(index int) (nullable bool, ok bool) {
return W.WColumnTypeNullable(index)
}
func (W _database_sql_driver_RowsColumnTypeNullable) Columns() []string { return W.WColumns() }
func (W _database_sql_driver_RowsColumnTypeNullable) Next(dest []driver.Value) error {
return W.WNext(dest)
}
// _database_sql_driver_RowsColumnTypePrecisionScale is an interface wrapper for RowsColumnTypePrecisionScale type
type _database_sql_driver_RowsColumnTypePrecisionScale struct {
IValue interface{}
WClose func() error
WColumnTypePrecisionScale func(index int) (precision int64, scale int64, ok bool)
WColumns func() []string
WNext func(dest []driver.Value) error
}
func (W _database_sql_driver_RowsColumnTypePrecisionScale) Close() error { return W.WClose() }
func (W _database_sql_driver_RowsColumnTypePrecisionScale) ColumnTypePrecisionScale(index int) (precision int64, scale int64, ok bool) {
return W.WColumnTypePrecisionScale(index)
}
func (W _database_sql_driver_RowsColumnTypePrecisionScale) Columns() []string { return W.WColumns() }
func (W _database_sql_driver_RowsColumnTypePrecisionScale) Next(dest []driver.Value) error {
return W.WNext(dest)
}
// _database_sql_driver_RowsColumnTypeScanType is an interface wrapper for RowsColumnTypeScanType type
type _database_sql_driver_RowsColumnTypeScanType struct {
IValue interface{}
WClose func() error
WColumnTypeScanType func(index int) reflect.Type
WColumns func() []string
WNext func(dest []driver.Value) error
}
func (W _database_sql_driver_RowsColumnTypeScanType) Close() error { return W.WClose() }
func (W _database_sql_driver_RowsColumnTypeScanType) ColumnTypeScanType(index int) reflect.Type {
return W.WColumnTypeScanType(index)
}
func (W _database_sql_driver_RowsColumnTypeScanType) Columns() []string { return W.WColumns() }
func (W _database_sql_driver_RowsColumnTypeScanType) Next(dest []driver.Value) error {
return W.WNext(dest)
}
// _database_sql_driver_RowsNextResultSet is an interface wrapper for RowsNextResultSet type
type _database_sql_driver_RowsNextResultSet struct {
IValue interface{}
WClose func() error
WColumns func() []string
WHasNextResultSet func() bool
WNext func(dest []driver.Value) error
WNextResultSet func() error
}
func (W _database_sql_driver_RowsNextResultSet) Close() error { return W.WClose() }
func (W _database_sql_driver_RowsNextResultSet) Columns() []string { return W.WColumns() }
func (W _database_sql_driver_RowsNextResultSet) HasNextResultSet() bool { return W.WHasNextResultSet() }
func (W _database_sql_driver_RowsNextResultSet) Next(dest []driver.Value) error { return W.WNext(dest) }
func (W _database_sql_driver_RowsNextResultSet) NextResultSet() error { return W.WNextResultSet() }
// _database_sql_driver_SessionResetter is an interface wrapper for SessionResetter type
type _database_sql_driver_SessionResetter struct {
IValue interface{}
WResetSession func(ctx context.Context) error
}
func (W _database_sql_driver_SessionResetter) ResetSession(ctx context.Context) error {
return W.WResetSession(ctx)
}
// _database_sql_driver_Stmt is an interface wrapper for Stmt type
type _database_sql_driver_Stmt struct {
IValue interface{}
WClose func() error
WExec func(args []driver.Value) (driver.Result, error)
WNumInput func() int
WQuery func(args []driver.Value) (driver.Rows, error)
}
func (W _database_sql_driver_Stmt) Close() error { return W.WClose() }
func (W _database_sql_driver_Stmt) Exec(args []driver.Value) (driver.Result, error) {
return W.WExec(args)
}
func (W _database_sql_driver_Stmt) NumInput() int { return W.WNumInput() }
func (W _database_sql_driver_Stmt) Query(args []driver.Value) (driver.Rows, error) {
return W.WQuery(args)
}
// _database_sql_driver_StmtExecContext is an interface wrapper for StmtExecContext type
type _database_sql_driver_StmtExecContext struct {
IValue interface{}
WExecContext func(ctx context.Context, args []driver.NamedValue) (driver.Result, error)
}
func (W _database_sql_driver_StmtExecContext) ExecContext(ctx context.Context, args []driver.NamedValue) (driver.Result, error) {
return W.WExecContext(ctx, args)
}
// _database_sql_driver_StmtQueryContext is an interface wrapper for StmtQueryContext type
type _database_sql_driver_StmtQueryContext struct {
IValue interface{}
WQueryContext func(ctx context.Context, args []driver.NamedValue) (driver.Rows, error)
}
func (W _database_sql_driver_StmtQueryContext) QueryContext(ctx context.Context, args []driver.NamedValue) (driver.Rows, error) {
return W.WQueryContext(ctx, args)
}
// _database_sql_driver_Tx is an interface wrapper for Tx type
type _database_sql_driver_Tx struct {
IValue interface{}
WCommit func() error
WRollback func() error
}
func (W _database_sql_driver_Tx) Commit() error { return W.WCommit() }
func (W _database_sql_driver_Tx) Rollback() error { return W.WRollback() }
// _database_sql_driver_Validator is an interface wrapper for Validator type
type _database_sql_driver_Validator struct {
IValue interface{}
WIsValid func() bool
}
func (W _database_sql_driver_Validator) IsValid() bool { return W.WIsValid() }
// _database_sql_driver_Value is an interface wrapper for Value type
type _database_sql_driver_Value struct {
IValue interface{}
}
// _database_sql_driver_ValueConverter is an interface wrapper for ValueConverter type
type _database_sql_driver_ValueConverter struct {
IValue interface{}
WConvertValue func(v any) (driver.Value, error)
}
func (W _database_sql_driver_ValueConverter) ConvertValue(v any) (driver.Value, error) {
return W.WConvertValue(v)
}
// _database_sql_driver_Valuer is an interface wrapper for Valuer type
type _database_sql_driver_Valuer struct {
IValue interface{}
WValue func() (driver.Value, error)
}
func (W _database_sql_driver_Valuer) Value() (driver.Value, error) { return W.WValue() }
================================================
FILE: stdlib/go1_21_debug_buildinfo.go
================================================
// Code generated by 'yaegi extract debug/buildinfo'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"debug/buildinfo"
"reflect"
)
func init() {
Symbols["debug/buildinfo/buildinfo"] = map[string]reflect.Value{
// function, constant and variable definitions
"Read": reflect.ValueOf(buildinfo.Read),
"ReadFile": reflect.ValueOf(buildinfo.ReadFile),
// type definitions
"BuildInfo": reflect.ValueOf((*buildinfo.BuildInfo)(nil)),
}
}
================================================
FILE: stdlib/go1_21_debug_dwarf.go
================================================
// Code generated by 'yaegi extract debug/dwarf'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"debug/dwarf"
"reflect"
)
func init() {
Symbols["debug/dwarf/dwarf"] = map[string]reflect.Value{
// function, constant and variable definitions
"AttrAbstractOrigin": reflect.ValueOf(dwarf.AttrAbstractOrigin),
"AttrAccessibility": reflect.ValueOf(dwarf.AttrAccessibility),
"AttrAddrBase": reflect.ValueOf(dwarf.AttrAddrBase),
"AttrAddrClass": reflect.ValueOf(dwarf.AttrAddrClass),
"AttrAlignment": reflect.ValueOf(dwarf.AttrAlignment),
"AttrAllocated": reflect.ValueOf(dwarf.AttrAllocated),
"AttrArtificial": reflect.ValueOf(dwarf.AttrArtificial),
"AttrAssociated": reflect.ValueOf(dwarf.AttrAssociated),
"AttrBaseTypes": reflect.ValueOf(dwarf.AttrBaseTypes),
"AttrBinaryScale": reflect.ValueOf(dwarf.AttrBinaryScale),
"AttrBitOffset": reflect.ValueOf(dwarf.AttrBitOffset),
"AttrBitSize": reflect.ValueOf(dwarf.AttrBitSize),
"AttrByteSize": reflect.ValueOf(dwarf.AttrByteSize),
"AttrCallAllCalls": reflect.ValueOf(dwarf.AttrCallAllCalls),
"AttrCallAllSourceCalls": reflect.ValueOf(dwarf.AttrCallAllSourceCalls),
"AttrCallAllTailCalls": reflect.ValueOf(dwarf.AttrCallAllTailCalls),
"AttrCallColumn": reflect.ValueOf(dwarf.AttrCallColumn),
"AttrCallDataLocation": reflect.ValueOf(dwarf.AttrCallDataLocation),
"AttrCallDataValue": reflect.ValueOf(dwarf.AttrCallDataValue),
"AttrCallFile": reflect.ValueOf(dwarf.AttrCallFile),
"AttrCallLine": reflect.ValueOf(dwarf.AttrCallLine),
"AttrCallOrigin": reflect.ValueOf(dwarf.AttrCallOrigin),
"AttrCallPC": reflect.ValueOf(dwarf.AttrCallPC),
"AttrCallParameter": reflect.ValueOf(dwarf.AttrCallParameter),
"AttrCallReturnPC": reflect.ValueOf(dwarf.AttrCallReturnPC),
"AttrCallTailCall": reflect.ValueOf(dwarf.AttrCallTailCall),
"AttrCallTarget": reflect.ValueOf(dwarf.AttrCallTarget),
"AttrCallTargetClobbered": reflect.ValueOf(dwarf.AttrCallTargetClobbered),
"AttrCallValue": reflect.ValueOf(dwarf.AttrCallValue),
"AttrCalling": reflect.ValueOf(dwarf.AttrCalling),
"AttrCommonRef": reflect.ValueOf(dwarf.AttrCommonRef),
"AttrCompDir": reflect.ValueOf(dwarf.AttrCompDir),
"AttrConstExpr": reflect.ValueOf(dwarf.AttrConstExpr),
"AttrConstValue": reflect.ValueOf(dwarf.AttrConstValue),
"AttrContainingType": reflect.ValueOf(dwarf.AttrContainingType),
"AttrCount": reflect.ValueOf(dwarf.AttrCount),
"AttrDataBitOffset": reflect.ValueOf(dwarf.AttrDataBitOffset),
"AttrDataLocation": reflect.ValueOf(dwarf.AttrDataLocation),
"AttrDataMemberLoc": reflect.ValueOf(dwarf.AttrDataMemberLoc),
"AttrDecimalScale": reflect.ValueOf(dwarf.AttrDecimalScale),
"AttrDecimalSign": reflect.ValueOf(dwarf.AttrDecimalSign),
"AttrDeclColumn": reflect.ValueOf(dwarf.AttrDeclColumn),
"AttrDeclFile": reflect.ValueOf(dwarf.AttrDeclFile),
"AttrDeclLine": reflect.ValueOf(dwarf.AttrDeclLine),
"AttrDeclaration": reflect.ValueOf(dwarf.AttrDeclaration),
"AttrDefaultValue": reflect.ValueOf(dwarf.AttrDefaultValue),
"AttrDefaulted": reflect.ValueOf(dwarf.AttrDefaulted),
"AttrDeleted": reflect.ValueOf(dwarf.AttrDeleted),
"AttrDescription": reflect.ValueOf(dwarf.AttrDescription),
"AttrDigitCount": reflect.ValueOf(dwarf.AttrDigitCount),
"AttrDiscr": reflect.ValueOf(dwarf.AttrDiscr),
"AttrDiscrList": reflect.ValueOf(dwarf.AttrDiscrList),
"AttrDiscrValue": reflect.ValueOf(dwarf.AttrDiscrValue),
"AttrDwoName": reflect.ValueOf(dwarf.AttrDwoName),
"AttrElemental": reflect.ValueOf(dwarf.AttrElemental),
"AttrEncoding": reflect.ValueOf(dwarf.AttrEncoding),
"AttrEndianity": reflect.ValueOf(dwarf.AttrEndianity),
"AttrEntrypc": reflect.ValueOf(dwarf.AttrEntrypc),
"AttrEnumClass": reflect.ValueOf(dwarf.AttrEnumClass),
"AttrExplicit": reflect.ValueOf(dwarf.AttrExplicit),
"AttrExportSymbols": reflect.ValueOf(dwarf.AttrExportSymbols),
"AttrExtension": reflect.ValueOf(dwarf.AttrExtension),
"AttrExternal": reflect.ValueOf(dwarf.AttrExternal),
"AttrFrameBase": reflect.ValueOf(dwarf.AttrFrameBase),
"AttrFriend": reflect.ValueOf(dwarf.AttrFriend),
"AttrHighpc": reflect.ValueOf(dwarf.AttrHighpc),
"AttrIdentifierCase": reflect.ValueOf(dwarf.AttrIdentifierCase),
"AttrImport": reflect.ValueOf(dwarf.AttrImport),
"AttrInline": reflect.ValueOf(dwarf.AttrInline),
"AttrIsOptional": reflect.ValueOf(dwarf.AttrIsOptional),
"AttrLanguage": reflect.ValueOf(dwarf.AttrLanguage),
"AttrLinkageName": reflect.ValueOf(dwarf.AttrLinkageName),
"AttrLocation": reflect.ValueOf(dwarf.AttrLocation),
"AttrLoclistsBase": reflect.ValueOf(dwarf.AttrLoclistsBase),
"AttrLowerBound": reflect.ValueOf(dwarf.AttrLowerBound),
"AttrLowpc": reflect.ValueOf(dwarf.AttrLowpc),
"AttrMacroInfo": reflect.ValueOf(dwarf.AttrMacroInfo),
"AttrMacros": reflect.ValueOf(dwarf.AttrMacros),
"AttrMainSubprogram": reflect.ValueOf(dwarf.AttrMainSubprogram),
"AttrMutable": reflect.ValueOf(dwarf.AttrMutable),
"AttrName": reflect.ValueOf(dwarf.AttrName),
"AttrNamelistItem": reflect.ValueOf(dwarf.AttrNamelistItem),
"AttrNoreturn": reflect.ValueOf(dwarf.AttrNoreturn),
"AttrObjectPointer": reflect.ValueOf(dwarf.AttrObjectPointer),
"AttrOrdering": reflect.ValueOf(dwarf.AttrOrdering),
"AttrPictureString": reflect.ValueOf(dwarf.AttrPictureString),
"AttrPriority": reflect.ValueOf(dwarf.AttrPriority),
"AttrProducer": reflect.ValueOf(dwarf.AttrProducer),
"AttrPrototyped": reflect.ValueOf(dwarf.AttrPrototyped),
"AttrPure": reflect.ValueOf(dwarf.AttrPure),
"AttrRanges": reflect.ValueOf(dwarf.AttrRanges),
"AttrRank": reflect.ValueOf(dwarf.AttrRank),
"AttrRecursive": reflect.ValueOf(dwarf.AttrRecursive),
"AttrReference": reflect.ValueOf(dwarf.AttrReference),
"AttrReturnAddr": reflect.ValueOf(dwarf.AttrReturnAddr),
"AttrRnglistsBase": reflect.ValueOf(dwarf.AttrRnglistsBase),
"AttrRvalueReference": reflect.ValueOf(dwarf.AttrRvalueReference),
"AttrSegment": reflect.ValueOf(dwarf.AttrSegment),
"AttrSibling": reflect.ValueOf(dwarf.AttrSibling),
"AttrSignature": reflect.ValueOf(dwarf.AttrSignature),
"AttrSmall": reflect.ValueOf(dwarf.AttrSmall),
"AttrSpecification": reflect.ValueOf(dwarf.AttrSpecification),
"AttrStartScope": reflect.ValueOf(dwarf.AttrStartScope),
"AttrStaticLink": reflect.ValueOf(dwarf.AttrStaticLink),
"AttrStmtList": reflect.ValueOf(dwarf.AttrStmtList),
"AttrStrOffsetsBase": reflect.ValueOf(dwarf.AttrStrOffsetsBase),
"AttrStride": reflect.ValueOf(dwarf.AttrStride),
"AttrStrideSize": reflect.ValueOf(dwarf.AttrStrideSize),
"AttrStringLength": reflect.ValueOf(dwarf.AttrStringLength),
"AttrStringLengthBitSize": reflect.ValueOf(dwarf.AttrStringLengthBitSize),
"AttrStringLengthByteSize": reflect.ValueOf(dwarf.AttrStringLengthByteSize),
"AttrThreadsScaled": reflect.ValueOf(dwarf.AttrThreadsScaled),
"AttrTrampoline": reflect.ValueOf(dwarf.AttrTrampoline),
"AttrType": reflect.ValueOf(dwarf.AttrType),
"AttrUpperBound": reflect.ValueOf(dwarf.AttrUpperBound),
"AttrUseLocation": reflect.ValueOf(dwarf.AttrUseLocation),
"AttrUseUTF8": reflect.ValueOf(dwarf.AttrUseUTF8),
"AttrVarParam": reflect.ValueOf(dwarf.AttrVarParam),
"AttrVirtuality": reflect.ValueOf(dwarf.AttrVirtuality),
"AttrVisibility": reflect.ValueOf(dwarf.AttrVisibility),
"AttrVtableElemLoc": reflect.ValueOf(dwarf.AttrVtableElemLoc),
"ClassAddrPtr": reflect.ValueOf(dwarf.ClassAddrPtr),
"ClassAddress": reflect.ValueOf(dwarf.ClassAddress),
"ClassBlock": reflect.ValueOf(dwarf.ClassBlock),
"ClassConstant": reflect.ValueOf(dwarf.ClassConstant),
"ClassExprLoc": reflect.ValueOf(dwarf.ClassExprLoc),
"ClassFlag": reflect.ValueOf(dwarf.ClassFlag),
"ClassLinePtr": reflect.ValueOf(dwarf.ClassLinePtr),
"ClassLocList": reflect.ValueOf(dwarf.ClassLocList),
"ClassLocListPtr": reflect.ValueOf(dwarf.ClassLocListPtr),
"ClassMacPtr": reflect.ValueOf(dwarf.ClassMacPtr),
"ClassRangeListPtr": reflect.ValueOf(dwarf.ClassRangeListPtr),
"ClassReference": reflect.ValueOf(dwarf.ClassReference),
"ClassReferenceAlt": reflect.ValueOf(dwarf.ClassReferenceAlt),
"ClassReferenceSig": reflect.ValueOf(dwarf.ClassReferenceSig),
"ClassRngList": reflect.ValueOf(dwarf.ClassRngList),
"ClassRngListsPtr": reflect.ValueOf(dwarf.ClassRngListsPtr),
"ClassStrOffsetsPtr": reflect.ValueOf(dwarf.ClassStrOffsetsPtr),
"ClassString": reflect.ValueOf(dwarf.ClassString),
"ClassStringAlt": reflect.ValueOf(dwarf.ClassStringAlt),
"ClassUnknown": reflect.ValueOf(dwarf.ClassUnknown),
"ErrUnknownPC": reflect.ValueOf(&dwarf.ErrUnknownPC).Elem(),
"New": reflect.ValueOf(dwarf.New),
"TagAccessDeclaration": reflect.ValueOf(dwarf.TagAccessDeclaration),
"TagArrayType": reflect.ValueOf(dwarf.TagArrayType),
"TagAtomicType": reflect.ValueOf(dwarf.TagAtomicType),
"TagBaseType": reflect.ValueOf(dwarf.TagBaseType),
"TagCallSite": reflect.ValueOf(dwarf.TagCallSite),
"TagCallSiteParameter": reflect.ValueOf(dwarf.TagCallSiteParameter),
"TagCatchDwarfBlock": reflect.ValueOf(dwarf.TagCatchDwarfBlock),
"TagClassType": reflect.ValueOf(dwarf.TagClassType),
"TagCoarrayType": reflect.ValueOf(dwarf.TagCoarrayType),
"TagCommonDwarfBlock": reflect.ValueOf(dwarf.TagCommonDwarfBlock),
"TagCommonInclusion": reflect.ValueOf(dwarf.TagCommonInclusion),
"TagCompileUnit": reflect.ValueOf(dwarf.TagCompileUnit),
"TagCondition": reflect.ValueOf(dwarf.TagCondition),
"TagConstType": reflect.ValueOf(dwarf.TagConstType),
"TagConstant": reflect.ValueOf(dwarf.TagConstant),
"TagDwarfProcedure": reflect.ValueOf(dwarf.TagDwarfProcedure),
"TagDynamicType": reflect.ValueOf(dwarf.TagDynamicType),
"TagEntryPoint": reflect.ValueOf(dwarf.TagEntryPoint),
"TagEnumerationType": reflect.ValueOf(dwarf.TagEnumerationType),
"TagEnumerator": reflect.ValueOf(dwarf.TagEnumerator),
"TagFileType": reflect.ValueOf(dwarf.TagFileType),
"TagFormalParameter": reflect.ValueOf(dwarf.TagFormalParameter),
"TagFriend": reflect.ValueOf(dwarf.TagFriend),
"TagGenericSubrange": reflect.ValueOf(dwarf.TagGenericSubrange),
"TagImmutableType": reflect.ValueOf(dwarf.TagImmutableType),
"TagImportedDeclaration": reflect.ValueOf(dwarf.TagImportedDeclaration),
"TagImportedModule": reflect.ValueOf(dwarf.TagImportedModule),
"TagImportedUnit": reflect.ValueOf(dwarf.TagImportedUnit),
"TagInheritance": reflect.ValueOf(dwarf.TagInheritance),
"TagInlinedSubroutine": reflect.ValueOf(dwarf.TagInlinedSubroutine),
"TagInterfaceType": reflect.ValueOf(dwarf.TagInterfaceType),
"TagLabel": reflect.ValueOf(dwarf.TagLabel),
"TagLexDwarfBlock": reflect.ValueOf(dwarf.TagLexDwarfBlock),
"TagMember": reflect.ValueOf(dwarf.TagMember),
"TagModule": reflect.ValueOf(dwarf.TagModule),
"TagMutableType": reflect.ValueOf(dwarf.TagMutableType),
"TagNamelist": reflect.ValueOf(dwarf.TagNamelist),
"TagNamelistItem": reflect.ValueOf(dwarf.TagNamelistItem),
"TagNamespace": reflect.ValueOf(dwarf.TagNamespace),
"TagPackedType": reflect.ValueOf(dwarf.TagPackedType),
"TagPartialUnit": reflect.ValueOf(dwarf.TagPartialUnit),
"TagPointerType": reflect.ValueOf(dwarf.TagPointerType),
"TagPtrToMemberType": reflect.ValueOf(dwarf.TagPtrToMemberType),
"TagReferenceType": reflect.ValueOf(dwarf.TagReferenceType),
"TagRestrictType": reflect.ValueOf(dwarf.TagRestrictType),
"TagRvalueReferenceType": reflect.ValueOf(dwarf.TagRvalueReferenceType),
"TagSetType": reflect.ValueOf(dwarf.TagSetType),
"TagSharedType": reflect.ValueOf(dwarf.TagSharedType),
"TagSkeletonUnit": reflect.ValueOf(dwarf.TagSkeletonUnit),
"TagStringType": reflect.ValueOf(dwarf.TagStringType),
"TagStructType": reflect.ValueOf(dwarf.TagStructType),
"TagSubprogram": reflect.ValueOf(dwarf.TagSubprogram),
"TagSubrangeType": reflect.ValueOf(dwarf.TagSubrangeType),
"TagSubroutineType": reflect.ValueOf(dwarf.TagSubroutineType),
"TagTemplateAlias": reflect.ValueOf(dwarf.TagTemplateAlias),
"TagTemplateTypeParameter": reflect.ValueOf(dwarf.TagTemplateTypeParameter),
"TagTemplateValueParameter": reflect.ValueOf(dwarf.TagTemplateValueParameter),
"TagThrownType": reflect.ValueOf(dwarf.TagThrownType),
"TagTryDwarfBlock": reflect.ValueOf(dwarf.TagTryDwarfBlock),
"TagTypeUnit": reflect.ValueOf(dwarf.TagTypeUnit),
"TagTypedef": reflect.ValueOf(dwarf.TagTypedef),
"TagUnionType": reflect.ValueOf(dwarf.TagUnionType),
"TagUnspecifiedParameters": reflect.ValueOf(dwarf.TagUnspecifiedParameters),
"TagUnspecifiedType": reflect.ValueOf(dwarf.TagUnspecifiedType),
"TagVariable": reflect.ValueOf(dwarf.TagVariable),
"TagVariant": reflect.ValueOf(dwarf.TagVariant),
"TagVariantPart": reflect.ValueOf(dwarf.TagVariantPart),
"TagVolatileType": reflect.ValueOf(dwarf.TagVolatileType),
"TagWithStmt": reflect.ValueOf(dwarf.TagWithStmt),
// type definitions
"AddrType": reflect.ValueOf((*dwarf.AddrType)(nil)),
"ArrayType": reflect.ValueOf((*dwarf.ArrayType)(nil)),
"Attr": reflect.ValueOf((*dwarf.Attr)(nil)),
"BasicType": reflect.ValueOf((*dwarf.BasicType)(nil)),
"BoolType": reflect.ValueOf((*dwarf.BoolType)(nil)),
"CharType": reflect.ValueOf((*dwarf.CharType)(nil)),
"Class": reflect.ValueOf((*dwarf.Class)(nil)),
"CommonType": reflect.ValueOf((*dwarf.CommonType)(nil)),
"ComplexType": reflect.ValueOf((*dwarf.ComplexType)(nil)),
"Data": reflect.ValueOf((*dwarf.Data)(nil)),
"DecodeError": reflect.ValueOf((*dwarf.DecodeError)(nil)),
"DotDotDotType": reflect.ValueOf((*dwarf.DotDotDotType)(nil)),
"Entry": reflect.ValueOf((*dwarf.Entry)(nil)),
"EnumType": reflect.ValueOf((*dwarf.EnumType)(nil)),
"EnumValue": reflect.ValueOf((*dwarf.EnumValue)(nil)),
"Field": reflect.ValueOf((*dwarf.Field)(nil)),
"FloatType": reflect.ValueOf((*dwarf.FloatType)(nil)),
"FuncType": reflect.ValueOf((*dwarf.FuncType)(nil)),
"IntType": reflect.ValueOf((*dwarf.IntType)(nil)),
"LineEntry": reflect.ValueOf((*dwarf.LineEntry)(nil)),
"LineFile": reflect.ValueOf((*dwarf.LineFile)(nil)),
"LineReader": reflect.ValueOf((*dwarf.LineReader)(nil)),
"LineReaderPos": reflect.ValueOf((*dwarf.LineReaderPos)(nil)),
"Offset": reflect.ValueOf((*dwarf.Offset)(nil)),
"PtrType": reflect.ValueOf((*dwarf.PtrType)(nil)),
"QualType": reflect.ValueOf((*dwarf.QualType)(nil)),
"Reader": reflect.ValueOf((*dwarf.Reader)(nil)),
"StructField": reflect.ValueOf((*dwarf.StructField)(nil)),
"StructType": reflect.ValueOf((*dwarf.StructType)(nil)),
"Tag": reflect.ValueOf((*dwarf.Tag)(nil)),
"Type": reflect.ValueOf((*dwarf.Type)(nil)),
"TypedefType": reflect.ValueOf((*dwarf.TypedefType)(nil)),
"UcharType": reflect.ValueOf((*dwarf.UcharType)(nil)),
"UintType": reflect.ValueOf((*dwarf.UintType)(nil)),
"UnspecifiedType": reflect.ValueOf((*dwarf.UnspecifiedType)(nil)),
"UnsupportedType": reflect.ValueOf((*dwarf.UnsupportedType)(nil)),
"VoidType": reflect.ValueOf((*dwarf.VoidType)(nil)),
// interface wrapper definitions
"_Type": reflect.ValueOf((*_debug_dwarf_Type)(nil)),
}
}
// _debug_dwarf_Type is an interface wrapper for Type type
type _debug_dwarf_Type struct {
IValue interface{}
WCommon func() *dwarf.CommonType
WSize func() int64
WString func() string
}
func (W _debug_dwarf_Type) Common() *dwarf.CommonType { return W.WCommon() }
func (W _debug_dwarf_Type) Size() int64 { return W.WSize() }
func (W _debug_dwarf_Type) String() string {
if W.WString == nil {
return ""
}
return W.WString()
}
================================================
FILE: stdlib/go1_21_debug_elf.go
================================================
// Code generated by 'yaegi extract debug/elf'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"debug/elf"
"go/constant"
"go/token"
"reflect"
)
func init() {
Symbols["debug/elf/elf"] = map[string]reflect.Value{
// function, constant and variable definitions
"ARM_MAGIC_TRAMP_NUMBER": reflect.ValueOf(constant.MakeFromLiteral("1543503875", token.INT, 0)),
"COMPRESS_HIOS": reflect.ValueOf(elf.COMPRESS_HIOS),
"COMPRESS_HIPROC": reflect.ValueOf(elf.COMPRESS_HIPROC),
"COMPRESS_LOOS": reflect.ValueOf(elf.COMPRESS_LOOS),
"COMPRESS_LOPROC": reflect.ValueOf(elf.COMPRESS_LOPROC),
"COMPRESS_ZLIB": reflect.ValueOf(elf.COMPRESS_ZLIB),
"COMPRESS_ZSTD": reflect.ValueOf(elf.COMPRESS_ZSTD),
"DF_1_CONFALT": reflect.ValueOf(elf.DF_1_CONFALT),
"DF_1_DIRECT": reflect.ValueOf(elf.DF_1_DIRECT),
"DF_1_DISPRELDNE": reflect.ValueOf(elf.DF_1_DISPRELDNE),
"DF_1_DISPRELPND": reflect.ValueOf(elf.DF_1_DISPRELPND),
"DF_1_EDITED": reflect.ValueOf(elf.DF_1_EDITED),
"DF_1_ENDFILTEE": reflect.ValueOf(elf.DF_1_ENDFILTEE),
"DF_1_GLOBAL": reflect.ValueOf(elf.DF_1_GLOBAL),
"DF_1_GLOBAUDIT": reflect.ValueOf(elf.DF_1_GLOBAUDIT),
"DF_1_GROUP": reflect.ValueOf(elf.DF_1_GROUP),
"DF_1_IGNMULDEF": reflect.ValueOf(elf.DF_1_IGNMULDEF),
"DF_1_INITFIRST": reflect.ValueOf(elf.DF_1_INITFIRST),
"DF_1_INTERPOSE": reflect.ValueOf(elf.DF_1_INTERPOSE),
"DF_1_KMOD": reflect.ValueOf(elf.DF_1_KMOD),
"DF_1_LOADFLTR": reflect.ValueOf(elf.DF_1_LOADFLTR),
"DF_1_NOCOMMON": reflect.ValueOf(elf.DF_1_NOCOMMON),
"DF_1_NODEFLIB": reflect.ValueOf(elf.DF_1_NODEFLIB),
"DF_1_NODELETE": reflect.ValueOf(elf.DF_1_NODELETE),
"DF_1_NODIRECT": reflect.ValueOf(elf.DF_1_NODIRECT),
"DF_1_NODUMP": reflect.ValueOf(elf.DF_1_NODUMP),
"DF_1_NOHDR": reflect.ValueOf(elf.DF_1_NOHDR),
"DF_1_NOKSYMS": reflect.ValueOf(elf.DF_1_NOKSYMS),
"DF_1_NOOPEN": reflect.ValueOf(elf.DF_1_NOOPEN),
"DF_1_NORELOC": reflect.ValueOf(elf.DF_1_NORELOC),
"DF_1_NOW": reflect.ValueOf(elf.DF_1_NOW),
"DF_1_ORIGIN": reflect.ValueOf(elf.DF_1_ORIGIN),
"DF_1_PIE": reflect.ValueOf(elf.DF_1_PIE),
"DF_1_SINGLETON": reflect.ValueOf(elf.DF_1_SINGLETON),
"DF_1_STUB": reflect.ValueOf(elf.DF_1_STUB),
"DF_1_SYMINTPOSE": reflect.ValueOf(elf.DF_1_SYMINTPOSE),
"DF_1_TRANS": reflect.ValueOf(elf.DF_1_TRANS),
"DF_1_WEAKFILTER": reflect.ValueOf(elf.DF_1_WEAKFILTER),
"DF_BIND_NOW": reflect.ValueOf(elf.DF_BIND_NOW),
"DF_ORIGIN": reflect.ValueOf(elf.DF_ORIGIN),
"DF_STATIC_TLS": reflect.ValueOf(elf.DF_STATIC_TLS),
"DF_SYMBOLIC": reflect.ValueOf(elf.DF_SYMBOLIC),
"DF_TEXTREL": reflect.ValueOf(elf.DF_TEXTREL),
"DT_ADDRRNGHI": reflect.ValueOf(elf.DT_ADDRRNGHI),
"DT_ADDRRNGLO": reflect.ValueOf(elf.DT_ADDRRNGLO),
"DT_AUDIT": reflect.ValueOf(elf.DT_AUDIT),
"DT_AUXILIARY": reflect.ValueOf(elf.DT_AUXILIARY),
"DT_BIND_NOW": reflect.ValueOf(elf.DT_BIND_NOW),
"DT_CHECKSUM": reflect.ValueOf(elf.DT_CHECKSUM),
"DT_CONFIG": reflect.ValueOf(elf.DT_CONFIG),
"DT_DEBUG": reflect.ValueOf(elf.DT_DEBUG),
"DT_DEPAUDIT": reflect.ValueOf(elf.DT_DEPAUDIT),
"DT_ENCODING": reflect.ValueOf(elf.DT_ENCODING),
"DT_FEATURE": reflect.ValueOf(elf.DT_FEATURE),
"DT_FILTER": reflect.ValueOf(elf.DT_FILTER),
"DT_FINI": reflect.ValueOf(elf.DT_FINI),
"DT_FINI_ARRAY": reflect.ValueOf(elf.DT_FINI_ARRAY),
"DT_FINI_ARRAYSZ": reflect.ValueOf(elf.DT_FINI_ARRAYSZ),
"DT_FLAGS": reflect.ValueOf(elf.DT_FLAGS),
"DT_FLAGS_1": reflect.ValueOf(elf.DT_FLAGS_1),
"DT_GNU_CONFLICT": reflect.ValueOf(elf.DT_GNU_CONFLICT),
"DT_GNU_CONFLICTSZ": reflect.ValueOf(elf.DT_GNU_CONFLICTSZ),
"DT_GNU_HASH": reflect.ValueOf(elf.DT_GNU_HASH),
"DT_GNU_LIBLIST": reflect.ValueOf(elf.DT_GNU_LIBLIST),
"DT_GNU_LIBLISTSZ": reflect.ValueOf(elf.DT_GNU_LIBLISTSZ),
"DT_GNU_PRELINKED": reflect.ValueOf(elf.DT_GNU_PRELINKED),
"DT_HASH": reflect.ValueOf(elf.DT_HASH),
"DT_HIOS": reflect.ValueOf(elf.DT_HIOS),
"DT_HIPROC": reflect.ValueOf(elf.DT_HIPROC),
"DT_INIT": reflect.ValueOf(elf.DT_INIT),
"DT_INIT_ARRAY": reflect.ValueOf(elf.DT_INIT_ARRAY),
"DT_INIT_ARRAYSZ": reflect.ValueOf(elf.DT_INIT_ARRAYSZ),
"DT_JMPREL": reflect.ValueOf(elf.DT_JMPREL),
"DT_LOOS": reflect.ValueOf(elf.DT_LOOS),
"DT_LOPROC": reflect.ValueOf(elf.DT_LOPROC),
"DT_MIPS_AUX_DYNAMIC": reflect.ValueOf(elf.DT_MIPS_AUX_DYNAMIC),
"DT_MIPS_BASE_ADDRESS": reflect.ValueOf(elf.DT_MIPS_BASE_ADDRESS),
"DT_MIPS_COMPACT_SIZE": reflect.ValueOf(elf.DT_MIPS_COMPACT_SIZE),
"DT_MIPS_CONFLICT": reflect.ValueOf(elf.DT_MIPS_CONFLICT),
"DT_MIPS_CONFLICTNO": reflect.ValueOf(elf.DT_MIPS_CONFLICTNO),
"DT_MIPS_CXX_FLAGS": reflect.ValueOf(elf.DT_MIPS_CXX_FLAGS),
"DT_MIPS_DELTA_CLASS": reflect.ValueOf(elf.DT_MIPS_DELTA_CLASS),
"DT_MIPS_DELTA_CLASSSYM": reflect.ValueOf(elf.DT_MIPS_DELTA_CLASSSYM),
"DT_MIPS_DELTA_CLASSSYM_NO": reflect.ValueOf(elf.DT_MIPS_DELTA_CLASSSYM_NO),
"DT_MIPS_DELTA_CLASS_NO": reflect.ValueOf(elf.DT_MIPS_DELTA_CLASS_NO),
"DT_MIPS_DELTA_INSTANCE": reflect.ValueOf(elf.DT_MIPS_DELTA_INSTANCE),
"DT_MIPS_DELTA_INSTANCE_NO": reflect.ValueOf(elf.DT_MIPS_DELTA_INSTANCE_NO),
"DT_MIPS_DELTA_RELOC": reflect.ValueOf(elf.DT_MIPS_DELTA_RELOC),
"DT_MIPS_DELTA_RELOC_NO": reflect.ValueOf(elf.DT_MIPS_DELTA_RELOC_NO),
"DT_MIPS_DELTA_SYM": reflect.ValueOf(elf.DT_MIPS_DELTA_SYM),
"DT_MIPS_DELTA_SYM_NO": reflect.ValueOf(elf.DT_MIPS_DELTA_SYM_NO),
"DT_MIPS_DYNSTR_ALIGN": reflect.ValueOf(elf.DT_MIPS_DYNSTR_ALIGN),
"DT_MIPS_FLAGS": reflect.ValueOf(elf.DT_MIPS_FLAGS),
"DT_MIPS_GOTSYM": reflect.ValueOf(elf.DT_MIPS_GOTSYM),
"DT_MIPS_GP_VALUE": reflect.ValueOf(elf.DT_MIPS_GP_VALUE),
"DT_MIPS_HIDDEN_GOTIDX": reflect.ValueOf(elf.DT_MIPS_HIDDEN_GOTIDX),
"DT_MIPS_HIPAGENO": reflect.ValueOf(elf.DT_MIPS_HIPAGENO),
"DT_MIPS_ICHECKSUM": reflect.ValueOf(elf.DT_MIPS_ICHECKSUM),
"DT_MIPS_INTERFACE": reflect.ValueOf(elf.DT_MIPS_INTERFACE),
"DT_MIPS_INTERFACE_SIZE": reflect.ValueOf(elf.DT_MIPS_INTERFACE_SIZE),
"DT_MIPS_IVERSION": reflect.ValueOf(elf.DT_MIPS_IVERSION),
"DT_MIPS_LIBLIST": reflect.ValueOf(elf.DT_MIPS_LIBLIST),
"DT_MIPS_LIBLISTNO": reflect.ValueOf(elf.DT_MIPS_LIBLISTNO),
"DT_MIPS_LOCALPAGE_GOTIDX": reflect.ValueOf(elf.DT_MIPS_LOCALPAGE_GOTIDX),
"DT_MIPS_LOCAL_GOTIDX": reflect.ValueOf(elf.DT_MIPS_LOCAL_GOTIDX),
"DT_MIPS_LOCAL_GOTNO": reflect.ValueOf(elf.DT_MIPS_LOCAL_GOTNO),
"DT_MIPS_MSYM": reflect.ValueOf(elf.DT_MIPS_MSYM),
"DT_MIPS_OPTIONS": reflect.ValueOf(elf.DT_MIPS_OPTIONS),
"DT_MIPS_PERF_SUFFIX": reflect.ValueOf(elf.DT_MIPS_PERF_SUFFIX),
"DT_MIPS_PIXIE_INIT": reflect.ValueOf(elf.DT_MIPS_PIXIE_INIT),
"DT_MIPS_PLTGOT": reflect.ValueOf(elf.DT_MIPS_PLTGOT),
"DT_MIPS_PROTECTED_GOTIDX": reflect.ValueOf(elf.DT_MIPS_PROTECTED_GOTIDX),
"DT_MIPS_RLD_MAP": reflect.ValueOf(elf.DT_MIPS_RLD_MAP),
"DT_MIPS_RLD_MAP_REL": reflect.ValueOf(elf.DT_MIPS_RLD_MAP_REL),
"DT_MIPS_RLD_TEXT_RESOLVE_ADDR": reflect.ValueOf(elf.DT_MIPS_RLD_TEXT_RESOLVE_ADDR),
"DT_MIPS_RLD_VERSION": reflect.ValueOf(elf.DT_MIPS_RLD_VERSION),
"DT_MIPS_RWPLT": reflect.ValueOf(elf.DT_MIPS_RWPLT),
"DT_MIPS_SYMBOL_LIB": reflect.ValueOf(elf.DT_MIPS_SYMBOL_LIB),
"DT_MIPS_SYMTABNO": reflect.ValueOf(elf.DT_MIPS_SYMTABNO),
"DT_MIPS_TIME_STAMP": reflect.ValueOf(elf.DT_MIPS_TIME_STAMP),
"DT_MIPS_UNREFEXTNO": reflect.ValueOf(elf.DT_MIPS_UNREFEXTNO),
"DT_MOVEENT": reflect.ValueOf(elf.DT_MOVEENT),
"DT_MOVESZ": reflect.ValueOf(elf.DT_MOVESZ),
"DT_MOVETAB": reflect.ValueOf(elf.DT_MOVETAB),
"DT_NEEDED": reflect.ValueOf(elf.DT_NEEDED),
"DT_NULL": reflect.ValueOf(elf.DT_NULL),
"DT_PLTGOT": reflect.ValueOf(elf.DT_PLTGOT),
"DT_PLTPAD": reflect.ValueOf(elf.DT_PLTPAD),
"DT_PLTPADSZ": reflect.ValueOf(elf.DT_PLTPADSZ),
"DT_PLTREL": reflect.ValueOf(elf.DT_PLTREL),
"DT_PLTRELSZ": reflect.ValueOf(elf.DT_PLTRELSZ),
"DT_POSFLAG_1": reflect.ValueOf(elf.DT_POSFLAG_1),
"DT_PPC64_GLINK": reflect.ValueOf(elf.DT_PPC64_GLINK),
"DT_PPC64_OPD": reflect.ValueOf(elf.DT_PPC64_OPD),
"DT_PPC64_OPDSZ": reflect.ValueOf(elf.DT_PPC64_OPDSZ),
"DT_PPC64_OPT": reflect.ValueOf(elf.DT_PPC64_OPT),
"DT_PPC_GOT": reflect.ValueOf(elf.DT_PPC_GOT),
"DT_PPC_OPT": reflect.ValueOf(elf.DT_PPC_OPT),
"DT_PREINIT_ARRAY": reflect.ValueOf(elf.DT_PREINIT_ARRAY),
"DT_PREINIT_ARRAYSZ": reflect.ValueOf(elf.DT_PREINIT_ARRAYSZ),
"DT_REL": reflect.ValueOf(elf.DT_REL),
"DT_RELA": reflect.ValueOf(elf.DT_RELA),
"DT_RELACOUNT": reflect.ValueOf(elf.DT_RELACOUNT),
"DT_RELAENT": reflect.ValueOf(elf.DT_RELAENT),
"DT_RELASZ": reflect.ValueOf(elf.DT_RELASZ),
"DT_RELCOUNT": reflect.ValueOf(elf.DT_RELCOUNT),
"DT_RELENT": reflect.ValueOf(elf.DT_RELENT),
"DT_RELSZ": reflect.ValueOf(elf.DT_RELSZ),
"DT_RPATH": reflect.ValueOf(elf.DT_RPATH),
"DT_RUNPATH": reflect.ValueOf(elf.DT_RUNPATH),
"DT_SONAME": reflect.ValueOf(elf.DT_SONAME),
"DT_SPARC_REGISTER": reflect.ValueOf(elf.DT_SPARC_REGISTER),
"DT_STRSZ": reflect.ValueOf(elf.DT_STRSZ),
"DT_STRTAB": reflect.ValueOf(elf.DT_STRTAB),
"DT_SYMBOLIC": reflect.ValueOf(elf.DT_SYMBOLIC),
"DT_SYMENT": reflect.ValueOf(elf.DT_SYMENT),
"DT_SYMINENT": reflect.ValueOf(elf.DT_SYMINENT),
"DT_SYMINFO": reflect.ValueOf(elf.DT_SYMINFO),
"DT_SYMINSZ": reflect.ValueOf(elf.DT_SYMINSZ),
"DT_SYMTAB": reflect.ValueOf(elf.DT_SYMTAB),
"DT_SYMTAB_SHNDX": reflect.ValueOf(elf.DT_SYMTAB_SHNDX),
"DT_TEXTREL": reflect.ValueOf(elf.DT_TEXTREL),
"DT_TLSDESC_GOT": reflect.ValueOf(elf.DT_TLSDESC_GOT),
"DT_TLSDESC_PLT": reflect.ValueOf(elf.DT_TLSDESC_PLT),
"DT_USED": reflect.ValueOf(elf.DT_USED),
"DT_VALRNGHI": reflect.ValueOf(elf.DT_VALRNGHI),
"DT_VALRNGLO": reflect.ValueOf(elf.DT_VALRNGLO),
"DT_VERDEF": reflect.ValueOf(elf.DT_VERDEF),
"DT_VERDEFNUM": reflect.ValueOf(elf.DT_VERDEFNUM),
"DT_VERNEED": reflect.ValueOf(elf.DT_VERNEED),
"DT_VERNEEDNUM": reflect.ValueOf(elf.DT_VERNEEDNUM),
"DT_VERSYM": reflect.ValueOf(elf.DT_VERSYM),
"EI_ABIVERSION": reflect.ValueOf(constant.MakeFromLiteral("8", token.INT, 0)),
"EI_CLASS": reflect.ValueOf(constant.MakeFromLiteral("4", token.INT, 0)),
"EI_DATA": reflect.ValueOf(constant.MakeFromLiteral("5", token.INT, 0)),
"EI_NIDENT": reflect.ValueOf(constant.MakeFromLiteral("16", token.INT, 0)),
"EI_OSABI": reflect.ValueOf(constant.MakeFromLiteral("7", token.INT, 0)),
"EI_PAD": reflect.ValueOf(constant.MakeFromLiteral("9", token.INT, 0)),
"EI_VERSION": reflect.ValueOf(constant.MakeFromLiteral("6", token.INT, 0)),
"ELFCLASS32": reflect.ValueOf(elf.ELFCLASS32),
"ELFCLASS64": reflect.ValueOf(elf.ELFCLASS64),
"ELFCLASSNONE": reflect.ValueOf(elf.ELFCLASSNONE),
"ELFDATA2LSB": reflect.ValueOf(elf.ELFDATA2LSB),
"ELFDATA2MSB": reflect.ValueOf(elf.ELFDATA2MSB),
"ELFDATANONE": reflect.ValueOf(elf.ELFDATANONE),
"ELFMAG": reflect.ValueOf(constant.MakeFromLiteral("\"\\x7fELF\"", token.STRING, 0)),
"ELFOSABI_86OPEN": reflect.ValueOf(elf.ELFOSABI_86OPEN),
"ELFOSABI_AIX": reflect.ValueOf(elf.ELFOSABI_AIX),
"ELFOSABI_ARM": reflect.ValueOf(elf.ELFOSABI_ARM),
"ELFOSABI_AROS": reflect.ValueOf(elf.ELFOSABI_AROS),
"ELFOSABI_CLOUDABI": reflect.ValueOf(elf.ELFOSABI_CLOUDABI),
"ELFOSABI_FENIXOS": reflect.ValueOf(elf.ELFOSABI_FENIXOS),
"ELFOSABI_FREEBSD": reflect.ValueOf(elf.ELFOSABI_FREEBSD),
"ELFOSABI_HPUX": reflect.ValueOf(elf.ELFOSABI_HPUX),
"ELFOSABI_HURD": reflect.ValueOf(elf.ELFOSABI_HURD),
"ELFOSABI_IRIX": reflect.ValueOf(elf.ELFOSABI_IRIX),
"ELFOSABI_LINUX": reflect.ValueOf(elf.ELFOSABI_LINUX),
"ELFOSABI_MODESTO": reflect.ValueOf(elf.ELFOSABI_MODESTO),
"ELFOSABI_NETBSD": reflect.ValueOf(elf.ELFOSABI_NETBSD),
"ELFOSABI_NONE": reflect.ValueOf(elf.ELFOSABI_NONE),
"ELFOSABI_NSK": reflect.ValueOf(elf.ELFOSABI_NSK),
"ELFOSABI_OPENBSD": reflect.ValueOf(elf.ELFOSABI_OPENBSD),
"ELFOSABI_OPENVMS": reflect.ValueOf(elf.ELFOSABI_OPENVMS),
"ELFOSABI_SOLARIS": reflect.ValueOf(elf.ELFOSABI_SOLARIS),
"ELFOSABI_STANDALONE": reflect.ValueOf(elf.ELFOSABI_STANDALONE),
"ELFOSABI_TRU64": reflect.ValueOf(elf.ELFOSABI_TRU64),
"EM_386": reflect.ValueOf(elf.EM_386),
"EM_486": reflect.ValueOf(elf.EM_486),
"EM_56800EX": reflect.ValueOf(elf.EM_56800EX),
"EM_68HC05": reflect.ValueOf(elf.EM_68HC05),
"EM_68HC08": reflect.ValueOf(elf.EM_68HC08),
"EM_68HC11": reflect.ValueOf(elf.EM_68HC11),
"EM_68HC12": reflect.ValueOf(elf.EM_68HC12),
"EM_68HC16": reflect.ValueOf(elf.EM_68HC16),
"EM_68K": reflect.ValueOf(elf.EM_68K),
"EM_78KOR": reflect.ValueOf(elf.EM_78KOR),
"EM_8051": reflect.ValueOf(elf.EM_8051),
"EM_860": reflect.ValueOf(elf.EM_860),
"EM_88K": reflect.ValueOf(elf.EM_88K),
"EM_960": reflect.ValueOf(elf.EM_960),
"EM_AARCH64": reflect.ValueOf(elf.EM_AARCH64),
"EM_ALPHA": reflect.ValueOf(elf.EM_ALPHA),
"EM_ALPHA_STD": reflect.ValueOf(elf.EM_ALPHA_STD),
"EM_ALTERA_NIOS2": reflect.ValueOf(elf.EM_ALTERA_NIOS2),
"EM_AMDGPU": reflect.ValueOf(elf.EM_AMDGPU),
"EM_ARC": reflect.ValueOf(elf.EM_ARC),
"EM_ARCA": reflect.ValueOf(elf.EM_ARCA),
"EM_ARC_COMPACT": reflect.ValueOf(elf.EM_ARC_COMPACT),
"EM_ARC_COMPACT2": reflect.ValueOf(elf.EM_ARC_COMPACT2),
"EM_ARM": reflect.ValueOf(elf.EM_ARM),
"EM_AVR": reflect.ValueOf(elf.EM_AVR),
"EM_AVR32": reflect.ValueOf(elf.EM_AVR32),
"EM_BA1": reflect.ValueOf(elf.EM_BA1),
"EM_BA2": reflect.ValueOf(elf.EM_BA2),
"EM_BLACKFIN": reflect.ValueOf(elf.EM_BLACKFIN),
"EM_BPF": reflect.ValueOf(elf.EM_BPF),
"EM_C166": reflect.ValueOf(elf.EM_C166),
"EM_CDP": reflect.ValueOf(elf.EM_CDP),
"EM_CE": reflect.ValueOf(elf.EM_CE),
"EM_CLOUDSHIELD": reflect.ValueOf(elf.EM_CLOUDSHIELD),
"EM_COGE": reflect.ValueOf(elf.EM_COGE),
"EM_COLDFIRE": reflect.ValueOf(elf.EM_COLDFIRE),
"EM_COOL": reflect.ValueOf(elf.EM_COOL),
"EM_COREA_1ST": reflect.ValueOf(elf.EM_COREA_1ST),
"EM_COREA_2ND": reflect.ValueOf(elf.EM_COREA_2ND),
"EM_CR": reflect.ValueOf(elf.EM_CR),
"EM_CR16": reflect.ValueOf(elf.EM_CR16),
"EM_CRAYNV2": reflect.ValueOf(elf.EM_CRAYNV2),
"EM_CRIS": reflect.ValueOf(elf.EM_CRIS),
"EM_CRX": reflect.ValueOf(elf.EM_CRX),
"EM_CSR_KALIMBA": reflect.ValueOf(elf.EM_CSR_KALIMBA),
"EM_CUDA": reflect.ValueOf(elf.EM_CUDA),
"EM_CYPRESS_M8C": reflect.ValueOf(elf.EM_CYPRESS_M8C),
"EM_D10V": reflect.ValueOf(elf.EM_D10V),
"EM_D30V": reflect.ValueOf(elf.EM_D30V),
"EM_DSP24": reflect.ValueOf(elf.EM_DSP24),
"EM_DSPIC30F": reflect.ValueOf(elf.EM_DSPIC30F),
"EM_DXP": reflect.ValueOf(elf.EM_DXP),
"EM_ECOG1": reflect.ValueOf(elf.EM_ECOG1),
"EM_ECOG16": reflect.ValueOf(elf.EM_ECOG16),
"EM_ECOG1X": reflect.ValueOf(elf.EM_ECOG1X),
"EM_ECOG2": reflect.ValueOf(elf.EM_ECOG2),
"EM_ETPU": reflect.ValueOf(elf.EM_ETPU),
"EM_EXCESS": reflect.ValueOf(elf.EM_EXCESS),
"EM_F2MC16": reflect.ValueOf(elf.EM_F2MC16),
"EM_FIREPATH": reflect.ValueOf(elf.EM_FIREPATH),
"EM_FR20": reflect.ValueOf(elf.EM_FR20),
"EM_FR30": reflect.ValueOf(elf.EM_FR30),
"EM_FT32": reflect.ValueOf(elf.EM_FT32),
"EM_FX66": reflect.ValueOf(elf.EM_FX66),
"EM_H8S": reflect.ValueOf(elf.EM_H8S),
"EM_H8_300": reflect.ValueOf(elf.EM_H8_300),
"EM_H8_300H": reflect.ValueOf(elf.EM_H8_300H),
"EM_H8_500": reflect.ValueOf(elf.EM_H8_500),
"EM_HUANY": reflect.ValueOf(elf.EM_HUANY),
"EM_IA_64": reflect.ValueOf(elf.EM_IA_64),
"EM_INTEL205": reflect.ValueOf(elf.EM_INTEL205),
"EM_INTEL206": reflect.ValueOf(elf.EM_INTEL206),
"EM_INTEL207": reflect.ValueOf(elf.EM_INTEL207),
"EM_INTEL208": reflect.ValueOf(elf.EM_INTEL208),
"EM_INTEL209": reflect.ValueOf(elf.EM_INTEL209),
"EM_IP2K": reflect.ValueOf(elf.EM_IP2K),
"EM_JAVELIN": reflect.ValueOf(elf.EM_JAVELIN),
"EM_K10M": reflect.ValueOf(elf.EM_K10M),
"EM_KM32": reflect.ValueOf(elf.EM_KM32),
"EM_KMX16": reflect.ValueOf(elf.EM_KMX16),
"EM_KMX32": reflect.ValueOf(elf.EM_KMX32),
"EM_KMX8": reflect.ValueOf(elf.EM_KMX8),
"EM_KVARC": reflect.ValueOf(elf.EM_KVARC),
"EM_L10M": reflect.ValueOf(elf.EM_L10M),
"EM_LANAI": reflect.ValueOf(elf.EM_LANAI),
"EM_LATTICEMICO32": reflect.ValueOf(elf.EM_LATTICEMICO32),
"EM_LOONGARCH": reflect.ValueOf(elf.EM_LOONGARCH),
"EM_M16C": reflect.ValueOf(elf.EM_M16C),
"EM_M32": reflect.ValueOf(elf.EM_M32),
"EM_M32C": reflect.ValueOf(elf.EM_M32C),
"EM_M32R": reflect.ValueOf(elf.EM_M32R),
"EM_MANIK": reflect.ValueOf(elf.EM_MANIK),
"EM_MAX": reflect.ValueOf(elf.EM_MAX),
"EM_MAXQ30": reflect.ValueOf(elf.EM_MAXQ30),
"EM_MCHP_PIC": reflect.ValueOf(elf.EM_MCHP_PIC),
"EM_MCST_ELBRUS": reflect.ValueOf(elf.EM_MCST_ELBRUS),
"EM_ME16": reflect.ValueOf(elf.EM_ME16),
"EM_METAG": reflect.ValueOf(elf.EM_METAG),
"EM_MICROBLAZE": reflect.ValueOf(elf.EM_MICROBLAZE),
"EM_MIPS": reflect.ValueOf(elf.EM_MIPS),
"EM_MIPS_RS3_LE": reflect.ValueOf(elf.EM_MIPS_RS3_LE),
"EM_MIPS_RS4_BE": reflect.ValueOf(elf.EM_MIPS_RS4_BE),
"EM_MIPS_X": reflect.ValueOf(elf.EM_MIPS_X),
"EM_MMA": reflect.ValueOf(elf.EM_MMA),
"EM_MMDSP_PLUS": reflect.ValueOf(elf.EM_MMDSP_PLUS),
"EM_MMIX": reflect.ValueOf(elf.EM_MMIX),
"EM_MN10200": reflect.ValueOf(elf.EM_MN10200),
"EM_MN10300": reflect.ValueOf(elf.EM_MN10300),
"EM_MOXIE": reflect.ValueOf(elf.EM_MOXIE),
"EM_MSP430": reflect.ValueOf(elf.EM_MSP430),
"EM_NCPU": reflect.ValueOf(elf.EM_NCPU),
"EM_NDR1": reflect.ValueOf(elf.EM_NDR1),
"EM_NDS32": reflect.ValueOf(elf.EM_NDS32),
"EM_NONE": reflect.ValueOf(elf.EM_NONE),
"EM_NORC": reflect.ValueOf(elf.EM_NORC),
"EM_NS32K": reflect.ValueOf(elf.EM_NS32K),
"EM_OPEN8": reflect.ValueOf(elf.EM_OPEN8),
"EM_OPENRISC": reflect.ValueOf(elf.EM_OPENRISC),
"EM_PARISC": reflect.ValueOf(elf.EM_PARISC),
"EM_PCP": reflect.ValueOf(elf.EM_PCP),
"EM_PDP10": reflect.ValueOf(elf.EM_PDP10),
"EM_PDP11": reflect.ValueOf(elf.EM_PDP11),
"EM_PDSP": reflect.ValueOf(elf.EM_PDSP),
"EM_PJ": reflect.ValueOf(elf.EM_PJ),
"EM_PPC": reflect.ValueOf(elf.EM_PPC),
"EM_PPC64": reflect.ValueOf(elf.EM_PPC64),
"EM_PRISM": reflect.ValueOf(elf.EM_PRISM),
"EM_QDSP6": reflect.ValueOf(elf.EM_QDSP6),
"EM_R32C": reflect.ValueOf(elf.EM_R32C),
"EM_RCE": reflect.ValueOf(elf.EM_RCE),
"EM_RH32": reflect.ValueOf(elf.EM_RH32),
"EM_RISCV": reflect.ValueOf(elf.EM_RISCV),
"EM_RL78": reflect.ValueOf(elf.EM_RL78),
"EM_RS08": reflect.ValueOf(elf.EM_RS08),
"EM_RX": reflect.ValueOf(elf.EM_RX),
"EM_S370": reflect.ValueOf(elf.EM_S370),
"EM_S390": reflect.ValueOf(elf.EM_S390),
"EM_SCORE7": reflect.ValueOf(elf.EM_SCORE7),
"EM_SEP": reflect.ValueOf(elf.EM_SEP),
"EM_SE_C17": reflect.ValueOf(elf.EM_SE_C17),
"EM_SE_C33": reflect.ValueOf(elf.EM_SE_C33),
"EM_SH": reflect.ValueOf(elf.EM_SH),
"EM_SHARC": reflect.ValueOf(elf.EM_SHARC),
"EM_SLE9X": reflect.ValueOf(elf.EM_SLE9X),
"EM_SNP1K": reflect.ValueOf(elf.EM_SNP1K),
"EM_SPARC": reflect.ValueOf(elf.EM_SPARC),
"EM_SPARC32PLUS": reflect.ValueOf(elf.EM_SPARC32PLUS),
"EM_SPARCV9": reflect.ValueOf(elf.EM_SPARCV9),
"EM_ST100": reflect.ValueOf(elf.EM_ST100),
"EM_ST19": reflect.ValueOf(elf.EM_ST19),
"EM_ST200": reflect.ValueOf(elf.EM_ST200),
"EM_ST7": reflect.ValueOf(elf.EM_ST7),
"EM_ST9PLUS": reflect.ValueOf(elf.EM_ST9PLUS),
"EM_STARCORE": reflect.ValueOf(elf.EM_STARCORE),
"EM_STM8": reflect.ValueOf(elf.EM_STM8),
"EM_STXP7X": reflect.ValueOf(elf.EM_STXP7X),
"EM_SVX": reflect.ValueOf(elf.EM_SVX),
"EM_TILE64": reflect.ValueOf(elf.EM_TILE64),
"EM_TILEGX": reflect.ValueOf(elf.EM_TILEGX),
"EM_TILEPRO": reflect.ValueOf(elf.EM_TILEPRO),
"EM_TINYJ": reflect.ValueOf(elf.EM_TINYJ),
"EM_TI_ARP32": reflect.ValueOf(elf.EM_TI_ARP32),
"EM_TI_C2000": reflect.ValueOf(elf.EM_TI_C2000),
"EM_TI_C5500": reflect.ValueOf(elf.EM_TI_C5500),
"EM_TI_C6000": reflect.ValueOf(elf.EM_TI_C6000),
"EM_TI_PRU": reflect.ValueOf(elf.EM_TI_PRU),
"EM_TMM_GPP": reflect.ValueOf(elf.EM_TMM_GPP),
"EM_TPC": reflect.ValueOf(elf.EM_TPC),
"EM_TRICORE": reflect.ValueOf(elf.EM_TRICORE),
"EM_TRIMEDIA": reflect.ValueOf(elf.EM_TRIMEDIA),
"EM_TSK3000": reflect.ValueOf(elf.EM_TSK3000),
"EM_UNICORE": reflect.ValueOf(elf.EM_UNICORE),
"EM_V800": reflect.ValueOf(elf.EM_V800),
"EM_V850": reflect.ValueOf(elf.EM_V850),
"EM_VAX": reflect.ValueOf(elf.EM_VAX),
"EM_VIDEOCORE": reflect.ValueOf(elf.EM_VIDEOCORE),
"EM_VIDEOCORE3": reflect.ValueOf(elf.EM_VIDEOCORE3),
"EM_VIDEOCORE5": reflect.ValueOf(elf.EM_VIDEOCORE5),
"EM_VISIUM": reflect.ValueOf(elf.EM_VISIUM),
"EM_VPP500": reflect.ValueOf(elf.EM_VPP500),
"EM_X86_64": reflect.ValueOf(elf.EM_X86_64),
"EM_XCORE": reflect.ValueOf(elf.EM_XCORE),
"EM_XGATE": reflect.ValueOf(elf.EM_XGATE),
"EM_XIMO16": reflect.ValueOf(elf.EM_XIMO16),
"EM_XTENSA": reflect.ValueOf(elf.EM_XTENSA),
"EM_Z80": reflect.ValueOf(elf.EM_Z80),
"EM_ZSP": reflect.ValueOf(elf.EM_ZSP),
"ET_CORE": reflect.ValueOf(elf.ET_CORE),
"ET_DYN": reflect.ValueOf(elf.ET_DYN),
"ET_EXEC": reflect.ValueOf(elf.ET_EXEC),
"ET_HIOS": reflect.ValueOf(elf.ET_HIOS),
"ET_HIPROC": reflect.ValueOf(elf.ET_HIPROC),
"ET_LOOS": reflect.ValueOf(elf.ET_LOOS),
"ET_LOPROC": reflect.ValueOf(elf.ET_LOPROC),
"ET_NONE": reflect.ValueOf(elf.ET_NONE),
"ET_REL": reflect.ValueOf(elf.ET_REL),
"EV_CURRENT": reflect.ValueOf(elf.EV_CURRENT),
"EV_NONE": reflect.ValueOf(elf.EV_NONE),
"ErrNoSymbols": reflect.ValueOf(&elf.ErrNoSymbols).Elem(),
"NT_FPREGSET": reflect.ValueOf(elf.NT_FPREGSET),
"NT_PRPSINFO": reflect.ValueOf(elf.NT_PRPSINFO),
"NT_PRSTATUS": reflect.ValueOf(elf.NT_PRSTATUS),
"NewFile": reflect.ValueOf(elf.NewFile),
"Open": reflect.ValueOf(elf.Open),
"PF_MASKOS": reflect.ValueOf(elf.PF_MASKOS),
"PF_MASKPROC": reflect.ValueOf(elf.PF_MASKPROC),
"PF_R": reflect.ValueOf(elf.PF_R),
"PF_W": reflect.ValueOf(elf.PF_W),
"PF_X": reflect.ValueOf(elf.PF_X),
"PT_AARCH64_ARCHEXT": reflect.ValueOf(elf.PT_AARCH64_ARCHEXT),
"PT_AARCH64_UNWIND": reflect.ValueOf(elf.PT_AARCH64_UNWIND),
"PT_ARM_ARCHEXT": reflect.ValueOf(elf.PT_ARM_ARCHEXT),
"PT_ARM_EXIDX": reflect.ValueOf(elf.PT_ARM_EXIDX),
"PT_DYNAMIC": reflect.ValueOf(elf.PT_DYNAMIC),
"PT_GNU_EH_FRAME": reflect.ValueOf(elf.PT_GNU_EH_FRAME),
"PT_GNU_MBIND_HI": reflect.ValueOf(elf.PT_GNU_MBIND_HI),
"PT_GNU_MBIND_LO": reflect.ValueOf(elf.PT_GNU_MBIND_LO),
"PT_GNU_PROPERTY": reflect.ValueOf(elf.PT_GNU_PROPERTY),
"PT_GNU_RELRO": reflect.ValueOf(elf.PT_GNU_RELRO),
"PT_GNU_STACK": reflect.ValueOf(elf.PT_GNU_STACK),
"PT_HIOS": reflect.ValueOf(elf.PT_HIOS),
"PT_HIPROC": reflect.ValueOf(elf.PT_HIPROC),
"PT_INTERP": reflect.ValueOf(elf.PT_INTERP),
"PT_LOAD": reflect.ValueOf(elf.PT_LOAD),
"PT_LOOS": reflect.ValueOf(elf.PT_LOOS),
"PT_LOPROC": reflect.ValueOf(elf.PT_LOPROC),
"PT_MIPS_ABIFLAGS": reflect.ValueOf(elf.PT_MIPS_ABIFLAGS),
"PT_MIPS_OPTIONS": reflect.ValueOf(elf.PT_MIPS_OPTIONS),
"PT_MIPS_REGINFO": reflect.ValueOf(elf.PT_MIPS_REGINFO),
"PT_MIPS_RTPROC": reflect.ValueOf(elf.PT_MIPS_RTPROC),
"PT_NOTE": reflect.ValueOf(elf.PT_NOTE),
"PT_NULL": reflect.ValueOf(elf.PT_NULL),
"PT_OPENBSD_BOOTDATA": reflect.ValueOf(elf.PT_OPENBSD_BOOTDATA),
"PT_OPENBSD_RANDOMIZE": reflect.ValueOf(elf.PT_OPENBSD_RANDOMIZE),
"PT_OPENBSD_WXNEEDED": reflect.ValueOf(elf.PT_OPENBSD_WXNEEDED),
"PT_PAX_FLAGS": reflect.ValueOf(elf.PT_PAX_FLAGS),
"PT_PHDR": reflect.ValueOf(elf.PT_PHDR),
"PT_S390_PGSTE": reflect.ValueOf(elf.PT_S390_PGSTE),
"PT_SHLIB": reflect.ValueOf(elf.PT_SHLIB),
"PT_SUNWSTACK": reflect.ValueOf(elf.PT_SUNWSTACK),
"PT_SUNW_EH_FRAME": reflect.ValueOf(elf.PT_SUNW_EH_FRAME),
"PT_TLS": reflect.ValueOf(elf.PT_TLS),
"R_386_16": reflect.ValueOf(elf.R_386_16),
"R_386_32": reflect.ValueOf(elf.R_386_32),
"R_386_32PLT": reflect.ValueOf(elf.R_386_32PLT),
"R_386_8": reflect.ValueOf(elf.R_386_8),
"R_386_COPY": reflect.ValueOf(elf.R_386_COPY),
"R_386_GLOB_DAT": reflect.ValueOf(elf.R_386_GLOB_DAT),
"R_386_GOT32": reflect.ValueOf(elf.R_386_GOT32),
"R_386_GOT32X": reflect.ValueOf(elf.R_386_GOT32X),
"R_386_GOTOFF": reflect.ValueOf(elf.R_386_GOTOFF),
"R_386_GOTPC": reflect.ValueOf(elf.R_386_GOTPC),
"R_386_IRELATIVE": reflect.ValueOf(elf.R_386_IRELATIVE),
"R_386_JMP_SLOT": reflect.ValueOf(elf.R_386_JMP_SLOT),
"R_386_NONE": reflect.ValueOf(elf.R_386_NONE),
"R_386_PC16": reflect.ValueOf(elf.R_386_PC16),
"R_386_PC32": reflect.ValueOf(elf.R_386_PC32),
"R_386_PC8": reflect.ValueOf(elf.R_386_PC8),
"R_386_PLT32": reflect.ValueOf(elf.R_386_PLT32),
"R_386_RELATIVE": reflect.ValueOf(elf.R_386_RELATIVE),
"R_386_SIZE32": reflect.ValueOf(elf.R_386_SIZE32),
"R_386_TLS_DESC": reflect.ValueOf(elf.R_386_TLS_DESC),
"R_386_TLS_DESC_CALL": reflect.ValueOf(elf.R_386_TLS_DESC_CALL),
"R_386_TLS_DTPMOD32": reflect.ValueOf(elf.R_386_TLS_DTPMOD32),
"R_386_TLS_DTPOFF32": reflect.ValueOf(elf.R_386_TLS_DTPOFF32),
"R_386_TLS_GD": reflect.ValueOf(elf.R_386_TLS_GD),
"R_386_TLS_GD_32": reflect.ValueOf(elf.R_386_TLS_GD_32),
"R_386_TLS_GD_CALL": reflect.ValueOf(elf.R_386_TLS_GD_CALL),
"R_386_TLS_GD_POP": reflect.ValueOf(elf.R_386_TLS_GD_POP),
"R_386_TLS_GD_PUSH": reflect.ValueOf(elf.R_386_TLS_GD_PUSH),
"R_386_TLS_GOTDESC": reflect.ValueOf(elf.R_386_TLS_GOTDESC),
"R_386_TLS_GOTIE": reflect.ValueOf(elf.R_386_TLS_GOTIE),
"R_386_TLS_IE": reflect.ValueOf(elf.R_386_TLS_IE),
"R_386_TLS_IE_32": reflect.ValueOf(elf.R_386_TLS_IE_32),
"R_386_TLS_LDM": reflect.ValueOf(elf.R_386_TLS_LDM),
"R_386_TLS_LDM_32": reflect.ValueOf(elf.R_386_TLS_LDM_32),
"R_386_TLS_LDM_CALL": reflect.ValueOf(elf.R_386_TLS_LDM_CALL),
"R_386_TLS_LDM_POP": reflect.ValueOf(elf.R_386_TLS_LDM_POP),
"R_386_TLS_LDM_PUSH": reflect.ValueOf(elf.R_386_TLS_LDM_PUSH),
"R_386_TLS_LDO_32": reflect.ValueOf(elf.R_386_TLS_LDO_32),
"R_386_TLS_LE": reflect.ValueOf(elf.R_386_TLS_LE),
"R_386_TLS_LE_32": reflect.ValueOf(elf.R_386_TLS_LE_32),
"R_386_TLS_TPOFF": reflect.ValueOf(elf.R_386_TLS_TPOFF),
"R_386_TLS_TPOFF32": reflect.ValueOf(elf.R_386_TLS_TPOFF32),
"R_390_12": reflect.ValueOf(elf.R_390_12),
"R_390_16": reflect.ValueOf(elf.R_390_16),
"R_390_20": reflect.ValueOf(elf.R_390_20),
"R_390_32": reflect.ValueOf(elf.R_390_32),
"R_390_64": reflect.ValueOf(elf.R_390_64),
"R_390_8": reflect.ValueOf(elf.R_390_8),
"R_390_COPY": reflect.ValueOf(elf.R_390_COPY),
"R_390_GLOB_DAT": reflect.ValueOf(elf.R_390_GLOB_DAT),
"R_390_GOT12": reflect.ValueOf(elf.R_390_GOT12),
"R_390_GOT16": reflect.ValueOf(elf.R_390_GOT16),
"R_390_GOT20": reflect.ValueOf(elf.R_390_GOT20),
"R_390_GOT32": reflect.ValueOf(elf.R_390_GOT32),
"R_390_GOT64": reflect.ValueOf(elf.R_390_GOT64),
"R_390_GOTENT": reflect.ValueOf(elf.R_390_GOTENT),
"R_390_GOTOFF": reflect.ValueOf(elf.R_390_GOTOFF),
"R_390_GOTOFF16": reflect.ValueOf(elf.R_390_GOTOFF16),
"R_390_GOTOFF64": reflect.ValueOf(elf.R_390_GOTOFF64),
"R_390_GOTPC": reflect.ValueOf(elf.R_390_GOTPC),
"R_390_GOTPCDBL": reflect.ValueOf(elf.R_390_GOTPCDBL),
"R_390_GOTPLT12": reflect.ValueOf(elf.R_390_GOTPLT12),
"R_390_GOTPLT16": reflect.ValueOf(elf.R_390_GOTPLT16),
"R_390_GOTPLT20": reflect.ValueOf(elf.R_390_GOTPLT20),
"R_390_GOTPLT32": reflect.ValueOf(elf.R_390_GOTPLT32),
"R_390_GOTPLT64": reflect.ValueOf(elf.R_390_GOTPLT64),
"R_390_GOTPLTENT": reflect.ValueOf(elf.R_390_GOTPLTENT),
"R_390_GOTPLTOFF16": reflect.ValueOf(elf.R_390_GOTPLTOFF16),
"R_390_GOTPLTOFF32": reflect.ValueOf(elf.R_390_GOTPLTOFF32),
"R_390_GOTPLTOFF64": reflect.ValueOf(elf.R_390_GOTPLTOFF64),
"R_390_JMP_SLOT": reflect.ValueOf(elf.R_390_JMP_SLOT),
"R_390_NONE": reflect.ValueOf(elf.R_390_NONE),
"R_390_PC16": reflect.ValueOf(elf.R_390_PC16),
"R_390_PC16DBL": reflect.ValueOf(elf.R_390_PC16DBL),
"R_390_PC32": reflect.ValueOf(elf.R_390_PC32),
"R_390_PC32DBL": reflect.ValueOf(elf.R_390_PC32DBL),
"R_390_PC64": reflect.ValueOf(elf.R_390_PC64),
"R_390_PLT16DBL": reflect.ValueOf(elf.R_390_PLT16DBL),
"R_390_PLT32": reflect.ValueOf(elf.R_390_PLT32),
"R_390_PLT32DBL": reflect.ValueOf(elf.R_390_PLT32DBL),
"R_390_PLT64": reflect.ValueOf(elf.R_390_PLT64),
"R_390_RELATIVE": reflect.ValueOf(elf.R_390_RELATIVE),
"R_390_TLS_DTPMOD": reflect.ValueOf(elf.R_390_TLS_DTPMOD),
"R_390_TLS_DTPOFF": reflect.ValueOf(elf.R_390_TLS_DTPOFF),
"R_390_TLS_GD32": reflect.ValueOf(elf.R_390_TLS_GD32),
"R_390_TLS_GD64": reflect.ValueOf(elf.R_390_TLS_GD64),
"R_390_TLS_GDCALL": reflect.ValueOf(elf.R_390_TLS_GDCALL),
"R_390_TLS_GOTIE12": reflect.ValueOf(elf.R_390_TLS_GOTIE12),
"R_390_TLS_GOTIE20": reflect.ValueOf(elf.R_390_TLS_GOTIE20),
"R_390_TLS_GOTIE32": reflect.ValueOf(elf.R_390_TLS_GOTIE32),
"R_390_TLS_GOTIE64": reflect.ValueOf(elf.R_390_TLS_GOTIE64),
"R_390_TLS_IE32": reflect.ValueOf(elf.R_390_TLS_IE32),
"R_390_TLS_IE64": reflect.ValueOf(elf.R_390_TLS_IE64),
"R_390_TLS_IEENT": reflect.ValueOf(elf.R_390_TLS_IEENT),
"R_390_TLS_LDCALL": reflect.ValueOf(elf.R_390_TLS_LDCALL),
"R_390_TLS_LDM32": reflect.ValueOf(elf.R_390_TLS_LDM32),
"R_390_TLS_LDM64": reflect.ValueOf(elf.R_390_TLS_LDM64),
"R_390_TLS_LDO32": reflect.ValueOf(elf.R_390_TLS_LDO32),
"R_390_TLS_LDO64": reflect.ValueOf(elf.R_390_TLS_LDO64),
"R_390_TLS_LE32": reflect.ValueOf(elf.R_390_TLS_LE32),
"R_390_TLS_LE64": reflect.ValueOf(elf.R_390_TLS_LE64),
"R_390_TLS_LOAD": reflect.ValueOf(elf.R_390_TLS_LOAD),
"R_390_TLS_TPOFF": reflect.ValueOf(elf.R_390_TLS_TPOFF),
"R_AARCH64_ABS16": reflect.ValueOf(elf.R_AARCH64_ABS16),
"R_AARCH64_ABS32": reflect.ValueOf(elf.R_AARCH64_ABS32),
"R_AARCH64_ABS64": reflect.ValueOf(elf.R_AARCH64_ABS64),
"R_AARCH64_ADD_ABS_LO12_NC": reflect.ValueOf(elf.R_AARCH64_ADD_ABS_LO12_NC),
"R_AARCH64_ADR_GOT_PAGE": reflect.ValueOf(elf.R_AARCH64_ADR_GOT_PAGE),
"R_AARCH64_ADR_PREL_LO21": reflect.ValueOf(elf.R_AARCH64_ADR_PREL_LO21),
"R_AARCH64_ADR_PREL_PG_HI21": reflect.ValueOf(elf.R_AARCH64_ADR_PREL_PG_HI21),
"R_AARCH64_ADR_PREL_PG_HI21_NC": reflect.ValueOf(elf.R_AARCH64_ADR_PREL_PG_HI21_NC),
"R_AARCH64_CALL26": reflect.ValueOf(elf.R_AARCH64_CALL26),
"R_AARCH64_CONDBR19": reflect.ValueOf(elf.R_AARCH64_CONDBR19),
"R_AARCH64_COPY": reflect.ValueOf(elf.R_AARCH64_COPY),
"R_AARCH64_GLOB_DAT": reflect.ValueOf(elf.R_AARCH64_GLOB_DAT),
"R_AARCH64_GOT_LD_PREL19": reflect.ValueOf(elf.R_AARCH64_GOT_LD_PREL19),
"R_AARCH64_IRELATIVE": reflect.ValueOf(elf.R_AARCH64_IRELATIVE),
"R_AARCH64_JUMP26": reflect.ValueOf(elf.R_AARCH64_JUMP26),
"R_AARCH64_JUMP_SLOT": reflect.ValueOf(elf.R_AARCH64_JUMP_SLOT),
"R_AARCH64_LD64_GOTOFF_LO15": reflect.ValueOf(elf.R_AARCH64_LD64_GOTOFF_LO15),
"R_AARCH64_LD64_GOTPAGE_LO15": reflect.ValueOf(elf.R_AARCH64_LD64_GOTPAGE_LO15),
"R_AARCH64_LD64_GOT_LO12_NC": reflect.ValueOf(elf.R_AARCH64_LD64_GOT_LO12_NC),
"R_AARCH64_LDST128_ABS_LO12_NC": reflect.ValueOf(elf.R_AARCH64_LDST128_ABS_LO12_NC),
"R_AARCH64_LDST16_ABS_LO12_NC": reflect.ValueOf(elf.R_AARCH64_LDST16_ABS_LO12_NC),
"R_AARCH64_LDST32_ABS_LO12_NC": reflect.ValueOf(elf.R_AARCH64_LDST32_ABS_LO12_NC),
"R_AARCH64_LDST64_ABS_LO12_NC": reflect.ValueOf(elf.R_AARCH64_LDST64_ABS_LO12_NC),
"R_AARCH64_LDST8_ABS_LO12_NC": reflect.ValueOf(elf.R_AARCH64_LDST8_ABS_LO12_NC),
"R_AARCH64_LD_PREL_LO19": reflect.ValueOf(elf.R_AARCH64_LD_PREL_LO19),
"R_AARCH64_MOVW_SABS_G0": reflect.ValueOf(elf.R_AARCH64_MOVW_SABS_G0),
"R_AARCH64_MOVW_SABS_G1": reflect.ValueOf(elf.R_AARCH64_MOVW_SABS_G1),
"R_AARCH64_MOVW_SABS_G2": reflect.ValueOf(elf.R_AARCH64_MOVW_SABS_G2),
"R_AARCH64_MOVW_UABS_G0": reflect.ValueOf(elf.R_AARCH64_MOVW_UABS_G0),
"R_AARCH64_MOVW_UABS_G0_NC": reflect.ValueOf(elf.R_AARCH64_MOVW_UABS_G0_NC),
"R_AARCH64_MOVW_UABS_G1": reflect.ValueOf(elf.R_AARCH64_MOVW_UABS_G1),
"R_AARCH64_MOVW_UABS_G1_NC": reflect.ValueOf(elf.R_AARCH64_MOVW_UABS_G1_NC),
"R_AARCH64_MOVW_UABS_G2": reflect.ValueOf(elf.R_AARCH64_MOVW_UABS_G2),
"R_AARCH64_MOVW_UABS_G2_NC": reflect.ValueOf(elf.R_AARCH64_MOVW_UABS_G2_NC),
"R_AARCH64_MOVW_UABS_G3": reflect.ValueOf(elf.R_AARCH64_MOVW_UABS_G3),
"R_AARCH64_NONE": reflect.ValueOf(elf.R_AARCH64_NONE),
"R_AARCH64_NULL": reflect.ValueOf(elf.R_AARCH64_NULL),
"R_AARCH64_P32_ABS16": reflect.ValueOf(elf.R_AARCH64_P32_ABS16),
"R_AARCH64_P32_ABS32": reflect.ValueOf(elf.R_AARCH64_P32_ABS32),
"R_AARCH64_P32_ADD_ABS_LO12_NC": reflect.ValueOf(elf.R_AARCH64_P32_ADD_ABS_LO12_NC),
"R_AARCH64_P32_ADR_GOT_PAGE": reflect.ValueOf(elf.R_AARCH64_P32_ADR_GOT_PAGE),
"R_AARCH64_P32_ADR_PREL_LO21": reflect.ValueOf(elf.R_AARCH64_P32_ADR_PREL_LO21),
"R_AARCH64_P32_ADR_PREL_PG_HI21": reflect.ValueOf(elf.R_AARCH64_P32_ADR_PREL_PG_HI21),
"R_AARCH64_P32_CALL26": reflect.ValueOf(elf.R_AARCH64_P32_CALL26),
"R_AARCH64_P32_CONDBR19": reflect.ValueOf(elf.R_AARCH64_P32_CONDBR19),
"R_AARCH64_P32_COPY": reflect.ValueOf(elf.R_AARCH64_P32_COPY),
"R_AARCH64_P32_GLOB_DAT": reflect.ValueOf(elf.R_AARCH64_P32_GLOB_DAT),
"R_AARCH64_P32_GOT_LD_PREL19": reflect.ValueOf(elf.R_AARCH64_P32_GOT_LD_PREL19),
"R_AARCH64_P32_IRELATIVE": reflect.ValueOf(elf.R_AARCH64_P32_IRELATIVE),
"R_AARCH64_P32_JUMP26": reflect.ValueOf(elf.R_AARCH64_P32_JUMP26),
"R_AARCH64_P32_JUMP_SLOT": reflect.ValueOf(elf.R_AARCH64_P32_JUMP_SLOT),
"R_AARCH64_P32_LD32_GOT_LO12_NC": reflect.ValueOf(elf.R_AARCH64_P32_LD32_GOT_LO12_NC),
"R_AARCH64_P32_LDST128_ABS_LO12_NC": reflect.ValueOf(elf.R_AARCH64_P32_LDST128_ABS_LO12_NC),
"R_AARCH64_P32_LDST16_ABS_LO12_NC": reflect.ValueOf(elf.R_AARCH64_P32_LDST16_ABS_LO12_NC),
"R_AARCH64_P32_LDST32_ABS_LO12_NC": reflect.ValueOf(elf.R_AARCH64_P32_LDST32_ABS_LO12_NC),
"R_AARCH64_P32_LDST64_ABS_LO12_NC": reflect.ValueOf(elf.R_AARCH64_P32_LDST64_ABS_LO12_NC),
"R_AARCH64_P32_LDST8_ABS_LO12_NC": reflect.ValueOf(elf.R_AARCH64_P32_LDST8_ABS_LO12_NC),
"R_AARCH64_P32_LD_PREL_LO19": reflect.ValueOf(elf.R_AARCH64_P32_LD_PREL_LO19),
"R_AARCH64_P32_MOVW_SABS_G0": reflect.ValueOf(elf.R_AARCH64_P32_MOVW_SABS_G0),
"R_AARCH64_P32_MOVW_UABS_G0": reflect.ValueOf(elf.R_AARCH64_P32_MOVW_UABS_G0),
"R_AARCH64_P32_MOVW_UABS_G0_NC": reflect.ValueOf(elf.R_AARCH64_P32_MOVW_UABS_G0_NC),
"R_AARCH64_P32_MOVW_UABS_G1": reflect.ValueOf(elf.R_AARCH64_P32_MOVW_UABS_G1),
"R_AARCH64_P32_PREL16": reflect.ValueOf(elf.R_AARCH64_P32_PREL16),
"R_AARCH64_P32_PREL32": reflect.ValueOf(elf.R_AARCH64_P32_PREL32),
"R_AARCH64_P32_RELATIVE": reflect.ValueOf(elf.R_AARCH64_P32_RELATIVE),
"R_AARCH64_P32_TLSDESC": reflect.ValueOf(elf.R_AARCH64_P32_TLSDESC),
"R_AARCH64_P32_TLSDESC_ADD_LO12_NC": reflect.ValueOf(elf.R_AARCH64_P32_TLSDESC_ADD_LO12_NC),
"R_AARCH64_P32_TLSDESC_ADR_PAGE21": reflect.ValueOf(elf.R_AARCH64_P32_TLSDESC_ADR_PAGE21),
"R_AARCH64_P32_TLSDESC_ADR_PREL21": reflect.ValueOf(elf.R_AARCH64_P32_TLSDESC_ADR_PREL21),
"R_AARCH64_P32_TLSDESC_CALL": reflect.ValueOf(elf.R_AARCH64_P32_TLSDESC_CALL),
"R_AARCH64_P32_TLSDESC_LD32_LO12_NC": reflect.ValueOf(elf.R_AARCH64_P32_TLSDESC_LD32_LO12_NC),
"R_AARCH64_P32_TLSDESC_LD_PREL19": reflect.ValueOf(elf.R_AARCH64_P32_TLSDESC_LD_PREL19),
"R_AARCH64_P32_TLSGD_ADD_LO12_NC": reflect.ValueOf(elf.R_AARCH64_P32_TLSGD_ADD_LO12_NC),
"R_AARCH64_P32_TLSGD_ADR_PAGE21": reflect.ValueOf(elf.R_AARCH64_P32_TLSGD_ADR_PAGE21),
"R_AARCH64_P32_TLSIE_ADR_GOTTPREL_PAGE21": reflect.ValueOf(elf.R_AARCH64_P32_TLSIE_ADR_GOTTPREL_PAGE21),
"R_AARCH64_P32_TLSIE_LD32_GOTTPREL_LO12_NC": reflect.ValueOf(elf.R_AARCH64_P32_TLSIE_LD32_GOTTPREL_LO12_NC),
"R_AARCH64_P32_TLSIE_LD_GOTTPREL_PREL19": reflect.ValueOf(elf.R_AARCH64_P32_TLSIE_LD_GOTTPREL_PREL19),
"R_AARCH64_P32_TLSLE_ADD_TPREL_HI12": reflect.ValueOf(elf.R_AARCH64_P32_TLSLE_ADD_TPREL_HI12),
"R_AARCH64_P32_TLSLE_ADD_TPREL_LO12": reflect.ValueOf(elf.R_AARCH64_P32_TLSLE_ADD_TPREL_LO12),
"R_AARCH64_P32_TLSLE_ADD_TPREL_LO12_NC": reflect.ValueOf(elf.R_AARCH64_P32_TLSLE_ADD_TPREL_LO12_NC),
"R_AARCH64_P32_TLSLE_MOVW_TPREL_G0": reflect.ValueOf(elf.R_AARCH64_P32_TLSLE_MOVW_TPREL_G0),
"R_AARCH64_P32_TLSLE_MOVW_TPREL_G0_NC": reflect.ValueOf(elf.R_AARCH64_P32_TLSLE_MOVW_TPREL_G0_NC),
"R_AARCH64_P32_TLSLE_MOVW_TPREL_G1": reflect.ValueOf(elf.R_AARCH64_P32_TLSLE_MOVW_TPREL_G1),
"R_AARCH64_P32_TLS_DTPMOD": reflect.ValueOf(elf.R_AARCH64_P32_TLS_DTPMOD),
"R_AARCH64_P32_TLS_DTPREL": reflect.ValueOf(elf.R_AARCH64_P32_TLS_DTPREL),
"R_AARCH64_P32_TLS_TPREL": reflect.ValueOf(elf.R_AARCH64_P32_TLS_TPREL),
"R_AARCH64_P32_TSTBR14": reflect.ValueOf(elf.R_AARCH64_P32_TSTBR14),
"R_AARCH64_PREL16": reflect.ValueOf(elf.R_AARCH64_PREL16),
"R_AARCH64_PREL32": reflect.ValueOf(elf.R_AARCH64_PREL32),
"R_AARCH64_PREL64": reflect.ValueOf(elf.R_AARCH64_PREL64),
"R_AARCH64_RELATIVE": reflect.ValueOf(elf.R_AARCH64_RELATIVE),
"R_AARCH64_TLSDESC": reflect.ValueOf(elf.R_AARCH64_TLSDESC),
"R_AARCH64_TLSDESC_ADD": reflect.ValueOf(elf.R_AARCH64_TLSDESC_ADD),
"R_AARCH64_TLSDESC_ADD_LO12_NC": reflect.ValueOf(elf.R_AARCH64_TLSDESC_ADD_LO12_NC),
"R_AARCH64_TLSDESC_ADR_PAGE21": reflect.ValueOf(elf.R_AARCH64_TLSDESC_ADR_PAGE21),
"R_AARCH64_TLSDESC_ADR_PREL21": reflect.ValueOf(elf.R_AARCH64_TLSDESC_ADR_PREL21),
"R_AARCH64_TLSDESC_CALL": reflect.ValueOf(elf.R_AARCH64_TLSDESC_CALL),
"R_AARCH64_TLSDESC_LD64_LO12_NC": reflect.ValueOf(elf.R_AARCH64_TLSDESC_LD64_LO12_NC),
"R_AARCH64_TLSDESC_LDR": reflect.ValueOf(elf.R_AARCH64_TLSDESC_LDR),
"R_AARCH64_TLSDESC_LD_PREL19": reflect.ValueOf(elf.R_AARCH64_TLSDESC_LD_PREL19),
"R_AARCH64_TLSDESC_OFF_G0_NC": reflect.ValueOf(elf.R_AARCH64_TLSDESC_OFF_G0_NC),
"R_AARCH64_TLSDESC_OFF_G1": reflect.ValueOf(elf.R_AARCH64_TLSDESC_OFF_G1),
"R_AARCH64_TLSGD_ADD_LO12_NC": reflect.ValueOf(elf.R_AARCH64_TLSGD_ADD_LO12_NC),
"R_AARCH64_TLSGD_ADR_PAGE21": reflect.ValueOf(elf.R_AARCH64_TLSGD_ADR_PAGE21),
"R_AARCH64_TLSGD_ADR_PREL21": reflect.ValueOf(elf.R_AARCH64_TLSGD_ADR_PREL21),
"R_AARCH64_TLSGD_MOVW_G0_NC": reflect.ValueOf(elf.R_AARCH64_TLSGD_MOVW_G0_NC),
"R_AARCH64_TLSGD_MOVW_G1": reflect.ValueOf(elf.R_AARCH64_TLSGD_MOVW_G1),
"R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21": reflect.ValueOf(elf.R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21),
"R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC": reflect.ValueOf(elf.R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC),
"R_AARCH64_TLSIE_LD_GOTTPREL_PREL19": reflect.ValueOf(elf.R_AARCH64_TLSIE_LD_GOTTPREL_PREL19),
"R_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC": reflect.ValueOf(elf.R_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC),
"R_AARCH64_TLSIE_MOVW_GOTTPREL_G1": reflect.ValueOf(elf.R_AARCH64_TLSIE_MOVW_GOTTPREL_G1),
"R_AARCH64_TLSLD_ADR_PAGE21": reflect.ValueOf(elf.R_AARCH64_TLSLD_ADR_PAGE21),
"R_AARCH64_TLSLD_ADR_PREL21": reflect.ValueOf(elf.R_AARCH64_TLSLD_ADR_PREL21),
"R_AARCH64_TLSLD_LDST128_DTPREL_LO12": reflect.ValueOf(elf.R_AARCH64_TLSLD_LDST128_DTPREL_LO12),
"R_AARCH64_TLSLD_LDST128_DTPREL_LO12_NC": reflect.ValueOf(elf.R_AARCH64_TLSLD_LDST128_DTPREL_LO12_NC),
"R_AARCH64_TLSLE_ADD_TPREL_HI12": reflect.ValueOf(elf.R_AARCH64_TLSLE_ADD_TPREL_HI12),
"R_AARCH64_TLSLE_ADD_TPREL_LO12": reflect.ValueOf(elf.R_AARCH64_TLSLE_ADD_TPREL_LO12),
"R_AARCH64_TLSLE_ADD_TPREL_LO12_NC": reflect.ValueOf(elf.R_AARCH64_TLSLE_ADD_TPREL_LO12_NC),
"R_AARCH64_TLSLE_LDST128_TPREL_LO12": reflect.ValueOf(elf.R_AARCH64_TLSLE_LDST128_TPREL_LO12),
"R_AARCH64_TLSLE_LDST128_TPREL_LO12_NC": reflect.ValueOf(elf.R_AARCH64_TLSLE_LDST128_TPREL_LO12_NC),
"R_AARCH64_TLSLE_MOVW_TPREL_G0": reflect.ValueOf(elf.R_AARCH64_TLSLE_MOVW_TPREL_G0),
"R_AARCH64_TLSLE_MOVW_TPREL_G0_NC": reflect.ValueOf(elf.R_AARCH64_TLSLE_MOVW_TPREL_G0_NC),
"R_AARCH64_TLSLE_MOVW_TPREL_G1": reflect.ValueOf(elf.R_AARCH64_TLSLE_MOVW_TPREL_G1),
"R_AARCH64_TLSLE_MOVW_TPREL_G1_NC": reflect.ValueOf(elf.R_AARCH64_TLSLE_MOVW_TPREL_G1_NC),
"R_AARCH64_TLSLE_MOVW_TPREL_G2": reflect.ValueOf(elf.R_AARCH64_TLSLE_MOVW_TPREL_G2),
"R_AARCH64_TLS_DTPMOD64": reflect.ValueOf(elf.R_AARCH64_TLS_DTPMOD64),
"R_AARCH64_TLS_DTPREL64": reflect.ValueOf(elf.R_AARCH64_TLS_DTPREL64),
"R_AARCH64_TLS_TPREL64": reflect.ValueOf(elf.R_AARCH64_TLS_TPREL64),
"R_AARCH64_TSTBR14": reflect.ValueOf(elf.R_AARCH64_TSTBR14),
"R_ALPHA_BRADDR": reflect.ValueOf(elf.R_ALPHA_BRADDR),
"R_ALPHA_COPY": reflect.ValueOf(elf.R_ALPHA_COPY),
"R_ALPHA_GLOB_DAT": reflect.ValueOf(elf.R_ALPHA_GLOB_DAT),
"R_ALPHA_GPDISP": reflect.ValueOf(elf.R_ALPHA_GPDISP),
"R_ALPHA_GPREL32": reflect.ValueOf(elf.R_ALPHA_GPREL32),
"R_ALPHA_GPRELHIGH": reflect.ValueOf(elf.R_ALPHA_GPRELHIGH),
"R_ALPHA_GPRELLOW": reflect.ValueOf(elf.R_ALPHA_GPRELLOW),
"R_ALPHA_GPVALUE": reflect.ValueOf(elf.R_ALPHA_GPVALUE),
"R_ALPHA_HINT": reflect.ValueOf(elf.R_ALPHA_HINT),
"R_ALPHA_IMMED_BR_HI32": reflect.ValueOf(elf.R_ALPHA_IMMED_BR_HI32),
"R_ALPHA_IMMED_GP_16": reflect.ValueOf(elf.R_ALPHA_IMMED_GP_16),
"R_ALPHA_IMMED_GP_HI32": reflect.ValueOf(elf.R_ALPHA_IMMED_GP_HI32),
"R_ALPHA_IMMED_LO32": reflect.ValueOf(elf.R_ALPHA_IMMED_LO32),
"R_ALPHA_IMMED_SCN_HI32": reflect.ValueOf(elf.R_ALPHA_IMMED_SCN_HI32),
"R_ALPHA_JMP_SLOT": reflect.ValueOf(elf.R_ALPHA_JMP_SLOT),
"R_ALPHA_LITERAL": reflect.ValueOf(elf.R_ALPHA_LITERAL),
"R_ALPHA_LITUSE": reflect.ValueOf(elf.R_ALPHA_LITUSE),
"R_ALPHA_NONE": reflect.ValueOf(elf.R_ALPHA_NONE),
"R_ALPHA_OP_PRSHIFT": reflect.ValueOf(elf.R_ALPHA_OP_PRSHIFT),
"R_ALPHA_OP_PSUB": reflect.ValueOf(elf.R_ALPHA_OP_PSUB),
"R_ALPHA_OP_PUSH": reflect.ValueOf(elf.R_ALPHA_OP_PUSH),
"R_ALPHA_OP_STORE": reflect.ValueOf(elf.R_ALPHA_OP_STORE),
"R_ALPHA_REFLONG": reflect.ValueOf(elf.R_ALPHA_REFLONG),
"R_ALPHA_REFQUAD": reflect.ValueOf(elf.R_ALPHA_REFQUAD),
"R_ALPHA_RELATIVE": reflect.ValueOf(elf.R_ALPHA_RELATIVE),
"R_ALPHA_SREL16": reflect.ValueOf(elf.R_ALPHA_SREL16),
"R_ALPHA_SREL32": reflect.ValueOf(elf.R_ALPHA_SREL32),
"R_ALPHA_SREL64": reflect.ValueOf(elf.R_ALPHA_SREL64),
"R_ARM_ABS12": reflect.ValueOf(elf.R_ARM_ABS12),
"R_ARM_ABS16": reflect.ValueOf(elf.R_ARM_ABS16),
"R_ARM_ABS32": reflect.ValueOf(elf.R_ARM_ABS32),
"R_ARM_ABS32_NOI": reflect.ValueOf(elf.R_ARM_ABS32_NOI),
"R_ARM_ABS8": reflect.ValueOf(elf.R_ARM_ABS8),
"R_ARM_ALU_PCREL_15_8": reflect.ValueOf(elf.R_ARM_ALU_PCREL_15_8),
"R_ARM_ALU_PCREL_23_15": reflect.ValueOf(elf.R_ARM_ALU_PCREL_23_15),
"R_ARM_ALU_PCREL_7_0": reflect.ValueOf(elf.R_ARM_ALU_PCREL_7_0),
"R_ARM_ALU_PC_G0": reflect.ValueOf(elf.R_ARM_ALU_PC_G0),
"R_ARM_ALU_PC_G0_NC": reflect.ValueOf(elf.R_ARM_ALU_PC_G0_NC),
"R_ARM_ALU_PC_G1": reflect.ValueOf(elf.R_ARM_ALU_PC_G1),
"R_ARM_ALU_PC_G1_NC": reflect.ValueOf(elf.R_ARM_ALU_PC_G1_NC),
"R_ARM_ALU_PC_G2": reflect.ValueOf(elf.R_ARM_ALU_PC_G2),
"R_ARM_ALU_SBREL_19_12_NC": reflect.ValueOf(elf.R_ARM_ALU_SBREL_19_12_NC),
"R_ARM_ALU_SBREL_27_20_CK": reflect.ValueOf(elf.R_ARM_ALU_SBREL_27_20_CK),
"R_ARM_ALU_SB_G0": reflect.ValueOf(elf.R_ARM_ALU_SB_G0),
"R_ARM_ALU_SB_G0_NC": reflect.ValueOf(elf.R_ARM_ALU_SB_G0_NC),
"R_ARM_ALU_SB_G1": reflect.ValueOf(elf.R_ARM_ALU_SB_G1),
"R_ARM_ALU_SB_G1_NC": reflect.ValueOf(elf.R_ARM_ALU_SB_G1_NC),
"R_ARM_ALU_SB_G2": reflect.ValueOf(elf.R_ARM_ALU_SB_G2),
"R_ARM_AMP_VCALL9": reflect.ValueOf(elf.R_ARM_AMP_VCALL9),
"R_ARM_BASE_ABS": reflect.ValueOf(elf.R_ARM_BASE_ABS),
"R_ARM_CALL": reflect.ValueOf(elf.R_ARM_CALL),
"R_ARM_COPY": reflect.ValueOf(elf.R_ARM_COPY),
"R_ARM_GLOB_DAT": reflect.ValueOf(elf.R_ARM_GLOB_DAT),
"R_ARM_GNU_VTENTRY": reflect.ValueOf(elf.R_ARM_GNU_VTENTRY),
"R_ARM_GNU_VTINHERIT": reflect.ValueOf(elf.R_ARM_GNU_VTINHERIT),
"R_ARM_GOT32": reflect.ValueOf(elf.R_ARM_GOT32),
"R_ARM_GOTOFF": reflect.ValueOf(elf.R_ARM_GOTOFF),
"R_ARM_GOTOFF12": reflect.ValueOf(elf.R_ARM_GOTOFF12),
"R_ARM_GOTPC": reflect.ValueOf(elf.R_ARM_GOTPC),
"R_ARM_GOTRELAX": reflect.ValueOf(elf.R_ARM_GOTRELAX),
"R_ARM_GOT_ABS": reflect.ValueOf(elf.R_ARM_GOT_ABS),
"R_ARM_GOT_BREL12": reflect.ValueOf(elf.R_ARM_GOT_BREL12),
"R_ARM_GOT_PREL": reflect.ValueOf(elf.R_ARM_GOT_PREL),
"R_ARM_IRELATIVE": reflect.ValueOf(elf.R_ARM_IRELATIVE),
"R_ARM_JUMP24": reflect.ValueOf(elf.R_ARM_JUMP24),
"R_ARM_JUMP_SLOT": reflect.ValueOf(elf.R_ARM_JUMP_SLOT),
"R_ARM_LDC_PC_G0": reflect.ValueOf(elf.R_ARM_LDC_PC_G0),
"R_ARM_LDC_PC_G1": reflect.ValueOf(elf.R_ARM_LDC_PC_G1),
"R_ARM_LDC_PC_G2": reflect.ValueOf(elf.R_ARM_LDC_PC_G2),
"R_ARM_LDC_SB_G0": reflect.ValueOf(elf.R_ARM_LDC_SB_G0),
"R_ARM_LDC_SB_G1": reflect.ValueOf(elf.R_ARM_LDC_SB_G1),
"R_ARM_LDC_SB_G2": reflect.ValueOf(elf.R_ARM_LDC_SB_G2),
"R_ARM_LDRS_PC_G0": reflect.ValueOf(elf.R_ARM_LDRS_PC_G0),
"R_ARM_LDRS_PC_G1": reflect.ValueOf(elf.R_ARM_LDRS_PC_G1),
"R_ARM_LDRS_PC_G2": reflect.ValueOf(elf.R_ARM_LDRS_PC_G2),
"R_ARM_LDRS_SB_G0": reflect.ValueOf(elf.R_ARM_LDRS_SB_G0),
"R_ARM_LDRS_SB_G1": reflect.ValueOf(elf.R_ARM_LDRS_SB_G1),
"R_ARM_LDRS_SB_G2": reflect.ValueOf(elf.R_ARM_LDRS_SB_G2),
"R_ARM_LDR_PC_G1": reflect.ValueOf(elf.R_ARM_LDR_PC_G1),
"R_ARM_LDR_PC_G2": reflect.ValueOf(elf.R_ARM_LDR_PC_G2),
"R_ARM_LDR_SBREL_11_10_NC": reflect.ValueOf(elf.R_ARM_LDR_SBREL_11_10_NC),
"R_ARM_LDR_SB_G0": reflect.ValueOf(elf.R_ARM_LDR_SB_G0),
"R_ARM_LDR_SB_G1": reflect.ValueOf(elf.R_ARM_LDR_SB_G1),
"R_ARM_LDR_SB_G2": reflect.ValueOf(elf.R_ARM_LDR_SB_G2),
"R_ARM_ME_TOO": reflect.ValueOf(elf.R_ARM_ME_TOO),
"R_ARM_MOVT_ABS": reflect.ValueOf(elf.R_ARM_MOVT_ABS),
"R_ARM_MOVT_BREL": reflect.ValueOf(elf.R_ARM_MOVT_BREL),
"R_ARM_MOVT_PREL": reflect.ValueOf(elf.R_ARM_MOVT_PREL),
"R_ARM_MOVW_ABS_NC": reflect.ValueOf(elf.R_ARM_MOVW_ABS_NC),
"R_ARM_MOVW_BREL": reflect.ValueOf(elf.R_ARM_MOVW_BREL),
"R_ARM_MOVW_BREL_NC": reflect.ValueOf(elf.R_ARM_MOVW_BREL_NC),
"R_ARM_MOVW_PREL_NC": reflect.ValueOf(elf.R_ARM_MOVW_PREL_NC),
"R_ARM_NONE": reflect.ValueOf(elf.R_ARM_NONE),
"R_ARM_PC13": reflect.ValueOf(elf.R_ARM_PC13),
"R_ARM_PC24": reflect.ValueOf(elf.R_ARM_PC24),
"R_ARM_PLT32": reflect.ValueOf(elf.R_ARM_PLT32),
"R_ARM_PLT32_ABS": reflect.ValueOf(elf.R_ARM_PLT32_ABS),
"R_ARM_PREL31": reflect.ValueOf(elf.R_ARM_PREL31),
"R_ARM_PRIVATE_0": reflect.ValueOf(elf.R_ARM_PRIVATE_0),
"R_ARM_PRIVATE_1": reflect.ValueOf(elf.R_ARM_PRIVATE_1),
"R_ARM_PRIVATE_10": reflect.ValueOf(elf.R_ARM_PRIVATE_10),
"R_ARM_PRIVATE_11": reflect.ValueOf(elf.R_ARM_PRIVATE_11),
"R_ARM_PRIVATE_12": reflect.ValueOf(elf.R_ARM_PRIVATE_12),
"R_ARM_PRIVATE_13": reflect.ValueOf(elf.R_ARM_PRIVATE_13),
"R_ARM_PRIVATE_14": reflect.ValueOf(elf.R_ARM_PRIVATE_14),
"R_ARM_PRIVATE_15": reflect.ValueOf(elf.R_ARM_PRIVATE_15),
"R_ARM_PRIVATE_2": reflect.ValueOf(elf.R_ARM_PRIVATE_2),
"R_ARM_PRIVATE_3": reflect.ValueOf(elf.R_ARM_PRIVATE_3),
"R_ARM_PRIVATE_4": reflect.ValueOf(elf.R_ARM_PRIVATE_4),
"R_ARM_PRIVATE_5": reflect.ValueOf(elf.R_ARM_PRIVATE_5),
"R_ARM_PRIVATE_6": reflect.ValueOf(elf.R_ARM_PRIVATE_6),
"R_ARM_PRIVATE_7": reflect.ValueOf(elf.R_ARM_PRIVATE_7),
"R_ARM_PRIVATE_8": reflect.ValueOf(elf.R_ARM_PRIVATE_8),
"R_ARM_PRIVATE_9": reflect.ValueOf(elf.R_ARM_PRIVATE_9),
"R_ARM_RABS32": reflect.ValueOf(elf.R_ARM_RABS32),
"R_ARM_RBASE": reflect.ValueOf(elf.R_ARM_RBASE),
"R_ARM_REL32": reflect.ValueOf(elf.R_ARM_REL32),
"R_ARM_REL32_NOI": reflect.ValueOf(elf.R_ARM_REL32_NOI),
"R_ARM_RELATIVE": reflect.ValueOf(elf.R_ARM_RELATIVE),
"R_ARM_RPC24": reflect.ValueOf(elf.R_ARM_RPC24),
"R_ARM_RREL32": reflect.ValueOf(elf.R_ARM_RREL32),
"R_ARM_RSBREL32": reflect.ValueOf(elf.R_ARM_RSBREL32),
"R_ARM_RXPC25": reflect.ValueOf(elf.R_ARM_RXPC25),
"R_ARM_SBREL31": reflect.ValueOf(elf.R_ARM_SBREL31),
"R_ARM_SBREL32": reflect.ValueOf(elf.R_ARM_SBREL32),
"R_ARM_SWI24": reflect.ValueOf(elf.R_ARM_SWI24),
"R_ARM_TARGET1": reflect.ValueOf(elf.R_ARM_TARGET1),
"R_ARM_TARGET2": reflect.ValueOf(elf.R_ARM_TARGET2),
"R_ARM_THM_ABS5": reflect.ValueOf(elf.R_ARM_THM_ABS5),
"R_ARM_THM_ALU_ABS_G0_NC": reflect.ValueOf(elf.R_ARM_THM_ALU_ABS_G0_NC),
"R_ARM_THM_ALU_ABS_G1_NC": reflect.ValueOf(elf.R_ARM_THM_ALU_ABS_G1_NC),
"R_ARM_THM_ALU_ABS_G2_NC": reflect.ValueOf(elf.R_ARM_THM_ALU_ABS_G2_NC),
"R_ARM_THM_ALU_ABS_G3": reflect.ValueOf(elf.R_ARM_THM_ALU_ABS_G3),
"R_ARM_THM_ALU_PREL_11_0": reflect.ValueOf(elf.R_ARM_THM_ALU_PREL_11_0),
"R_ARM_THM_GOT_BREL12": reflect.ValueOf(elf.R_ARM_THM_GOT_BREL12),
"R_ARM_THM_JUMP11": reflect.ValueOf(elf.R_ARM_THM_JUMP11),
"R_ARM_THM_JUMP19": reflect.ValueOf(elf.R_ARM_THM_JUMP19),
"R_ARM_THM_JUMP24": reflect.ValueOf(elf.R_ARM_THM_JUMP24),
"R_ARM_THM_JUMP6": reflect.ValueOf(elf.R_ARM_THM_JUMP6),
"R_ARM_THM_JUMP8": reflect.ValueOf(elf.R_ARM_THM_JUMP8),
"R_ARM_THM_MOVT_ABS": reflect.ValueOf(elf.R_ARM_THM_MOVT_ABS),
"R_ARM_THM_MOVT_BREL": reflect.ValueOf(elf.R_ARM_THM_MOVT_BREL),
"R_ARM_THM_MOVT_PREL": reflect.ValueOf(elf.R_ARM_THM_MOVT_PREL),
"R_ARM_THM_MOVW_ABS_NC": reflect.ValueOf(elf.R_ARM_THM_MOVW_ABS_NC),
"R_ARM_THM_MOVW_BREL": reflect.ValueOf(elf.R_ARM_THM_MOVW_BREL),
"R_ARM_THM_MOVW_BREL_NC": reflect.ValueOf(elf.R_ARM_THM_MOVW_BREL_NC),
"R_ARM_THM_MOVW_PREL_NC": reflect.ValueOf(elf.R_ARM_THM_MOVW_PREL_NC),
"R_ARM_THM_PC12": reflect.ValueOf(elf.R_ARM_THM_PC12),
"R_ARM_THM_PC22": reflect.ValueOf(elf.R_ARM_THM_PC22),
"R_ARM_THM_PC8": reflect.ValueOf(elf.R_ARM_THM_PC8),
"R_ARM_THM_RPC22": reflect.ValueOf(elf.R_ARM_THM_RPC22),
"R_ARM_THM_SWI8": reflect.ValueOf(elf.R_ARM_THM_SWI8),
"R_ARM_THM_TLS_CALL": reflect.ValueOf(elf.R_ARM_THM_TLS_CALL),
"R_ARM_THM_TLS_DESCSEQ16": reflect.ValueOf(elf.R_ARM_THM_TLS_DESCSEQ16),
"R_ARM_THM_TLS_DESCSEQ32": reflect.ValueOf(elf.R_ARM_THM_TLS_DESCSEQ32),
"R_ARM_THM_XPC22": reflect.ValueOf(elf.R_ARM_THM_XPC22),
"R_ARM_TLS_CALL": reflect.ValueOf(elf.R_ARM_TLS_CALL),
"R_ARM_TLS_DESCSEQ": reflect.ValueOf(elf.R_ARM_TLS_DESCSEQ),
"R_ARM_TLS_DTPMOD32": reflect.ValueOf(elf.R_ARM_TLS_DTPMOD32),
"R_ARM_TLS_DTPOFF32": reflect.ValueOf(elf.R_ARM_TLS_DTPOFF32),
"R_ARM_TLS_GD32": reflect.ValueOf(elf.R_ARM_TLS_GD32),
"R_ARM_TLS_GOTDESC": reflect.ValueOf(elf.R_ARM_TLS_GOTDESC),
"R_ARM_TLS_IE12GP": reflect.ValueOf(elf.R_ARM_TLS_IE12GP),
"R_ARM_TLS_IE32": reflect.ValueOf(elf.R_ARM_TLS_IE32),
"R_ARM_TLS_LDM32": reflect.ValueOf(elf.R_ARM_TLS_LDM32),
"R_ARM_TLS_LDO12": reflect.ValueOf(elf.R_ARM_TLS_LDO12),
"R_ARM_TLS_LDO32": reflect.ValueOf(elf.R_ARM_TLS_LDO32),
"R_ARM_TLS_LE12": reflect.ValueOf(elf.R_ARM_TLS_LE12),
"R_ARM_TLS_LE32": reflect.ValueOf(elf.R_ARM_TLS_LE32),
"R_ARM_TLS_TPOFF32": reflect.ValueOf(elf.R_ARM_TLS_TPOFF32),
"R_ARM_V4BX": reflect.ValueOf(elf.R_ARM_V4BX),
"R_ARM_XPC25": reflect.ValueOf(elf.R_ARM_XPC25),
"R_INFO": reflect.ValueOf(elf.R_INFO),
"R_INFO32": reflect.ValueOf(elf.R_INFO32),
"R_LARCH_32": reflect.ValueOf(elf.R_LARCH_32),
"R_LARCH_32_PCREL": reflect.ValueOf(elf.R_LARCH_32_PCREL),
"R_LARCH_64": reflect.ValueOf(elf.R_LARCH_64),
"R_LARCH_ABS64_HI12": reflect.ValueOf(elf.R_LARCH_ABS64_HI12),
"R_LARCH_ABS64_LO20": reflect.ValueOf(elf.R_LARCH_ABS64_LO20),
"R_LARCH_ABS_HI20": reflect.ValueOf(elf.R_LARCH_ABS_HI20),
"R_LARCH_ABS_LO12": reflect.ValueOf(elf.R_LARCH_ABS_LO12),
"R_LARCH_ADD16": reflect.ValueOf(elf.R_LARCH_ADD16),
"R_LARCH_ADD24": reflect.ValueOf(elf.R_LARCH_ADD24),
"R_LARCH_ADD32": reflect.ValueOf(elf.R_LARCH_ADD32),
"R_LARCH_ADD64": reflect.ValueOf(elf.R_LARCH_ADD64),
"R_LARCH_ADD8": reflect.ValueOf(elf.R_LARCH_ADD8),
"R_LARCH_B16": reflect.ValueOf(elf.R_LARCH_B16),
"R_LARCH_B21": reflect.ValueOf(elf.R_LARCH_B21),
"R_LARCH_B26": reflect.ValueOf(elf.R_LARCH_B26),
"R_LARCH_COPY": reflect.ValueOf(elf.R_LARCH_COPY),
"R_LARCH_GNU_VTENTRY": reflect.ValueOf(elf.R_LARCH_GNU_VTENTRY),
"R_LARCH_GNU_VTINHERIT": reflect.ValueOf(elf.R_LARCH_GNU_VTINHERIT),
"R_LARCH_GOT64_HI12": reflect.ValueOf(elf.R_LARCH_GOT64_HI12),
"R_LARCH_GOT64_LO20": reflect.ValueOf(elf.R_LARCH_GOT64_LO20),
"R_LARCH_GOT64_PC_HI12": reflect.ValueOf(elf.R_LARCH_GOT64_PC_HI12),
"R_LARCH_GOT64_PC_LO20": reflect.ValueOf(elf.R_LARCH_GOT64_PC_LO20),
"R_LARCH_GOT_HI20": reflect.ValueOf(elf.R_LARCH_GOT_HI20),
"R_LARCH_GOT_LO12": reflect.ValueOf(elf.R_LARCH_GOT_LO12),
"R_LARCH_GOT_PC_HI20": reflect.ValueOf(elf.R_LARCH_GOT_PC_HI20),
"R_LARCH_GOT_PC_LO12": reflect.ValueOf(elf.R_LARCH_GOT_PC_LO12),
"R_LARCH_IRELATIVE": reflect.ValueOf(elf.R_LARCH_IRELATIVE),
"R_LARCH_JUMP_SLOT": reflect.ValueOf(elf.R_LARCH_JUMP_SLOT),
"R_LARCH_MARK_LA": reflect.ValueOf(elf.R_LARCH_MARK_LA),
"R_LARCH_MARK_PCREL": reflect.ValueOf(elf.R_LARCH_MARK_PCREL),
"R_LARCH_NONE": reflect.ValueOf(elf.R_LARCH_NONE),
"R_LARCH_PCALA64_HI12": reflect.ValueOf(elf.R_LARCH_PCALA64_HI12),
"R_LARCH_PCALA64_LO20": reflect.ValueOf(elf.R_LARCH_PCALA64_LO20),
"R_LARCH_PCALA_HI20": reflect.ValueOf(elf.R_LARCH_PCALA_HI20),
"R_LARCH_PCALA_LO12": reflect.ValueOf(elf.R_LARCH_PCALA_LO12),
"R_LARCH_RELATIVE": reflect.ValueOf(elf.R_LARCH_RELATIVE),
"R_LARCH_RELAX": reflect.ValueOf(elf.R_LARCH_RELAX),
"R_LARCH_SOP_ADD": reflect.ValueOf(elf.R_LARCH_SOP_ADD),
"R_LARCH_SOP_AND": reflect.ValueOf(elf.R_LARCH_SOP_AND),
"R_LARCH_SOP_ASSERT": reflect.ValueOf(elf.R_LARCH_SOP_ASSERT),
"R_LARCH_SOP_IF_ELSE": reflect.ValueOf(elf.R_LARCH_SOP_IF_ELSE),
"R_LARCH_SOP_NOT": reflect.ValueOf(elf.R_LARCH_SOP_NOT),
"R_LARCH_SOP_POP_32_S_0_10_10_16_S2": reflect.ValueOf(elf.R_LARCH_SOP_POP_32_S_0_10_10_16_S2),
"R_LARCH_SOP_POP_32_S_0_5_10_16_S2": reflect.ValueOf(elf.R_LARCH_SOP_POP_32_S_0_5_10_16_S2),
"R_LARCH_SOP_POP_32_S_10_12": reflect.ValueOf(elf.R_LARCH_SOP_POP_32_S_10_12),
"R_LARCH_SOP_POP_32_S_10_16": reflect.ValueOf(elf.R_LARCH_SOP_POP_32_S_10_16),
"R_LARCH_SOP_POP_32_S_10_16_S2": reflect.ValueOf(elf.R_LARCH_SOP_POP_32_S_10_16_S2),
"R_LARCH_SOP_POP_32_S_10_5": reflect.ValueOf(elf.R_LARCH_SOP_POP_32_S_10_5),
"R_LARCH_SOP_POP_32_S_5_20": reflect.ValueOf(elf.R_LARCH_SOP_POP_32_S_5_20),
"R_LARCH_SOP_POP_32_U": reflect.ValueOf(elf.R_LARCH_SOP_POP_32_U),
"R_LARCH_SOP_POP_32_U_10_12": reflect.ValueOf(elf.R_LARCH_SOP_POP_32_U_10_12),
"R_LARCH_SOP_PUSH_ABSOLUTE": reflect.ValueOf(elf.R_LARCH_SOP_PUSH_ABSOLUTE),
"R_LARCH_SOP_PUSH_DUP": reflect.ValueOf(elf.R_LARCH_SOP_PUSH_DUP),
"R_LARCH_SOP_PUSH_GPREL": reflect.ValueOf(elf.R_LARCH_SOP_PUSH_GPREL),
"R_LARCH_SOP_PUSH_PCREL": reflect.ValueOf(elf.R_LARCH_SOP_PUSH_PCREL),
"R_LARCH_SOP_PUSH_PLT_PCREL": reflect.ValueOf(elf.R_LARCH_SOP_PUSH_PLT_PCREL),
"R_LARCH_SOP_PUSH_TLS_GD": reflect.ValueOf(elf.R_LARCH_SOP_PUSH_TLS_GD),
"R_LARCH_SOP_PUSH_TLS_GOT": reflect.ValueOf(elf.R_LARCH_SOP_PUSH_TLS_GOT),
"R_LARCH_SOP_PUSH_TLS_TPREL": reflect.ValueOf(elf.R_LARCH_SOP_PUSH_TLS_TPREL),
"R_LARCH_SOP_SL": reflect.ValueOf(elf.R_LARCH_SOP_SL),
"R_LARCH_SOP_SR": reflect.ValueOf(elf.R_LARCH_SOP_SR),
"R_LARCH_SOP_SUB": reflect.ValueOf(elf.R_LARCH_SOP_SUB),
"R_LARCH_SUB16": reflect.ValueOf(elf.R_LARCH_SUB16),
"R_LARCH_SUB24": reflect.ValueOf(elf.R_LARCH_SUB24),
"R_LARCH_SUB32": reflect.ValueOf(elf.R_LARCH_SUB32),
"R_LARCH_SUB64": reflect.ValueOf(elf.R_LARCH_SUB64),
"R_LARCH_SUB8": reflect.ValueOf(elf.R_LARCH_SUB8),
"R_LARCH_TLS_DTPMOD32": reflect.ValueOf(elf.R_LARCH_TLS_DTPMOD32),
"R_LARCH_TLS_DTPMOD64": reflect.ValueOf(elf.R_LARCH_TLS_DTPMOD64),
"R_LARCH_TLS_DTPREL32": reflect.ValueOf(elf.R_LARCH_TLS_DTPREL32),
"R_LARCH_TLS_DTPREL64": reflect.ValueOf(elf.R_LARCH_TLS_DTPREL64),
"R_LARCH_TLS_GD_HI20": reflect.ValueOf(elf.R_LARCH_TLS_GD_HI20),
"R_LARCH_TLS_GD_PC_HI20": reflect.ValueOf(elf.R_LARCH_TLS_GD_PC_HI20),
"R_LARCH_TLS_IE64_HI12": reflect.ValueOf(elf.R_LARCH_TLS_IE64_HI12),
"R_LARCH_TLS_IE64_LO20": reflect.ValueOf(elf.R_LARCH_TLS_IE64_LO20),
"R_LARCH_TLS_IE64_PC_HI12": reflect.ValueOf(elf.R_LARCH_TLS_IE64_PC_HI12),
"R_LARCH_TLS_IE64_PC_LO20": reflect.ValueOf(elf.R_LARCH_TLS_IE64_PC_LO20),
"R_LARCH_TLS_IE_HI20": reflect.ValueOf(elf.R_LARCH_TLS_IE_HI20),
"R_LARCH_TLS_IE_LO12": reflect.ValueOf(elf.R_LARCH_TLS_IE_LO12),
"R_LARCH_TLS_IE_PC_HI20": reflect.ValueOf(elf.R_LARCH_TLS_IE_PC_HI20),
"R_LARCH_TLS_IE_PC_LO12": reflect.ValueOf(elf.R_LARCH_TLS_IE_PC_LO12),
"R_LARCH_TLS_LD_HI20": reflect.ValueOf(elf.R_LARCH_TLS_LD_HI20),
"R_LARCH_TLS_LD_PC_HI20": reflect.ValueOf(elf.R_LARCH_TLS_LD_PC_HI20),
"R_LARCH_TLS_LE64_HI12": reflect.ValueOf(elf.R_LARCH_TLS_LE64_HI12),
"R_LARCH_TLS_LE64_LO20": reflect.ValueOf(elf.R_LARCH_TLS_LE64_LO20),
"R_LARCH_TLS_LE_HI20": reflect.ValueOf(elf.R_LARCH_TLS_LE_HI20),
"R_LARCH_TLS_LE_LO12": reflect.ValueOf(elf.R_LARCH_TLS_LE_LO12),
"R_LARCH_TLS_TPREL32": reflect.ValueOf(elf.R_LARCH_TLS_TPREL32),
"R_LARCH_TLS_TPREL64": reflect.ValueOf(elf.R_LARCH_TLS_TPREL64),
"R_MIPS_16": reflect.ValueOf(elf.R_MIPS_16),
"R_MIPS_26": reflect.ValueOf(elf.R_MIPS_26),
"R_MIPS_32": reflect.ValueOf(elf.R_MIPS_32),
"R_MIPS_64": reflect.ValueOf(elf.R_MIPS_64),
"R_MIPS_ADD_IMMEDIATE": reflect.ValueOf(elf.R_MIPS_ADD_IMMEDIATE),
"R_MIPS_CALL16": reflect.ValueOf(elf.R_MIPS_CALL16),
"R_MIPS_CALL_HI16": reflect.ValueOf(elf.R_MIPS_CALL_HI16),
"R_MIPS_CALL_LO16": reflect.ValueOf(elf.R_MIPS_CALL_LO16),
"R_MIPS_DELETE": reflect.ValueOf(elf.R_MIPS_DELETE),
"R_MIPS_GOT16": reflect.ValueOf(elf.R_MIPS_GOT16),
"R_MIPS_GOT_DISP": reflect.ValueOf(elf.R_MIPS_GOT_DISP),
"R_MIPS_GOT_HI16": reflect.ValueOf(elf.R_MIPS_GOT_HI16),
"R_MIPS_GOT_LO16": reflect.ValueOf(elf.R_MIPS_GOT_LO16),
"R_MIPS_GOT_OFST": reflect.ValueOf(elf.R_MIPS_GOT_OFST),
"R_MIPS_GOT_PAGE": reflect.ValueOf(elf.R_MIPS_GOT_PAGE),
"R_MIPS_GPREL16": reflect.ValueOf(elf.R_MIPS_GPREL16),
"R_MIPS_GPREL32": reflect.ValueOf(elf.R_MIPS_GPREL32),
"R_MIPS_HI16": reflect.ValueOf(elf.R_MIPS_HI16),
"R_MIPS_HIGHER": reflect.ValueOf(elf.R_MIPS_HIGHER),
"R_MIPS_HIGHEST": reflect.ValueOf(elf.R_MIPS_HIGHEST),
"R_MIPS_INSERT_A": reflect.ValueOf(elf.R_MIPS_INSERT_A),
"R_MIPS_INSERT_B": reflect.ValueOf(elf.R_MIPS_INSERT_B),
"R_MIPS_JALR": reflect.ValueOf(elf.R_MIPS_JALR),
"R_MIPS_LITERAL": reflect.ValueOf(elf.R_MIPS_LITERAL),
"R_MIPS_LO16": reflect.ValueOf(elf.R_MIPS_LO16),
"R_MIPS_NONE": reflect.ValueOf(elf.R_MIPS_NONE),
"R_MIPS_PC16": reflect.ValueOf(elf.R_MIPS_PC16),
"R_MIPS_PJUMP": reflect.ValueOf(elf.R_MIPS_PJUMP),
"R_MIPS_REL16": reflect.ValueOf(elf.R_MIPS_REL16),
"R_MIPS_REL32": reflect.ValueOf(elf.R_MIPS_REL32),
"R_MIPS_RELGOT": reflect.ValueOf(elf.R_MIPS_RELGOT),
"R_MIPS_SCN_DISP": reflect.ValueOf(elf.R_MIPS_SCN_DISP),
"R_MIPS_SHIFT5": reflect.ValueOf(elf.R_MIPS_SHIFT5),
"R_MIPS_SHIFT6": reflect.ValueOf(elf.R_MIPS_SHIFT6),
"R_MIPS_SUB": reflect.ValueOf(elf.R_MIPS_SUB),
"R_MIPS_TLS_DTPMOD32": reflect.ValueOf(elf.R_MIPS_TLS_DTPMOD32),
"R_MIPS_TLS_DTPMOD64": reflect.ValueOf(elf.R_MIPS_TLS_DTPMOD64),
"R_MIPS_TLS_DTPREL32": reflect.ValueOf(elf.R_MIPS_TLS_DTPREL32),
"R_MIPS_TLS_DTPREL64": reflect.ValueOf(elf.R_MIPS_TLS_DTPREL64),
"R_MIPS_TLS_DTPREL_HI16": reflect.ValueOf(elf.R_MIPS_TLS_DTPREL_HI16),
"R_MIPS_TLS_DTPREL_LO16": reflect.ValueOf(elf.R_MIPS_TLS_DTPREL_LO16),
"R_MIPS_TLS_GD": reflect.ValueOf(elf.R_MIPS_TLS_GD),
"R_MIPS_TLS_GOTTPREL": reflect.ValueOf(elf.R_MIPS_TLS_GOTTPREL),
"R_MIPS_TLS_LDM": reflect.ValueOf(elf.R_MIPS_TLS_LDM),
"R_MIPS_TLS_TPREL32": reflect.ValueOf(elf.R_MIPS_TLS_TPREL32),
"R_MIPS_TLS_TPREL64": reflect.ValueOf(elf.R_MIPS_TLS_TPREL64),
"R_MIPS_TLS_TPREL_HI16": reflect.ValueOf(elf.R_MIPS_TLS_TPREL_HI16),
"R_MIPS_TLS_TPREL_LO16": reflect.ValueOf(elf.R_MIPS_TLS_TPREL_LO16),
"R_PPC64_ADDR14": reflect.ValueOf(elf.R_PPC64_ADDR14),
"R_PPC64_ADDR14_BRNTAKEN": reflect.ValueOf(elf.R_PPC64_ADDR14_BRNTAKEN),
"R_PPC64_ADDR14_BRTAKEN": reflect.ValueOf(elf.R_PPC64_ADDR14_BRTAKEN),
"R_PPC64_ADDR16": reflect.ValueOf(elf.R_PPC64_ADDR16),
"R_PPC64_ADDR16_DS": reflect.ValueOf(elf.R_PPC64_ADDR16_DS),
"R_PPC64_ADDR16_HA": reflect.ValueOf(elf.R_PPC64_ADDR16_HA),
"R_PPC64_ADDR16_HI": reflect.ValueOf(elf.R_PPC64_ADDR16_HI),
"R_PPC64_ADDR16_HIGH": reflect.ValueOf(elf.R_PPC64_ADDR16_HIGH),
"R_PPC64_ADDR16_HIGHA": reflect.ValueOf(elf.R_PPC64_ADDR16_HIGHA),
"R_PPC64_ADDR16_HIGHER": reflect.ValueOf(elf.R_PPC64_ADDR16_HIGHER),
"R_PPC64_ADDR16_HIGHER34": reflect.ValueOf(elf.R_PPC64_ADDR16_HIGHER34),
"R_PPC64_ADDR16_HIGHERA": reflect.ValueOf(elf.R_PPC64_ADDR16_HIGHERA),
"R_PPC64_ADDR16_HIGHERA34": reflect.ValueOf(elf.R_PPC64_ADDR16_HIGHERA34),
"R_PPC64_ADDR16_HIGHEST": reflect.ValueOf(elf.R_PPC64_ADDR16_HIGHEST),
"R_PPC64_ADDR16_HIGHEST34": reflect.ValueOf(elf.R_PPC64_ADDR16_HIGHEST34),
"R_PPC64_ADDR16_HIGHESTA": reflect.ValueOf(elf.R_PPC64_ADDR16_HIGHESTA),
"R_PPC64_ADDR16_HIGHESTA34": reflect.ValueOf(elf.R_PPC64_ADDR16_HIGHESTA34),
"R_PPC64_ADDR16_LO": reflect.ValueOf(elf.R_PPC64_ADDR16_LO),
"R_PPC64_ADDR16_LO_DS": reflect.ValueOf(elf.R_PPC64_ADDR16_LO_DS),
"R_PPC64_ADDR24": reflect.ValueOf(elf.R_PPC64_ADDR24),
"R_PPC64_ADDR32": reflect.ValueOf(elf.R_PPC64_ADDR32),
"R_PPC64_ADDR64": reflect.ValueOf(elf.R_PPC64_ADDR64),
"R_PPC64_ADDR64_LOCAL": reflect.ValueOf(elf.R_PPC64_ADDR64_LOCAL),
"R_PPC64_COPY": reflect.ValueOf(elf.R_PPC64_COPY),
"R_PPC64_D28": reflect.ValueOf(elf.R_PPC64_D28),
"R_PPC64_D34": reflect.ValueOf(elf.R_PPC64_D34),
"R_PPC64_D34_HA30": reflect.ValueOf(elf.R_PPC64_D34_HA30),
"R_PPC64_D34_HI30": reflect.ValueOf(elf.R_PPC64_D34_HI30),
"R_PPC64_D34_LO": reflect.ValueOf(elf.R_PPC64_D34_LO),
"R_PPC64_DTPMOD64": reflect.ValueOf(elf.R_PPC64_DTPMOD64),
"R_PPC64_DTPREL16": reflect.ValueOf(elf.R_PPC64_DTPREL16),
"R_PPC64_DTPREL16_DS": reflect.ValueOf(elf.R_PPC64_DTPREL16_DS),
"R_PPC64_DTPREL16_HA": reflect.ValueOf(elf.R_PPC64_DTPREL16_HA),
"R_PPC64_DTPREL16_HI": reflect.ValueOf(elf.R_PPC64_DTPREL16_HI),
"R_PPC64_DTPREL16_HIGH": reflect.ValueOf(elf.R_PPC64_DTPREL16_HIGH),
"R_PPC64_DTPREL16_HIGHA": reflect.ValueOf(elf.R_PPC64_DTPREL16_HIGHA),
"R_PPC64_DTPREL16_HIGHER": reflect.ValueOf(elf.R_PPC64_DTPREL16_HIGHER),
"R_PPC64_DTPREL16_HIGHERA": reflect.ValueOf(elf.R_PPC64_DTPREL16_HIGHERA),
"R_PPC64_DTPREL16_HIGHEST": reflect.ValueOf(elf.R_PPC64_DTPREL16_HIGHEST),
"R_PPC64_DTPREL16_HIGHESTA": reflect.ValueOf(elf.R_PPC64_DTPREL16_HIGHESTA),
"R_PPC64_DTPREL16_LO": reflect.ValueOf(elf.R_PPC64_DTPREL16_LO),
"R_PPC64_DTPREL16_LO_DS": reflect.ValueOf(elf.R_PPC64_DTPREL16_LO_DS),
"R_PPC64_DTPREL34": reflect.ValueOf(elf.R_PPC64_DTPREL34),
"R_PPC64_DTPREL64": reflect.ValueOf(elf.R_PPC64_DTPREL64),
"R_PPC64_ENTRY": reflect.ValueOf(elf.R_PPC64_ENTRY),
"R_PPC64_GLOB_DAT": reflect.ValueOf(elf.R_PPC64_GLOB_DAT),
"R_PPC64_GNU_VTENTRY": reflect.ValueOf(elf.R_PPC64_GNU_VTENTRY),
"R_PPC64_GNU_VTINHERIT": reflect.ValueOf(elf.R_PPC64_GNU_VTINHERIT),
"R_PPC64_GOT16": reflect.ValueOf(elf.R_PPC64_GOT16),
"R_PPC64_GOT16_DS": reflect.ValueOf(elf.R_PPC64_GOT16_DS),
"R_PPC64_GOT16_HA": reflect.ValueOf(elf.R_PPC64_GOT16_HA),
"R_PPC64_GOT16_HI": reflect.ValueOf(elf.R_PPC64_GOT16_HI),
"R_PPC64_GOT16_LO": reflect.ValueOf(elf.R_PPC64_GOT16_LO),
"R_PPC64_GOT16_LO_DS": reflect.ValueOf(elf.R_PPC64_GOT16_LO_DS),
"R_PPC64_GOT_DTPREL16_DS": reflect.ValueOf(elf.R_PPC64_GOT_DTPREL16_DS),
"R_PPC64_GOT_DTPREL16_HA": reflect.ValueOf(elf.R_PPC64_GOT_DTPREL16_HA),
"R_PPC64_GOT_DTPREL16_HI": reflect.ValueOf(elf.R_PPC64_GOT_DTPREL16_HI),
"R_PPC64_GOT_DTPREL16_LO_DS": reflect.ValueOf(elf.R_PPC64_GOT_DTPREL16_LO_DS),
"R_PPC64_GOT_DTPREL_PCREL34": reflect.ValueOf(elf.R_PPC64_GOT_DTPREL_PCREL34),
"R_PPC64_GOT_PCREL34": reflect.ValueOf(elf.R_PPC64_GOT_PCREL34),
"R_PPC64_GOT_TLSGD16": reflect.ValueOf(elf.R_PPC64_GOT_TLSGD16),
"R_PPC64_GOT_TLSGD16_HA": reflect.ValueOf(elf.R_PPC64_GOT_TLSGD16_HA),
"R_PPC64_GOT_TLSGD16_HI": reflect.ValueOf(elf.R_PPC64_GOT_TLSGD16_HI),
"R_PPC64_GOT_TLSGD16_LO": reflect.ValueOf(elf.R_PPC64_GOT_TLSGD16_LO),
"R_PPC64_GOT_TLSGD_PCREL34": reflect.ValueOf(elf.R_PPC64_GOT_TLSGD_PCREL34),
"R_PPC64_GOT_TLSLD16": reflect.ValueOf(elf.R_PPC64_GOT_TLSLD16),
"R_PPC64_GOT_TLSLD16_HA": reflect.ValueOf(elf.R_PPC64_GOT_TLSLD16_HA),
"R_PPC64_GOT_TLSLD16_HI": reflect.ValueOf(elf.R_PPC64_GOT_TLSLD16_HI),
"R_PPC64_GOT_TLSLD16_LO": reflect.ValueOf(elf.R_PPC64_GOT_TLSLD16_LO),
"R_PPC64_GOT_TLSLD_PCREL34": reflect.ValueOf(elf.R_PPC64_GOT_TLSLD_PCREL34),
"R_PPC64_GOT_TPREL16_DS": reflect.ValueOf(elf.R_PPC64_GOT_TPREL16_DS),
"R_PPC64_GOT_TPREL16_HA": reflect.ValueOf(elf.R_PPC64_GOT_TPREL16_HA),
"R_PPC64_GOT_TPREL16_HI": reflect.ValueOf(elf.R_PPC64_GOT_TPREL16_HI),
"R_PPC64_GOT_TPREL16_LO_DS": reflect.ValueOf(elf.R_PPC64_GOT_TPREL16_LO_DS),
"R_PPC64_GOT_TPREL_PCREL34": reflect.ValueOf(elf.R_PPC64_GOT_TPREL_PCREL34),
"R_PPC64_IRELATIVE": reflect.ValueOf(elf.R_PPC64_IRELATIVE),
"R_PPC64_JMP_IREL": reflect.ValueOf(elf.R_PPC64_JMP_IREL),
"R_PPC64_JMP_SLOT": reflect.ValueOf(elf.R_PPC64_JMP_SLOT),
"R_PPC64_NONE": reflect.ValueOf(elf.R_PPC64_NONE),
"R_PPC64_PCREL28": reflect.ValueOf(elf.R_PPC64_PCREL28),
"R_PPC64_PCREL34": reflect.ValueOf(elf.R_PPC64_PCREL34),
"R_PPC64_PCREL_OPT": reflect.ValueOf(elf.R_PPC64_PCREL_OPT),
"R_PPC64_PLT16_HA": reflect.ValueOf(elf.R_PPC64_PLT16_HA),
"R_PPC64_PLT16_HI": reflect.ValueOf(elf.R_PPC64_PLT16_HI),
"R_PPC64_PLT16_LO": reflect.ValueOf(elf.R_PPC64_PLT16_LO),
"R_PPC64_PLT16_LO_DS": reflect.ValueOf(elf.R_PPC64_PLT16_LO_DS),
"R_PPC64_PLT32": reflect.ValueOf(elf.R_PPC64_PLT32),
"R_PPC64_PLT64": reflect.ValueOf(elf.R_PPC64_PLT64),
"R_PPC64_PLTCALL": reflect.ValueOf(elf.R_PPC64_PLTCALL),
"R_PPC64_PLTCALL_NOTOC": reflect.ValueOf(elf.R_PPC64_PLTCALL_NOTOC),
"R_PPC64_PLTGOT16": reflect.ValueOf(elf.R_PPC64_PLTGOT16),
"R_PPC64_PLTGOT16_DS": reflect.ValueOf(elf.R_PPC64_PLTGOT16_DS),
"R_PPC64_PLTGOT16_HA": reflect.ValueOf(elf.R_PPC64_PLTGOT16_HA),
"R_PPC64_PLTGOT16_HI": reflect.ValueOf(elf.R_PPC64_PLTGOT16_HI),
"R_PPC64_PLTGOT16_LO": reflect.ValueOf(elf.R_PPC64_PLTGOT16_LO),
"R_PPC64_PLTGOT_LO_DS": reflect.ValueOf(elf.R_PPC64_PLTGOT_LO_DS),
"R_PPC64_PLTREL32": reflect.ValueOf(elf.R_PPC64_PLTREL32),
"R_PPC64_PLTREL64": reflect.ValueOf(elf.R_PPC64_PLTREL64),
"R_PPC64_PLTSEQ": reflect.ValueOf(elf.R_PPC64_PLTSEQ),
"R_PPC64_PLTSEQ_NOTOC": reflect.ValueOf(elf.R_PPC64_PLTSEQ_NOTOC),
"R_PPC64_PLT_PCREL34": reflect.ValueOf(elf.R_PPC64_PLT_PCREL34),
"R_PPC64_PLT_PCREL34_NOTOC": reflect.ValueOf(elf.R_PPC64_PLT_PCREL34_NOTOC),
"R_PPC64_REL14": reflect.ValueOf(elf.R_PPC64_REL14),
"R_PPC64_REL14_BRNTAKEN": reflect.ValueOf(elf.R_PPC64_REL14_BRNTAKEN),
"R_PPC64_REL14_BRTAKEN": reflect.ValueOf(elf.R_PPC64_REL14_BRTAKEN),
"R_PPC64_REL16": reflect.ValueOf(elf.R_PPC64_REL16),
"R_PPC64_REL16DX_HA": reflect.ValueOf(elf.R_PPC64_REL16DX_HA),
"R_PPC64_REL16_HA": reflect.ValueOf(elf.R_PPC64_REL16_HA),
"R_PPC64_REL16_HI": reflect.ValueOf(elf.R_PPC64_REL16_HI),
"R_PPC64_REL16_HIGH": reflect.ValueOf(elf.R_PPC64_REL16_HIGH),
"R_PPC64_REL16_HIGHA": reflect.ValueOf(elf.R_PPC64_REL16_HIGHA),
"R_PPC64_REL16_HIGHER": reflect.ValueOf(elf.R_PPC64_REL16_HIGHER),
"R_PPC64_REL16_HIGHER34": reflect.ValueOf(elf.R_PPC64_REL16_HIGHER34),
"R_PPC64_REL16_HIGHERA": reflect.ValueOf(elf.R_PPC64_REL16_HIGHERA),
"R_PPC64_REL16_HIGHERA34": reflect.ValueOf(elf.R_PPC64_REL16_HIGHERA34),
"R_PPC64_REL16_HIGHEST": reflect.ValueOf(elf.R_PPC64_REL16_HIGHEST),
"R_PPC64_REL16_HIGHEST34": reflect.ValueOf(elf.R_PPC64_REL16_HIGHEST34),
"R_PPC64_REL16_HIGHESTA": reflect.ValueOf(elf.R_PPC64_REL16_HIGHESTA),
"R_PPC64_REL16_HIGHESTA34": reflect.ValueOf(elf.R_PPC64_REL16_HIGHESTA34),
"R_PPC64_REL16_LO": reflect.ValueOf(elf.R_PPC64_REL16_LO),
"R_PPC64_REL24": reflect.ValueOf(elf.R_PPC64_REL24),
"R_PPC64_REL24_NOTOC": reflect.ValueOf(elf.R_PPC64_REL24_NOTOC),
"R_PPC64_REL24_P9NOTOC": reflect.ValueOf(elf.R_PPC64_REL24_P9NOTOC),
"R_PPC64_REL30": reflect.ValueOf(elf.R_PPC64_REL30),
"R_PPC64_REL32": reflect.ValueOf(elf.R_PPC64_REL32),
"R_PPC64_REL64": reflect.ValueOf(elf.R_PPC64_REL64),
"R_PPC64_RELATIVE": reflect.ValueOf(elf.R_PPC64_RELATIVE),
"R_PPC64_SECTOFF": reflect.ValueOf(elf.R_PPC64_SECTOFF),
"R_PPC64_SECTOFF_DS": reflect.ValueOf(elf.R_PPC64_SECTOFF_DS),
"R_PPC64_SECTOFF_HA": reflect.ValueOf(elf.R_PPC64_SECTOFF_HA),
"R_PPC64_SECTOFF_HI": reflect.ValueOf(elf.R_PPC64_SECTOFF_HI),
"R_PPC64_SECTOFF_LO": reflect.ValueOf(elf.R_PPC64_SECTOFF_LO),
"R_PPC64_SECTOFF_LO_DS": reflect.ValueOf(elf.R_PPC64_SECTOFF_LO_DS),
"R_PPC64_TLS": reflect.ValueOf(elf.R_PPC64_TLS),
"R_PPC64_TLSGD": reflect.ValueOf(elf.R_PPC64_TLSGD),
"R_PPC64_TLSLD": reflect.ValueOf(elf.R_PPC64_TLSLD),
"R_PPC64_TOC": reflect.ValueOf(elf.R_PPC64_TOC),
"R_PPC64_TOC16": reflect.ValueOf(elf.R_PPC64_TOC16),
"R_PPC64_TOC16_DS": reflect.ValueOf(elf.R_PPC64_TOC16_DS),
"R_PPC64_TOC16_HA": reflect.ValueOf(elf.R_PPC64_TOC16_HA),
"R_PPC64_TOC16_HI": reflect.ValueOf(elf.R_PPC64_TOC16_HI),
"R_PPC64_TOC16_LO": reflect.ValueOf(elf.R_PPC64_TOC16_LO),
"R_PPC64_TOC16_LO_DS": reflect.ValueOf(elf.R_PPC64_TOC16_LO_DS),
"R_PPC64_TOCSAVE": reflect.ValueOf(elf.R_PPC64_TOCSAVE),
"R_PPC64_TPREL16": reflect.ValueOf(elf.R_PPC64_TPREL16),
"R_PPC64_TPREL16_DS": reflect.ValueOf(elf.R_PPC64_TPREL16_DS),
"R_PPC64_TPREL16_HA": reflect.ValueOf(elf.R_PPC64_TPREL16_HA),
"R_PPC64_TPREL16_HI": reflect.ValueOf(elf.R_PPC64_TPREL16_HI),
"R_PPC64_TPREL16_HIGH": reflect.ValueOf(elf.R_PPC64_TPREL16_HIGH),
"R_PPC64_TPREL16_HIGHA": reflect.ValueOf(elf.R_PPC64_TPREL16_HIGHA),
"R_PPC64_TPREL16_HIGHER": reflect.ValueOf(elf.R_PPC64_TPREL16_HIGHER),
"R_PPC64_TPREL16_HIGHERA": reflect.ValueOf(elf.R_PPC64_TPREL16_HIGHERA),
"R_PPC64_TPREL16_HIGHEST": reflect.ValueOf(elf.R_PPC64_TPREL16_HIGHEST),
"R_PPC64_TPREL16_HIGHESTA": reflect.ValueOf(elf.R_PPC64_TPREL16_HIGHESTA),
"R_PPC64_TPREL16_LO": reflect.ValueOf(elf.R_PPC64_TPREL16_LO),
"R_PPC64_TPREL16_LO_DS": reflect.ValueOf(elf.R_PPC64_TPREL16_LO_DS),
"R_PPC64_TPREL34": reflect.ValueOf(elf.R_PPC64_TPREL34),
"R_PPC64_TPREL64": reflect.ValueOf(elf.R_PPC64_TPREL64),
"R_PPC64_UADDR16": reflect.ValueOf(elf.R_PPC64_UADDR16),
"R_PPC64_UADDR32": reflect.ValueOf(elf.R_PPC64_UADDR32),
"R_PPC64_UADDR64": reflect.ValueOf(elf.R_PPC64_UADDR64),
"R_PPC_ADDR14": reflect.ValueOf(elf.R_PPC_ADDR14),
"R_PPC_ADDR14_BRNTAKEN": reflect.ValueOf(elf.R_PPC_ADDR14_BRNTAKEN),
"R_PPC_ADDR14_BRTAKEN": reflect.ValueOf(elf.R_PPC_ADDR14_BRTAKEN),
"R_PPC_ADDR16": reflect.ValueOf(elf.R_PPC_ADDR16),
"R_PPC_ADDR16_HA": reflect.ValueOf(elf.R_PPC_ADDR16_HA),
"R_PPC_ADDR16_HI": reflect.ValueOf(elf.R_PPC_ADDR16_HI),
"R_PPC_ADDR16_LO": reflect.ValueOf(elf.R_PPC_ADDR16_LO),
"R_PPC_ADDR24": reflect.ValueOf(elf.R_PPC_ADDR24),
"R_PPC_ADDR32": reflect.ValueOf(elf.R_PPC_ADDR32),
"R_PPC_COPY": reflect.ValueOf(elf.R_PPC_COPY),
"R_PPC_DTPMOD32": reflect.ValueOf(elf.R_PPC_DTPMOD32),
"R_PPC_DTPREL16": reflect.ValueOf(elf.R_PPC_DTPREL16),
"R_PPC_DTPREL16_HA": reflect.ValueOf(elf.R_PPC_DTPREL16_HA),
"R_PPC_DTPREL16_HI": reflect.ValueOf(elf.R_PPC_DTPREL16_HI),
"R_PPC_DTPREL16_LO": reflect.ValueOf(elf.R_PPC_DTPREL16_LO),
"R_PPC_DTPREL32": reflect.ValueOf(elf.R_PPC_DTPREL32),
"R_PPC_EMB_BIT_FLD": reflect.ValueOf(elf.R_PPC_EMB_BIT_FLD),
"R_PPC_EMB_MRKREF": reflect.ValueOf(elf.R_PPC_EMB_MRKREF),
"R_PPC_EMB_NADDR16": reflect.ValueOf(elf.R_PPC_EMB_NADDR16),
"R_PPC_EMB_NADDR16_HA": reflect.ValueOf(elf.R_PPC_EMB_NADDR16_HA),
"R_PPC_EMB_NADDR16_HI": reflect.ValueOf(elf.R_PPC_EMB_NADDR16_HI),
"R_PPC_EMB_NADDR16_LO": reflect.ValueOf(elf.R_PPC_EMB_NADDR16_LO),
"R_PPC_EMB_NADDR32": reflect.ValueOf(elf.R_PPC_EMB_NADDR32),
"R_PPC_EMB_RELSDA": reflect.ValueOf(elf.R_PPC_EMB_RELSDA),
"R_PPC_EMB_RELSEC16": reflect.ValueOf(elf.R_PPC_EMB_RELSEC16),
"R_PPC_EMB_RELST_HA": reflect.ValueOf(elf.R_PPC_EMB_RELST_HA),
"R_PPC_EMB_RELST_HI": reflect.ValueOf(elf.R_PPC_EMB_RELST_HI),
"R_PPC_EMB_RELST_LO": reflect.ValueOf(elf.R_PPC_EMB_RELST_LO),
"R_PPC_EMB_SDA21": reflect.ValueOf(elf.R_PPC_EMB_SDA21),
"R_PPC_EMB_SDA2I16": reflect.ValueOf(elf.R_PPC_EMB_SDA2I16),
"R_PPC_EMB_SDA2REL": reflect.ValueOf(elf.R_PPC_EMB_SDA2REL),
"R_PPC_EMB_SDAI16": reflect.ValueOf(elf.R_PPC_EMB_SDAI16),
"R_PPC_GLOB_DAT": reflect.ValueOf(elf.R_PPC_GLOB_DAT),
"R_PPC_GOT16": reflect.ValueOf(elf.R_PPC_GOT16),
"R_PPC_GOT16_HA": reflect.ValueOf(elf.R_PPC_GOT16_HA),
"R_PPC_GOT16_HI": reflect.ValueOf(elf.R_PPC_GOT16_HI),
"R_PPC_GOT16_LO": reflect.ValueOf(elf.R_PPC_GOT16_LO),
"R_PPC_GOT_TLSGD16": reflect.ValueOf(elf.R_PPC_GOT_TLSGD16),
"R_PPC_GOT_TLSGD16_HA": reflect.ValueOf(elf.R_PPC_GOT_TLSGD16_HA),
"R_PPC_GOT_TLSGD16_HI": reflect.ValueOf(elf.R_PPC_GOT_TLSGD16_HI),
"R_PPC_GOT_TLSGD16_LO": reflect.ValueOf(elf.R_PPC_GOT_TLSGD16_LO),
"R_PPC_GOT_TLSLD16": reflect.ValueOf(elf.R_PPC_GOT_TLSLD16),
"R_PPC_GOT_TLSLD16_HA": reflect.ValueOf(elf.R_PPC_GOT_TLSLD16_HA),
"R_PPC_GOT_TLSLD16_HI": reflect.ValueOf(elf.R_PPC_GOT_TLSLD16_HI),
"R_PPC_GOT_TLSLD16_LO": reflect.ValueOf(elf.R_PPC_GOT_TLSLD16_LO),
"R_PPC_GOT_TPREL16": reflect.ValueOf(elf.R_PPC_GOT_TPREL16),
"R_PPC_GOT_TPREL16_HA": reflect.ValueOf(elf.R_PPC_GOT_TPREL16_HA),
"R_PPC_GOT_TPREL16_HI": reflect.ValueOf(elf.R_PPC_GOT_TPREL16_HI),
"R_PPC_GOT_TPREL16_LO": reflect.ValueOf(elf.R_PPC_GOT_TPREL16_LO),
"R_PPC_JMP_SLOT": reflect.ValueOf(elf.R_PPC_JMP_SLOT),
"R_PPC_LOCAL24PC": reflect.ValueOf(elf.R_PPC_LOCAL24PC),
"R_PPC_NONE": reflect.ValueOf(elf.R_PPC_NONE),
"R_PPC_PLT16_HA": reflect.ValueOf(elf.R_PPC_PLT16_HA),
"R_PPC_PLT16_HI": reflect.ValueOf(elf.R_PPC_PLT16_HI),
"R_PPC_PLT16_LO": reflect.ValueOf(elf.R_PPC_PLT16_LO),
"R_PPC_PLT32": reflect.ValueOf(elf.R_PPC_PLT32),
"R_PPC_PLTREL24": reflect.ValueOf(elf.R_PPC_PLTREL24),
"R_PPC_PLTREL32": reflect.ValueOf(elf.R_PPC_PLTREL32),
"R_PPC_REL14": reflect.ValueOf(elf.R_PPC_REL14),
"R_PPC_REL14_BRNTAKEN": reflect.ValueOf(elf.R_PPC_REL14_BRNTAKEN),
"R_PPC_REL14_BRTAKEN": reflect.ValueOf(elf.R_PPC_REL14_BRTAKEN),
"R_PPC_REL24": reflect.ValueOf(elf.R_PPC_REL24),
"R_PPC_REL32": reflect.ValueOf(elf.R_PPC_REL32),
"R_PPC_RELATIVE": reflect.ValueOf(elf.R_PPC_RELATIVE),
"R_PPC_SDAREL16": reflect.ValueOf(elf.R_PPC_SDAREL16),
"R_PPC_SECTOFF": reflect.ValueOf(elf.R_PPC_SECTOFF),
"R_PPC_SECTOFF_HA": reflect.ValueOf(elf.R_PPC_SECTOFF_HA),
"R_PPC_SECTOFF_HI": reflect.ValueOf(elf.R_PPC_SECTOFF_HI),
"R_PPC_SECTOFF_LO": reflect.ValueOf(elf.R_PPC_SECTOFF_LO),
"R_PPC_TLS": reflect.ValueOf(elf.R_PPC_TLS),
"R_PPC_TPREL16": reflect.ValueOf(elf.R_PPC_TPREL16),
"R_PPC_TPREL16_HA": reflect.ValueOf(elf.R_PPC_TPREL16_HA),
"R_PPC_TPREL16_HI": reflect.ValueOf(elf.R_PPC_TPREL16_HI),
"R_PPC_TPREL16_LO": reflect.ValueOf(elf.R_PPC_TPREL16_LO),
"R_PPC_TPREL32": reflect.ValueOf(elf.R_PPC_TPREL32),
"R_PPC_UADDR16": reflect.ValueOf(elf.R_PPC_UADDR16),
"R_PPC_UADDR32": reflect.ValueOf(elf.R_PPC_UADDR32),
"R_RISCV_32": reflect.ValueOf(elf.R_RISCV_32),
"R_RISCV_32_PCREL": reflect.ValueOf(elf.R_RISCV_32_PCREL),
"R_RISCV_64": reflect.ValueOf(elf.R_RISCV_64),
"R_RISCV_ADD16": reflect.ValueOf(elf.R_RISCV_ADD16),
"R_RISCV_ADD32": reflect.ValueOf(elf.R_RISCV_ADD32),
"R_RISCV_ADD64": reflect.ValueOf(elf.R_RISCV_ADD64),
"R_RISCV_ADD8": reflect.ValueOf(elf.R_RISCV_ADD8),
"R_RISCV_ALIGN": reflect.ValueOf(elf.R_RISCV_ALIGN),
"R_RISCV_BRANCH": reflect.ValueOf(elf.R_RISCV_BRANCH),
"R_RISCV_CALL": reflect.ValueOf(elf.R_RISCV_CALL),
"R_RISCV_CALL_PLT": reflect.ValueOf(elf.R_RISCV_CALL_PLT),
"R_RISCV_COPY": reflect.ValueOf(elf.R_RISCV_COPY),
"R_RISCV_GNU_VTENTRY": reflect.ValueOf(elf.R_RISCV_GNU_VTENTRY),
"R_RISCV_GNU_VTINHERIT": reflect.ValueOf(elf.R_RISCV_GNU_VTINHERIT),
"R_RISCV_GOT_HI20": reflect.ValueOf(elf.R_RISCV_GOT_HI20),
"R_RISCV_GPREL_I": reflect.ValueOf(elf.R_RISCV_GPREL_I),
"R_RISCV_GPREL_S": reflect.ValueOf(elf.R_RISCV_GPREL_S),
"R_RISCV_HI20": reflect.ValueOf(elf.R_RISCV_HI20),
"R_RISCV_JAL": reflect.ValueOf(elf.R_RISCV_JAL),
"R_RISCV_JUMP_SLOT": reflect.ValueOf(elf.R_RISCV_JUMP_SLOT),
"R_RISCV_LO12_I": reflect.ValueOf(elf.R_RISCV_LO12_I),
"R_RISCV_LO12_S": reflect.ValueOf(elf.R_RISCV_LO12_S),
"R_RISCV_NONE": reflect.ValueOf(elf.R_RISCV_NONE),
"R_RISCV_PCREL_HI20": reflect.ValueOf(elf.R_RISCV_PCREL_HI20),
"R_RISCV_PCREL_LO12_I": reflect.ValueOf(elf.R_RISCV_PCREL_LO12_I),
"R_RISCV_PCREL_LO12_S": reflect.ValueOf(elf.R_RISCV_PCREL_LO12_S),
"R_RISCV_RELATIVE": reflect.ValueOf(elf.R_RISCV_RELATIVE),
"R_RISCV_RELAX": reflect.ValueOf(elf.R_RISCV_RELAX),
"R_RISCV_RVC_BRANCH": reflect.ValueOf(elf.R_RISCV_RVC_BRANCH),
"R_RISCV_RVC_JUMP": reflect.ValueOf(elf.R_RISCV_RVC_JUMP),
"R_RISCV_RVC_LUI": reflect.ValueOf(elf.R_RISCV_RVC_LUI),
"R_RISCV_SET16": reflect.ValueOf(elf.R_RISCV_SET16),
"R_RISCV_SET32": reflect.ValueOf(elf.R_RISCV_SET32),
"R_RISCV_SET6": reflect.ValueOf(elf.R_RISCV_SET6),
"R_RISCV_SET8": reflect.ValueOf(elf.R_RISCV_SET8),
"R_RISCV_SUB16": reflect.ValueOf(elf.R_RISCV_SUB16),
"R_RISCV_SUB32": reflect.ValueOf(elf.R_RISCV_SUB32),
"R_RISCV_SUB6": reflect.ValueOf(elf.R_RISCV_SUB6),
"R_RISCV_SUB64": reflect.ValueOf(elf.R_RISCV_SUB64),
"R_RISCV_SUB8": reflect.ValueOf(elf.R_RISCV_SUB8),
"R_RISCV_TLS_DTPMOD32": reflect.ValueOf(elf.R_RISCV_TLS_DTPMOD32),
"R_RISCV_TLS_DTPMOD64": reflect.ValueOf(elf.R_RISCV_TLS_DTPMOD64),
"R_RISCV_TLS_DTPREL32": reflect.ValueOf(elf.R_RISCV_TLS_DTPREL32),
"R_RISCV_TLS_DTPREL64": reflect.ValueOf(elf.R_RISCV_TLS_DTPREL64),
"R_RISCV_TLS_GD_HI20": reflect.ValueOf(elf.R_RISCV_TLS_GD_HI20),
"R_RISCV_TLS_GOT_HI20": reflect.ValueOf(elf.R_RISCV_TLS_GOT_HI20),
"R_RISCV_TLS_TPREL32": reflect.ValueOf(elf.R_RISCV_TLS_TPREL32),
"R_RISCV_TLS_TPREL64": reflect.ValueOf(elf.R_RISCV_TLS_TPREL64),
"R_RISCV_TPREL_ADD": reflect.ValueOf(elf.R_RISCV_TPREL_ADD),
"R_RISCV_TPREL_HI20": reflect.ValueOf(elf.R_RISCV_TPREL_HI20),
"R_RISCV_TPREL_I": reflect.ValueOf(elf.R_RISCV_TPREL_I),
"R_RISCV_TPREL_LO12_I": reflect.ValueOf(elf.R_RISCV_TPREL_LO12_I),
"R_RISCV_TPREL_LO12_S": reflect.ValueOf(elf.R_RISCV_TPREL_LO12_S),
"R_RISCV_TPREL_S": reflect.ValueOf(elf.R_RISCV_TPREL_S),
"R_SPARC_10": reflect.ValueOf(elf.R_SPARC_10),
"R_SPARC_11": reflect.ValueOf(elf.R_SPARC_11),
"R_SPARC_13": reflect.ValueOf(elf.R_SPARC_13),
"R_SPARC_16": reflect.ValueOf(elf.R_SPARC_16),
"R_SPARC_22": reflect.ValueOf(elf.R_SPARC_22),
"R_SPARC_32": reflect.ValueOf(elf.R_SPARC_32),
"R_SPARC_5": reflect.ValueOf(elf.R_SPARC_5),
"R_SPARC_6": reflect.ValueOf(elf.R_SPARC_6),
"R_SPARC_64": reflect.ValueOf(elf.R_SPARC_64),
"R_SPARC_7": reflect.ValueOf(elf.R_SPARC_7),
"R_SPARC_8": reflect.ValueOf(elf.R_SPARC_8),
"R_SPARC_COPY": reflect.ValueOf(elf.R_SPARC_COPY),
"R_SPARC_DISP16": reflect.ValueOf(elf.R_SPARC_DISP16),
"R_SPARC_DISP32": reflect.ValueOf(elf.R_SPARC_DISP32),
"R_SPARC_DISP64": reflect.ValueOf(elf.R_SPARC_DISP64),
"R_SPARC_DISP8": reflect.ValueOf(elf.R_SPARC_DISP8),
"R_SPARC_GLOB_DAT": reflect.ValueOf(elf.R_SPARC_GLOB_DAT),
"R_SPARC_GLOB_JMP": reflect.ValueOf(elf.R_SPARC_GLOB_JMP),
"R_SPARC_GOT10": reflect.ValueOf(elf.R_SPARC_GOT10),
"R_SPARC_GOT13": reflect.ValueOf(elf.R_SPARC_GOT13),
"R_SPARC_GOT22": reflect.ValueOf(elf.R_SPARC_GOT22),
"R_SPARC_H44": reflect.ValueOf(elf.R_SPARC_H44),
"R_SPARC_HH22": reflect.ValueOf(elf.R_SPARC_HH22),
"R_SPARC_HI22": reflect.ValueOf(elf.R_SPARC_HI22),
"R_SPARC_HIPLT22": reflect.ValueOf(elf.R_SPARC_HIPLT22),
"R_SPARC_HIX22": reflect.ValueOf(elf.R_SPARC_HIX22),
"R_SPARC_HM10": reflect.ValueOf(elf.R_SPARC_HM10),
"R_SPARC_JMP_SLOT": reflect.ValueOf(elf.R_SPARC_JMP_SLOT),
"R_SPARC_L44": reflect.ValueOf(elf.R_SPARC_L44),
"R_SPARC_LM22": reflect.ValueOf(elf.R_SPARC_LM22),
"R_SPARC_LO10": reflect.ValueOf(elf.R_SPARC_LO10),
"R_SPARC_LOPLT10": reflect.ValueOf(elf.R_SPARC_LOPLT10),
"R_SPARC_LOX10": reflect.ValueOf(elf.R_SPARC_LOX10),
"R_SPARC_M44": reflect.ValueOf(elf.R_SPARC_M44),
"R_SPARC_NONE": reflect.ValueOf(elf.R_SPARC_NONE),
"R_SPARC_OLO10": reflect.ValueOf(elf.R_SPARC_OLO10),
"R_SPARC_PC10": reflect.ValueOf(elf.R_SPARC_PC10),
"R_SPARC_PC22": reflect.ValueOf(elf.R_SPARC_PC22),
"R_SPARC_PCPLT10": reflect.ValueOf(elf.R_SPARC_PCPLT10),
"R_SPARC_PCPLT22": reflect.ValueOf(elf.R_SPARC_PCPLT22),
"R_SPARC_PCPLT32": reflect.ValueOf(elf.R_SPARC_PCPLT32),
"R_SPARC_PC_HH22": reflect.ValueOf(elf.R_SPARC_PC_HH22),
"R_SPARC_PC_HM10": reflect.ValueOf(elf.R_SPARC_PC_HM10),
"R_SPARC_PC_LM22": reflect.ValueOf(elf.R_SPARC_PC_LM22),
"R_SPARC_PLT32": reflect.ValueOf(elf.R_SPARC_PLT32),
"R_SPARC_PLT64": reflect.ValueOf(elf.R_SPARC_PLT64),
"R_SPARC_REGISTER": reflect.ValueOf(elf.R_SPARC_REGISTER),
"R_SPARC_RELATIVE": reflect.ValueOf(elf.R_SPARC_RELATIVE),
"R_SPARC_UA16": reflect.ValueOf(elf.R_SPARC_UA16),
"R_SPARC_UA32": reflect.ValueOf(elf.R_SPARC_UA32),
"R_SPARC_UA64": reflect.ValueOf(elf.R_SPARC_UA64),
"R_SPARC_WDISP16": reflect.ValueOf(elf.R_SPARC_WDISP16),
"R_SPARC_WDISP19": reflect.ValueOf(elf.R_SPARC_WDISP19),
"R_SPARC_WDISP22": reflect.ValueOf(elf.R_SPARC_WDISP22),
"R_SPARC_WDISP30": reflect.ValueOf(elf.R_SPARC_WDISP30),
"R_SPARC_WPLT30": reflect.ValueOf(elf.R_SPARC_WPLT30),
"R_SYM32": reflect.ValueOf(elf.R_SYM32),
"R_SYM64": reflect.ValueOf(elf.R_SYM64),
"R_TYPE32": reflect.ValueOf(elf.R_TYPE32),
"R_TYPE64": reflect.ValueOf(elf.R_TYPE64),
"R_X86_64_16": reflect.ValueOf(elf.R_X86_64_16),
"R_X86_64_32": reflect.ValueOf(elf.R_X86_64_32),
"R_X86_64_32S": reflect.ValueOf(elf.R_X86_64_32S),
"R_X86_64_64": reflect.ValueOf(elf.R_X86_64_64),
"R_X86_64_8": reflect.ValueOf(elf.R_X86_64_8),
"R_X86_64_COPY": reflect.ValueOf(elf.R_X86_64_COPY),
"R_X86_64_DTPMOD64": reflect.ValueOf(elf.R_X86_64_DTPMOD64),
"R_X86_64_DTPOFF32": reflect.ValueOf(elf.R_X86_64_DTPOFF32),
"R_X86_64_DTPOFF64": reflect.ValueOf(elf.R_X86_64_DTPOFF64),
"R_X86_64_GLOB_DAT": reflect.ValueOf(elf.R_X86_64_GLOB_DAT),
"R_X86_64_GOT32": reflect.ValueOf(elf.R_X86_64_GOT32),
"R_X86_64_GOT64": reflect.ValueOf(elf.R_X86_64_GOT64),
"R_X86_64_GOTOFF64": reflect.ValueOf(elf.R_X86_64_GOTOFF64),
"R_X86_64_GOTPC32": reflect.ValueOf(elf.R_X86_64_GOTPC32),
"R_X86_64_GOTPC32_TLSDESC": reflect.ValueOf(elf.R_X86_64_GOTPC32_TLSDESC),
"R_X86_64_GOTPC64": reflect.ValueOf(elf.R_X86_64_GOTPC64),
"R_X86_64_GOTPCREL": reflect.ValueOf(elf.R_X86_64_GOTPCREL),
"R_X86_64_GOTPCREL64": reflect.ValueOf(elf.R_X86_64_GOTPCREL64),
"R_X86_64_GOTPCRELX": reflect.ValueOf(elf.R_X86_64_GOTPCRELX),
"R_X86_64_GOTPLT64": reflect.ValueOf(elf.R_X86_64_GOTPLT64),
"R_X86_64_GOTTPOFF": reflect.ValueOf(elf.R_X86_64_GOTTPOFF),
"R_X86_64_IRELATIVE": reflect.ValueOf(elf.R_X86_64_IRELATIVE),
"R_X86_64_JMP_SLOT": reflect.ValueOf(elf.R_X86_64_JMP_SLOT),
"R_X86_64_NONE": reflect.ValueOf(elf.R_X86_64_NONE),
"R_X86_64_PC16": reflect.ValueOf(elf.R_X86_64_PC16),
"R_X86_64_PC32": reflect.ValueOf(elf.R_X86_64_PC32),
"R_X86_64_PC32_BND": reflect.ValueOf(elf.R_X86_64_PC32_BND),
"R_X86_64_PC64": reflect.ValueOf(elf.R_X86_64_PC64),
"R_X86_64_PC8": reflect.ValueOf(elf.R_X86_64_PC8),
"R_X86_64_PLT32": reflect.ValueOf(elf.R_X86_64_PLT32),
"R_X86_64_PLT32_BND": reflect.ValueOf(elf.R_X86_64_PLT32_BND),
"R_X86_64_PLTOFF64": reflect.ValueOf(elf.R_X86_64_PLTOFF64),
"R_X86_64_RELATIVE": reflect.ValueOf(elf.R_X86_64_RELATIVE),
"R_X86_64_RELATIVE64": reflect.ValueOf(elf.R_X86_64_RELATIVE64),
"R_X86_64_REX_GOTPCRELX": reflect.ValueOf(elf.R_X86_64_REX_GOTPCRELX),
"R_X86_64_SIZE32": reflect.ValueOf(elf.R_X86_64_SIZE32),
"R_X86_64_SIZE64": reflect.ValueOf(elf.R_X86_64_SIZE64),
"R_X86_64_TLSDESC": reflect.ValueOf(elf.R_X86_64_TLSDESC),
"R_X86_64_TLSDESC_CALL": reflect.ValueOf(elf.R_X86_64_TLSDESC_CALL),
"R_X86_64_TLSGD": reflect.ValueOf(elf.R_X86_64_TLSGD),
"R_X86_64_TLSLD": reflect.ValueOf(elf.R_X86_64_TLSLD),
"R_X86_64_TPOFF32": reflect.ValueOf(elf.R_X86_64_TPOFF32),
"R_X86_64_TPOFF64": reflect.ValueOf(elf.R_X86_64_TPOFF64),
"SHF_ALLOC": reflect.ValueOf(elf.SHF_ALLOC),
"SHF_COMPRESSED": reflect.ValueOf(elf.SHF_COMPRESSED),
"SHF_EXECINSTR": reflect.ValueOf(elf.SHF_EXECINSTR),
"SHF_GROUP": reflect.ValueOf(elf.SHF_GROUP),
"SHF_INFO_LINK": reflect.ValueOf(elf.SHF_INFO_LINK),
"SHF_LINK_ORDER": reflect.ValueOf(elf.SHF_LINK_ORDER),
"SHF_MASKOS": reflect.ValueOf(elf.SHF_MASKOS),
"SHF_MASKPROC": reflect.ValueOf(elf.SHF_MASKPROC),
"SHF_MERGE": reflect.ValueOf(elf.SHF_MERGE),
"SHF_OS_NONCONFORMING": reflect.ValueOf(elf.SHF_OS_NONCONFORMING),
"SHF_STRINGS": reflect.ValueOf(elf.SHF_STRINGS),
"SHF_TLS": reflect.ValueOf(elf.SHF_TLS),
"SHF_WRITE": reflect.ValueOf(elf.SHF_WRITE),
"SHN_ABS": reflect.ValueOf(elf.SHN_ABS),
"SHN_COMMON": reflect.ValueOf(elf.SHN_COMMON),
"SHN_HIOS": reflect.ValueOf(elf.SHN_HIOS),
"SHN_HIPROC": reflect.ValueOf(elf.SHN_HIPROC),
"SHN_HIRESERVE": reflect.ValueOf(elf.SHN_HIRESERVE),
"SHN_LOOS": reflect.ValueOf(elf.SHN_LOOS),
"SHN_LOPROC": reflect.ValueOf(elf.SHN_LOPROC),
"SHN_LORESERVE": reflect.ValueOf(elf.SHN_LORESERVE),
"SHN_UNDEF": reflect.ValueOf(elf.SHN_UNDEF),
"SHN_XINDEX": reflect.ValueOf(elf.SHN_XINDEX),
"SHT_DYNAMIC": reflect.ValueOf(elf.SHT_DYNAMIC),
"SHT_DYNSYM": reflect.ValueOf(elf.SHT_DYNSYM),
"SHT_FINI_ARRAY": reflect.ValueOf(elf.SHT_FINI_ARRAY),
"SHT_GNU_ATTRIBUTES": reflect.ValueOf(elf.SHT_GNU_ATTRIBUTES),
"SHT_GNU_HASH": reflect.ValueOf(elf.SHT_GNU_HASH),
"SHT_GNU_LIBLIST": reflect.ValueOf(elf.SHT_GNU_LIBLIST),
"SHT_GNU_VERDEF": reflect.ValueOf(elf.SHT_GNU_VERDEF),
"SHT_GNU_VERNEED": reflect.ValueOf(elf.SHT_GNU_VERNEED),
"SHT_GNU_VERSYM": reflect.ValueOf(elf.SHT_GNU_VERSYM),
"SHT_GROUP": reflect.ValueOf(elf.SHT_GROUP),
"SHT_HASH": reflect.ValueOf(elf.SHT_HASH),
"SHT_HIOS": reflect.ValueOf(elf.SHT_HIOS),
"SHT_HIPROC": reflect.ValueOf(elf.SHT_HIPROC),
"SHT_HIUSER": reflect.ValueOf(elf.SHT_HIUSER),
"SHT_INIT_ARRAY": reflect.ValueOf(elf.SHT_INIT_ARRAY),
"SHT_LOOS": reflect.ValueOf(elf.SHT_LOOS),
"SHT_LOPROC": reflect.ValueOf(elf.SHT_LOPROC),
"SHT_LOUSER": reflect.ValueOf(elf.SHT_LOUSER),
"SHT_MIPS_ABIFLAGS": reflect.ValueOf(elf.SHT_MIPS_ABIFLAGS),
"SHT_NOBITS": reflect.ValueOf(elf.SHT_NOBITS),
"SHT_NOTE": reflect.ValueOf(elf.SHT_NOTE),
"SHT_NULL": reflect.ValueOf(elf.SHT_NULL),
"SHT_PREINIT_ARRAY": reflect.ValueOf(elf.SHT_PREINIT_ARRAY),
"SHT_PROGBITS": reflect.ValueOf(elf.SHT_PROGBITS),
"SHT_REL": reflect.ValueOf(elf.SHT_REL),
"SHT_RELA": reflect.ValueOf(elf.SHT_RELA),
"SHT_SHLIB": reflect.ValueOf(elf.SHT_SHLIB),
"SHT_STRTAB": reflect.ValueOf(elf.SHT_STRTAB),
"SHT_SYMTAB": reflect.ValueOf(elf.SHT_SYMTAB),
"SHT_SYMTAB_SHNDX": reflect.ValueOf(elf.SHT_SYMTAB_SHNDX),
"STB_GLOBAL": reflect.ValueOf(elf.STB_GLOBAL),
"STB_HIOS": reflect.ValueOf(elf.STB_HIOS),
"STB_HIPROC": reflect.ValueOf(elf.STB_HIPROC),
"STB_LOCAL": reflect.ValueOf(elf.STB_LOCAL),
"STB_LOOS": reflect.ValueOf(elf.STB_LOOS),
"STB_LOPROC": reflect.ValueOf(elf.STB_LOPROC),
"STB_WEAK": reflect.ValueOf(elf.STB_WEAK),
"STT_COMMON": reflect.ValueOf(elf.STT_COMMON),
"STT_FILE": reflect.ValueOf(elf.STT_FILE),
"STT_FUNC": reflect.ValueOf(elf.STT_FUNC),
"STT_HIOS": reflect.ValueOf(elf.STT_HIOS),
"STT_HIPROC": reflect.ValueOf(elf.STT_HIPROC),
"STT_LOOS": reflect.ValueOf(elf.STT_LOOS),
"STT_LOPROC": reflect.ValueOf(elf.STT_LOPROC),
"STT_NOTYPE": reflect.ValueOf(elf.STT_NOTYPE),
"STT_OBJECT": reflect.ValueOf(elf.STT_OBJECT),
"STT_SECTION": reflect.ValueOf(elf.STT_SECTION),
"STT_TLS": reflect.ValueOf(elf.STT_TLS),
"STV_DEFAULT": reflect.ValueOf(elf.STV_DEFAULT),
"STV_HIDDEN": reflect.ValueOf(elf.STV_HIDDEN),
"STV_INTERNAL": reflect.ValueOf(elf.STV_INTERNAL),
"STV_PROTECTED": reflect.ValueOf(elf.STV_PROTECTED),
"ST_BIND": reflect.ValueOf(elf.ST_BIND),
"ST_INFO": reflect.ValueOf(elf.ST_INFO),
"ST_TYPE": reflect.ValueOf(elf.ST_TYPE),
"ST_VISIBILITY": reflect.ValueOf(elf.ST_VISIBILITY),
"Sym32Size": reflect.ValueOf(constant.MakeFromLiteral("16", token.INT, 0)),
"Sym64Size": reflect.ValueOf(constant.MakeFromLiteral("24", token.INT, 0)),
// type definitions
"Chdr32": reflect.ValueOf((*elf.Chdr32)(nil)),
"Chdr64": reflect.ValueOf((*elf.Chdr64)(nil)),
"Class": reflect.ValueOf((*elf.Class)(nil)),
"CompressionType": reflect.ValueOf((*elf.CompressionType)(nil)),
"Data": reflect.ValueOf((*elf.Data)(nil)),
"Dyn32": reflect.ValueOf((*elf.Dyn32)(nil)),
"Dyn64": reflect.ValueOf((*elf.Dyn64)(nil)),
"DynFlag": reflect.ValueOf((*elf.DynFlag)(nil)),
"DynFlag1": reflect.ValueOf((*elf.DynFlag1)(nil)),
"DynTag": reflect.ValueOf((*elf.DynTag)(nil)),
"File": reflect.ValueOf((*elf.File)(nil)),
"FileHeader": reflect.ValueOf((*elf.FileHeader)(nil)),
"FormatError": reflect.ValueOf((*elf.FormatError)(nil)),
"Header32": reflect.ValueOf((*elf.Header32)(nil)),
"Header64": reflect.ValueOf((*elf.Header64)(nil)),
"ImportedSymbol": reflect.ValueOf((*elf.ImportedSymbol)(nil)),
"Machine": reflect.ValueOf((*elf.Machine)(nil)),
"NType": reflect.ValueOf((*elf.NType)(nil)),
"OSABI": reflect.ValueOf((*elf.OSABI)(nil)),
"Prog": reflect.ValueOf((*elf.Prog)(nil)),
"Prog32": reflect.ValueOf((*elf.Prog32)(nil)),
"Prog64": reflect.ValueOf((*elf.Prog64)(nil)),
"ProgFlag": reflect.ValueOf((*elf.ProgFlag)(nil)),
"ProgHeader": reflect.ValueOf((*elf.ProgHeader)(nil)),
"ProgType": reflect.ValueOf((*elf.ProgType)(nil)),
"R_386": reflect.ValueOf((*elf.R_386)(nil)),
"R_390": reflect.ValueOf((*elf.R_390)(nil)),
"R_AARCH64": reflect.ValueOf((*elf.R_AARCH64)(nil)),
"R_ALPHA": reflect.ValueOf((*elf.R_ALPHA)(nil)),
"R_ARM": reflect.ValueOf((*elf.R_ARM)(nil)),
"R_LARCH": reflect.ValueOf((*elf.R_LARCH)(nil)),
"R_MIPS": reflect.ValueOf((*elf.R_MIPS)(nil)),
"R_PPC": reflect.ValueOf((*elf.R_PPC)(nil)),
"R_PPC64": reflect.ValueOf((*elf.R_PPC64)(nil)),
"R_RISCV": reflect.ValueOf((*elf.R_RISCV)(nil)),
"R_SPARC": reflect.ValueOf((*elf.R_SPARC)(nil)),
"R_X86_64": reflect.ValueOf((*elf.R_X86_64)(nil)),
"Rel32": reflect.ValueOf((*elf.Rel32)(nil)),
"Rel64": reflect.ValueOf((*elf.Rel64)(nil)),
"Rela32": reflect.ValueOf((*elf.Rela32)(nil)),
"Rela64": reflect.ValueOf((*elf.Rela64)(nil)),
"Section": reflect.ValueOf((*elf.Section)(nil)),
"Section32": reflect.ValueOf((*elf.Section32)(nil)),
"Section64": reflect.ValueOf((*elf.Section64)(nil)),
"SectionFlag": reflect.ValueOf((*elf.SectionFlag)(nil)),
"SectionHeader": reflect.ValueOf((*elf.SectionHeader)(nil)),
"SectionIndex": reflect.ValueOf((*elf.SectionIndex)(nil)),
"SectionType": reflect.ValueOf((*elf.SectionType)(nil)),
"Sym32": reflect.ValueOf((*elf.Sym32)(nil)),
"Sym64": reflect.ValueOf((*elf.Sym64)(nil)),
"SymBind": reflect.ValueOf((*elf.SymBind)(nil)),
"SymType": reflect.ValueOf((*elf.SymType)(nil)),
"SymVis": reflect.ValueOf((*elf.SymVis)(nil)),
"Symbol": reflect.ValueOf((*elf.Symbol)(nil)),
"Type": reflect.ValueOf((*elf.Type)(nil)),
"Version": reflect.ValueOf((*elf.Version)(nil)),
}
}
================================================
FILE: stdlib/go1_21_debug_gosym.go
================================================
// Code generated by 'yaegi extract debug/gosym'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"debug/gosym"
"reflect"
)
func init() {
Symbols["debug/gosym/gosym"] = map[string]reflect.Value{
// function, constant and variable definitions
"NewLineTable": reflect.ValueOf(gosym.NewLineTable),
"NewTable": reflect.ValueOf(gosym.NewTable),
// type definitions
"DecodingError": reflect.ValueOf((*gosym.DecodingError)(nil)),
"Func": reflect.ValueOf((*gosym.Func)(nil)),
"LineTable": reflect.ValueOf((*gosym.LineTable)(nil)),
"Obj": reflect.ValueOf((*gosym.Obj)(nil)),
"Sym": reflect.ValueOf((*gosym.Sym)(nil)),
"Table": reflect.ValueOf((*gosym.Table)(nil)),
"UnknownFileError": reflect.ValueOf((*gosym.UnknownFileError)(nil)),
"UnknownLineError": reflect.ValueOf((*gosym.UnknownLineError)(nil)),
}
}
================================================
FILE: stdlib/go1_21_debug_macho.go
================================================
// Code generated by 'yaegi extract debug/macho'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"debug/macho"
"reflect"
)
func init() {
Symbols["debug/macho/macho"] = map[string]reflect.Value{
// function, constant and variable definitions
"ARM64_RELOC_ADDEND": reflect.ValueOf(macho.ARM64_RELOC_ADDEND),
"ARM64_RELOC_BRANCH26": reflect.ValueOf(macho.ARM64_RELOC_BRANCH26),
"ARM64_RELOC_GOT_LOAD_PAGE21": reflect.ValueOf(macho.ARM64_RELOC_GOT_LOAD_PAGE21),
"ARM64_RELOC_GOT_LOAD_PAGEOFF12": reflect.ValueOf(macho.ARM64_RELOC_GOT_LOAD_PAGEOFF12),
"ARM64_RELOC_PAGE21": reflect.ValueOf(macho.ARM64_RELOC_PAGE21),
"ARM64_RELOC_PAGEOFF12": reflect.ValueOf(macho.ARM64_RELOC_PAGEOFF12),
"ARM64_RELOC_POINTER_TO_GOT": reflect.ValueOf(macho.ARM64_RELOC_POINTER_TO_GOT),
"ARM64_RELOC_SUBTRACTOR": reflect.ValueOf(macho.ARM64_RELOC_SUBTRACTOR),
"ARM64_RELOC_TLVP_LOAD_PAGE21": reflect.ValueOf(macho.ARM64_RELOC_TLVP_LOAD_PAGE21),
"ARM64_RELOC_TLVP_LOAD_PAGEOFF12": reflect.ValueOf(macho.ARM64_RELOC_TLVP_LOAD_PAGEOFF12),
"ARM64_RELOC_UNSIGNED": reflect.ValueOf(macho.ARM64_RELOC_UNSIGNED),
"ARM_RELOC_BR24": reflect.ValueOf(macho.ARM_RELOC_BR24),
"ARM_RELOC_HALF": reflect.ValueOf(macho.ARM_RELOC_HALF),
"ARM_RELOC_HALF_SECTDIFF": reflect.ValueOf(macho.ARM_RELOC_HALF_SECTDIFF),
"ARM_RELOC_LOCAL_SECTDIFF": reflect.ValueOf(macho.ARM_RELOC_LOCAL_SECTDIFF),
"ARM_RELOC_PAIR": reflect.ValueOf(macho.ARM_RELOC_PAIR),
"ARM_RELOC_PB_LA_PTR": reflect.ValueOf(macho.ARM_RELOC_PB_LA_PTR),
"ARM_RELOC_SECTDIFF": reflect.ValueOf(macho.ARM_RELOC_SECTDIFF),
"ARM_RELOC_VANILLA": reflect.ValueOf(macho.ARM_RELOC_VANILLA),
"ARM_THUMB_32BIT_BRANCH": reflect.ValueOf(macho.ARM_THUMB_32BIT_BRANCH),
"ARM_THUMB_RELOC_BR22": reflect.ValueOf(macho.ARM_THUMB_RELOC_BR22),
"Cpu386": reflect.ValueOf(macho.Cpu386),
"CpuAmd64": reflect.ValueOf(macho.CpuAmd64),
"CpuArm": reflect.ValueOf(macho.CpuArm),
"CpuArm64": reflect.ValueOf(macho.CpuArm64),
"CpuPpc": reflect.ValueOf(macho.CpuPpc),
"CpuPpc64": reflect.ValueOf(macho.CpuPpc64),
"ErrNotFat": reflect.ValueOf(&macho.ErrNotFat).Elem(),
"FlagAllModsBound": reflect.ValueOf(macho.FlagAllModsBound),
"FlagAllowStackExecution": reflect.ValueOf(macho.FlagAllowStackExecution),
"FlagAppExtensionSafe": reflect.ValueOf(macho.FlagAppExtensionSafe),
"FlagBindAtLoad": reflect.ValueOf(macho.FlagBindAtLoad),
"FlagBindsToWeak": reflect.ValueOf(macho.FlagBindsToWeak),
"FlagCanonical": reflect.ValueOf(macho.FlagCanonical),
"FlagDeadStrippableDylib": reflect.ValueOf(macho.FlagDeadStrippableDylib),
"FlagDyldLink": reflect.ValueOf(macho.FlagDyldLink),
"FlagForceFlat": reflect.ValueOf(macho.FlagForceFlat),
"FlagHasTLVDescriptors": reflect.ValueOf(macho.FlagHasTLVDescriptors),
"FlagIncrLink": reflect.ValueOf(macho.FlagIncrLink),
"FlagLazyInit": reflect.ValueOf(macho.FlagLazyInit),
"FlagNoFixPrebinding": reflect.ValueOf(macho.FlagNoFixPrebinding),
"FlagNoHeapExecution": reflect.ValueOf(macho.FlagNoHeapExecution),
"FlagNoMultiDefs": reflect.ValueOf(macho.FlagNoMultiDefs),
"FlagNoReexportedDylibs": reflect.ValueOf(macho.FlagNoReexportedDylibs),
"FlagNoUndefs": reflect.ValueOf(macho.FlagNoUndefs),
"FlagPIE": reflect.ValueOf(macho.FlagPIE),
"FlagPrebindable": reflect.ValueOf(macho.FlagPrebindable),
"FlagPrebound": reflect.ValueOf(macho.FlagPrebound),
"FlagRootSafe": reflect.ValueOf(macho.FlagRootSafe),
"FlagSetuidSafe": reflect.ValueOf(macho.FlagSetuidSafe),
"FlagSplitSegs": reflect.ValueOf(macho.FlagSplitSegs),
"FlagSubsectionsViaSymbols": reflect.ValueOf(macho.FlagSubsectionsViaSymbols),
"FlagTwoLevel": reflect.ValueOf(macho.FlagTwoLevel),
"FlagWeakDefines": reflect.ValueOf(macho.FlagWeakDefines),
"GENERIC_RELOC_LOCAL_SECTDIFF": reflect.ValueOf(macho.GENERIC_RELOC_LOCAL_SECTDIFF),
"GENERIC_RELOC_PAIR": reflect.ValueOf(macho.GENERIC_RELOC_PAIR),
"GENERIC_RELOC_PB_LA_PTR": reflect.ValueOf(macho.GENERIC_RELOC_PB_LA_PTR),
"GENERIC_RELOC_SECTDIFF": reflect.ValueOf(macho.GENERIC_RELOC_SECTDIFF),
"GENERIC_RELOC_TLV": reflect.ValueOf(macho.GENERIC_RELOC_TLV),
"GENERIC_RELOC_VANILLA": reflect.ValueOf(macho.GENERIC_RELOC_VANILLA),
"LoadCmdDylib": reflect.ValueOf(macho.LoadCmdDylib),
"LoadCmdDylinker": reflect.ValueOf(macho.LoadCmdDylinker),
"LoadCmdDysymtab": reflect.ValueOf(macho.LoadCmdDysymtab),
"LoadCmdRpath": reflect.ValueOf(macho.LoadCmdRpath),
"LoadCmdSegment": reflect.ValueOf(macho.LoadCmdSegment),
"LoadCmdSegment64": reflect.ValueOf(macho.LoadCmdSegment64),
"LoadCmdSymtab": reflect.ValueOf(macho.LoadCmdSymtab),
"LoadCmdThread": reflect.ValueOf(macho.LoadCmdThread),
"LoadCmdUnixThread": reflect.ValueOf(macho.LoadCmdUnixThread),
"Magic32": reflect.ValueOf(macho.Magic32),
"Magic64": reflect.ValueOf(macho.Magic64),
"MagicFat": reflect.ValueOf(macho.MagicFat),
"NewFatFile": reflect.ValueOf(macho.NewFatFile),
"NewFile": reflect.ValueOf(macho.NewFile),
"Open": reflect.ValueOf(macho.Open),
"OpenFat": reflect.ValueOf(macho.OpenFat),
"TypeBundle": reflect.ValueOf(macho.TypeBundle),
"TypeDylib": reflect.ValueOf(macho.TypeDylib),
"TypeExec": reflect.ValueOf(macho.TypeExec),
"TypeObj": reflect.ValueOf(macho.TypeObj),
"X86_64_RELOC_BRANCH": reflect.ValueOf(macho.X86_64_RELOC_BRANCH),
"X86_64_RELOC_GOT": reflect.ValueOf(macho.X86_64_RELOC_GOT),
"X86_64_RELOC_GOT_LOAD": reflect.ValueOf(macho.X86_64_RELOC_GOT_LOAD),
"X86_64_RELOC_SIGNED": reflect.ValueOf(macho.X86_64_RELOC_SIGNED),
"X86_64_RELOC_SIGNED_1": reflect.ValueOf(macho.X86_64_RELOC_SIGNED_1),
"X86_64_RELOC_SIGNED_2": reflect.ValueOf(macho.X86_64_RELOC_SIGNED_2),
"X86_64_RELOC_SIGNED_4": reflect.ValueOf(macho.X86_64_RELOC_SIGNED_4),
"X86_64_RELOC_SUBTRACTOR": reflect.ValueOf(macho.X86_64_RELOC_SUBTRACTOR),
"X86_64_RELOC_TLV": reflect.ValueOf(macho.X86_64_RELOC_TLV),
"X86_64_RELOC_UNSIGNED": reflect.ValueOf(macho.X86_64_RELOC_UNSIGNED),
// type definitions
"Cpu": reflect.ValueOf((*macho.Cpu)(nil)),
"Dylib": reflect.ValueOf((*macho.Dylib)(nil)),
"DylibCmd": reflect.ValueOf((*macho.DylibCmd)(nil)),
"Dysymtab": reflect.ValueOf((*macho.Dysymtab)(nil)),
"DysymtabCmd": reflect.ValueOf((*macho.DysymtabCmd)(nil)),
"FatArch": reflect.ValueOf((*macho.FatArch)(nil)),
"FatArchHeader": reflect.ValueOf((*macho.FatArchHeader)(nil)),
"FatFile": reflect.ValueOf((*macho.FatFile)(nil)),
"File": reflect.ValueOf((*macho.File)(nil)),
"FileHeader": reflect.ValueOf((*macho.FileHeader)(nil)),
"FormatError": reflect.ValueOf((*macho.FormatError)(nil)),
"Load": reflect.ValueOf((*macho.Load)(nil)),
"LoadBytes": reflect.ValueOf((*macho.LoadBytes)(nil)),
"LoadCmd": reflect.ValueOf((*macho.LoadCmd)(nil)),
"Nlist32": reflect.ValueOf((*macho.Nlist32)(nil)),
"Nlist64": reflect.ValueOf((*macho.Nlist64)(nil)),
"Regs386": reflect.ValueOf((*macho.Regs386)(nil)),
"RegsAMD64": reflect.ValueOf((*macho.RegsAMD64)(nil)),
"Reloc": reflect.ValueOf((*macho.Reloc)(nil)),
"RelocTypeARM": reflect.ValueOf((*macho.RelocTypeARM)(nil)),
"RelocTypeARM64": reflect.ValueOf((*macho.RelocTypeARM64)(nil)),
"RelocTypeGeneric": reflect.ValueOf((*macho.RelocTypeGeneric)(nil)),
"RelocTypeX86_64": reflect.ValueOf((*macho.RelocTypeX86_64)(nil)),
"Rpath": reflect.ValueOf((*macho.Rpath)(nil)),
"RpathCmd": reflect.ValueOf((*macho.RpathCmd)(nil)),
"Section": reflect.ValueOf((*macho.Section)(nil)),
"Section32": reflect.ValueOf((*macho.Section32)(nil)),
"Section64": reflect.ValueOf((*macho.Section64)(nil)),
"SectionHeader": reflect.ValueOf((*macho.SectionHeader)(nil)),
"Segment": reflect.ValueOf((*macho.Segment)(nil)),
"Segment32": reflect.ValueOf((*macho.Segment32)(nil)),
"Segment64": reflect.ValueOf((*macho.Segment64)(nil)),
"SegmentHeader": reflect.ValueOf((*macho.SegmentHeader)(nil)),
"Symbol": reflect.ValueOf((*macho.Symbol)(nil)),
"Symtab": reflect.ValueOf((*macho.Symtab)(nil)),
"SymtabCmd": reflect.ValueOf((*macho.SymtabCmd)(nil)),
"Thread": reflect.ValueOf((*macho.Thread)(nil)),
"Type": reflect.ValueOf((*macho.Type)(nil)),
// interface wrapper definitions
"_Load": reflect.ValueOf((*_debug_macho_Load)(nil)),
}
}
// _debug_macho_Load is an interface wrapper for Load type
type _debug_macho_Load struct {
IValue interface{}
WRaw func() []byte
}
func (W _debug_macho_Load) Raw() []byte { return W.WRaw() }
================================================
FILE: stdlib/go1_21_debug_pe.go
================================================
// Code generated by 'yaegi extract debug/pe'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"debug/pe"
"go/constant"
"go/token"
"reflect"
)
func init() {
Symbols["debug/pe/pe"] = map[string]reflect.Value{
// function, constant and variable definitions
"COFFSymbolSize": reflect.ValueOf(constant.MakeFromLiteral("18", token.INT, 0)),
"IMAGE_COMDAT_SELECT_ANY": reflect.ValueOf(constant.MakeFromLiteral("2", token.INT, 0)),
"IMAGE_COMDAT_SELECT_ASSOCIATIVE": reflect.ValueOf(constant.MakeFromLiteral("5", token.INT, 0)),
"IMAGE_COMDAT_SELECT_EXACT_MATCH": reflect.ValueOf(constant.MakeFromLiteral("4", token.INT, 0)),
"IMAGE_COMDAT_SELECT_LARGEST": reflect.ValueOf(constant.MakeFromLiteral("6", token.INT, 0)),
"IMAGE_COMDAT_SELECT_NODUPLICATES": reflect.ValueOf(constant.MakeFromLiteral("1", token.INT, 0)),
"IMAGE_COMDAT_SELECT_SAME_SIZE": reflect.ValueOf(constant.MakeFromLiteral("3", token.INT, 0)),
"IMAGE_DIRECTORY_ENTRY_ARCHITECTURE": reflect.ValueOf(constant.MakeFromLiteral("7", token.INT, 0)),
"IMAGE_DIRECTORY_ENTRY_BASERELOC": reflect.ValueOf(constant.MakeFromLiteral("5", token.INT, 0)),
"IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT": reflect.ValueOf(constant.MakeFromLiteral("11", token.INT, 0)),
"IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR": reflect.ValueOf(constant.MakeFromLiteral("14", token.INT, 0)),
"IMAGE_DIRECTORY_ENTRY_DEBUG": reflect.ValueOf(constant.MakeFromLiteral("6", token.INT, 0)),
"IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT": reflect.ValueOf(constant.MakeFromLiteral("13", token.INT, 0)),
"IMAGE_DIRECTORY_ENTRY_EXCEPTION": reflect.ValueOf(constant.MakeFromLiteral("3", token.INT, 0)),
"IMAGE_DIRECTORY_ENTRY_EXPORT": reflect.ValueOf(constant.MakeFromLiteral("0", token.INT, 0)),
"IMAGE_DIRECTORY_ENTRY_GLOBALPTR": reflect.ValueOf(constant.MakeFromLiteral("8", token.INT, 0)),
"IMAGE_DIRECTORY_ENTRY_IAT": reflect.ValueOf(constant.MakeFromLiteral("12", token.INT, 0)),
"IMAGE_DIRECTORY_ENTRY_IMPORT": reflect.ValueOf(constant.MakeFromLiteral("1", token.INT, 0)),
"IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG": reflect.ValueOf(constant.MakeFromLiteral("10", token.INT, 0)),
"IMAGE_DIRECTORY_ENTRY_RESOURCE": reflect.ValueOf(constant.MakeFromLiteral("2", token.INT, 0)),
"IMAGE_DIRECTORY_ENTRY_SECURITY": reflect.ValueOf(constant.MakeFromLiteral("4", token.INT, 0)),
"IMAGE_DIRECTORY_ENTRY_TLS": reflect.ValueOf(constant.MakeFromLiteral("9", token.INT, 0)),
"IMAGE_DLLCHARACTERISTICS_APPCONTAINER": reflect.ValueOf(constant.MakeFromLiteral("4096", token.INT, 0)),
"IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE": reflect.ValueOf(constant.MakeFromLiteral("64", token.INT, 0)),
"IMAGE_DLLCHARACTERISTICS_FORCE_INTEGRITY": reflect.ValueOf(constant.MakeFromLiteral("128", token.INT, 0)),
"IMAGE_DLLCHARACTERISTICS_GUARD_CF": reflect.ValueOf(constant.MakeFromLiteral("16384", token.INT, 0)),
"IMAGE_DLLCHARACTERISTICS_HIGH_ENTROPY_VA": reflect.ValueOf(constant.MakeFromLiteral("32", token.INT, 0)),
"IMAGE_DLLCHARACTERISTICS_NO_BIND": reflect.ValueOf(constant.MakeFromLiteral("2048", token.INT, 0)),
"IMAGE_DLLCHARACTERISTICS_NO_ISOLATION": reflect.ValueOf(constant.MakeFromLiteral("512", token.INT, 0)),
"IMAGE_DLLCHARACTERISTICS_NO_SEH": reflect.ValueOf(constant.MakeFromLiteral("1024", token.INT, 0)),
"IMAGE_DLLCHARACTERISTICS_NX_COMPAT": reflect.ValueOf(constant.MakeFromLiteral("256", token.INT, 0)),
"IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE": reflect.ValueOf(constant.MakeFromLiteral("32768", token.INT, 0)),
"IMAGE_DLLCHARACTERISTICS_WDM_DRIVER": reflect.ValueOf(constant.MakeFromLiteral("8192", token.INT, 0)),
"IMAGE_FILE_32BIT_MACHINE": reflect.ValueOf(constant.MakeFromLiteral("256", token.INT, 0)),
"IMAGE_FILE_AGGRESIVE_WS_TRIM": reflect.ValueOf(constant.MakeFromLiteral("16", token.INT, 0)),
"IMAGE_FILE_BYTES_REVERSED_HI": reflect.ValueOf(constant.MakeFromLiteral("32768", token.INT, 0)),
"IMAGE_FILE_BYTES_REVERSED_LO": reflect.ValueOf(constant.MakeFromLiteral("128", token.INT, 0)),
"IMAGE_FILE_DEBUG_STRIPPED": reflect.ValueOf(constant.MakeFromLiteral("512", token.INT, 0)),
"IMAGE_FILE_DLL": reflect.ValueOf(constant.MakeFromLiteral("8192", token.INT, 0)),
"IMAGE_FILE_EXECUTABLE_IMAGE": reflect.ValueOf(constant.MakeFromLiteral("2", token.INT, 0)),
"IMAGE_FILE_LARGE_ADDRESS_AWARE": reflect.ValueOf(constant.MakeFromLiteral("32", token.INT, 0)),
"IMAGE_FILE_LINE_NUMS_STRIPPED": reflect.ValueOf(constant.MakeFromLiteral("4", token.INT, 0)),
"IMAGE_FILE_LOCAL_SYMS_STRIPPED": reflect.ValueOf(constant.MakeFromLiteral("8", token.INT, 0)),
"IMAGE_FILE_MACHINE_AM33": reflect.ValueOf(constant.MakeFromLiteral("467", token.INT, 0)),
"IMAGE_FILE_MACHINE_AMD64": reflect.ValueOf(constant.MakeFromLiteral("34404", token.INT, 0)),
"IMAGE_FILE_MACHINE_ARM": reflect.ValueOf(constant.MakeFromLiteral("448", token.INT, 0)),
"IMAGE_FILE_MACHINE_ARM64": reflect.ValueOf(constant.MakeFromLiteral("43620", token.INT, 0)),
"IMAGE_FILE_MACHINE_ARMNT": reflect.ValueOf(constant.MakeFromLiteral("452", token.INT, 0)),
"IMAGE_FILE_MACHINE_EBC": reflect.ValueOf(constant.MakeFromLiteral("3772", token.INT, 0)),
"IMAGE_FILE_MACHINE_I386": reflect.ValueOf(constant.MakeFromLiteral("332", token.INT, 0)),
"IMAGE_FILE_MACHINE_IA64": reflect.ValueOf(constant.MakeFromLiteral("512", token.INT, 0)),
"IMAGE_FILE_MACHINE_LOONGARCH32": reflect.ValueOf(constant.MakeFromLiteral("25138", token.INT, 0)),
"IMAGE_FILE_MACHINE_LOONGARCH64": reflect.ValueOf(constant.MakeFromLiteral("25188", token.INT, 0)),
"IMAGE_FILE_MACHINE_M32R": reflect.ValueOf(constant.MakeFromLiteral("36929", token.INT, 0)),
"IMAGE_FILE_MACHINE_MIPS16": reflect.ValueOf(constant.MakeFromLiteral("614", token.INT, 0)),
"IMAGE_FILE_MACHINE_MIPSFPU": reflect.ValueOf(constant.MakeFromLiteral("870", token.INT, 0)),
"IMAGE_FILE_MACHINE_MIPSFPU16": reflect.ValueOf(constant.MakeFromLiteral("1126", token.INT, 0)),
"IMAGE_FILE_MACHINE_POWERPC": reflect.ValueOf(constant.MakeFromLiteral("496", token.INT, 0)),
"IMAGE_FILE_MACHINE_POWERPCFP": reflect.ValueOf(constant.MakeFromLiteral("497", token.INT, 0)),
"IMAGE_FILE_MACHINE_R4000": reflect.ValueOf(constant.MakeFromLiteral("358", token.INT, 0)),
"IMAGE_FILE_MACHINE_RISCV128": reflect.ValueOf(constant.MakeFromLiteral("20776", token.INT, 0)),
"IMAGE_FILE_MACHINE_RISCV32": reflect.ValueOf(constant.MakeFromLiteral("20530", token.INT, 0)),
"IMAGE_FILE_MACHINE_RISCV64": reflect.ValueOf(constant.MakeFromLiteral("20580", token.INT, 0)),
"IMAGE_FILE_MACHINE_SH3": reflect.ValueOf(constant.MakeFromLiteral("418", token.INT, 0)),
"IMAGE_FILE_MACHINE_SH3DSP": reflect.ValueOf(constant.MakeFromLiteral("419", token.INT, 0)),
"IMAGE_FILE_MACHINE_SH4": reflect.ValueOf(constant.MakeFromLiteral("422", token.INT, 0)),
"IMAGE_FILE_MACHINE_SH5": reflect.ValueOf(constant.MakeFromLiteral("424", token.INT, 0)),
"IMAGE_FILE_MACHINE_THUMB": reflect.ValueOf(constant.MakeFromLiteral("450", token.INT, 0)),
"IMAGE_FILE_MACHINE_UNKNOWN": reflect.ValueOf(constant.MakeFromLiteral("0", token.INT, 0)),
"IMAGE_FILE_MACHINE_WCEMIPSV2": reflect.ValueOf(constant.MakeFromLiteral("361", token.INT, 0)),
"IMAGE_FILE_NET_RUN_FROM_SWAP": reflect.ValueOf(constant.MakeFromLiteral("2048", token.INT, 0)),
"IMAGE_FILE_RELOCS_STRIPPED": reflect.ValueOf(constant.MakeFromLiteral("1", token.INT, 0)),
"IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP": reflect.ValueOf(constant.MakeFromLiteral("1024", token.INT, 0)),
"IMAGE_FILE_SYSTEM": reflect.ValueOf(constant.MakeFromLiteral("4096", token.INT, 0)),
"IMAGE_FILE_UP_SYSTEM_ONLY": reflect.ValueOf(constant.MakeFromLiteral("16384", token.INT, 0)),
"IMAGE_SCN_CNT_CODE": reflect.ValueOf(constant.MakeFromLiteral("32", token.INT, 0)),
"IMAGE_SCN_CNT_INITIALIZED_DATA": reflect.ValueOf(constant.MakeFromLiteral("64", token.INT, 0)),
"IMAGE_SCN_CNT_UNINITIALIZED_DATA": reflect.ValueOf(constant.MakeFromLiteral("128", token.INT, 0)),
"IMAGE_SCN_LNK_COMDAT": reflect.ValueOf(constant.MakeFromLiteral("4096", token.INT, 0)),
"IMAGE_SCN_MEM_DISCARDABLE": reflect.ValueOf(constant.MakeFromLiteral("33554432", token.INT, 0)),
"IMAGE_SCN_MEM_EXECUTE": reflect.ValueOf(constant.MakeFromLiteral("536870912", token.INT, 0)),
"IMAGE_SCN_MEM_READ": reflect.ValueOf(constant.MakeFromLiteral("1073741824", token.INT, 0)),
"IMAGE_SCN_MEM_WRITE": reflect.ValueOf(constant.MakeFromLiteral("2147483648", token.INT, 0)),
"IMAGE_SUBSYSTEM_EFI_APPLICATION": reflect.ValueOf(constant.MakeFromLiteral("10", token.INT, 0)),
"IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER": reflect.ValueOf(constant.MakeFromLiteral("11", token.INT, 0)),
"IMAGE_SUBSYSTEM_EFI_ROM": reflect.ValueOf(constant.MakeFromLiteral("13", token.INT, 0)),
"IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER": reflect.ValueOf(constant.MakeFromLiteral("12", token.INT, 0)),
"IMAGE_SUBSYSTEM_NATIVE": reflect.ValueOf(constant.MakeFromLiteral("1", token.INT, 0)),
"IMAGE_SUBSYSTEM_NATIVE_WINDOWS": reflect.ValueOf(constant.MakeFromLiteral("8", token.INT, 0)),
"IMAGE_SUBSYSTEM_OS2_CUI": reflect.ValueOf(constant.MakeFromLiteral("5", token.INT, 0)),
"IMAGE_SUBSYSTEM_POSIX_CUI": reflect.ValueOf(constant.MakeFromLiteral("7", token.INT, 0)),
"IMAGE_SUBSYSTEM_UNKNOWN": reflect.ValueOf(constant.MakeFromLiteral("0", token.INT, 0)),
"IMAGE_SUBSYSTEM_WINDOWS_BOOT_APPLICATION": reflect.ValueOf(constant.MakeFromLiteral("16", token.INT, 0)),
"IMAGE_SUBSYSTEM_WINDOWS_CE_GUI": reflect.ValueOf(constant.MakeFromLiteral("9", token.INT, 0)),
"IMAGE_SUBSYSTEM_WINDOWS_CUI": reflect.ValueOf(constant.MakeFromLiteral("3", token.INT, 0)),
"IMAGE_SUBSYSTEM_WINDOWS_GUI": reflect.ValueOf(constant.MakeFromLiteral("2", token.INT, 0)),
"IMAGE_SUBSYSTEM_XBOX": reflect.ValueOf(constant.MakeFromLiteral("14", token.INT, 0)),
"NewFile": reflect.ValueOf(pe.NewFile),
"Open": reflect.ValueOf(pe.Open),
// type definitions
"COFFSymbol": reflect.ValueOf((*pe.COFFSymbol)(nil)),
"COFFSymbolAuxFormat5": reflect.ValueOf((*pe.COFFSymbolAuxFormat5)(nil)),
"DataDirectory": reflect.ValueOf((*pe.DataDirectory)(nil)),
"File": reflect.ValueOf((*pe.File)(nil)),
"FileHeader": reflect.ValueOf((*pe.FileHeader)(nil)),
"FormatError": reflect.ValueOf((*pe.FormatError)(nil)),
"ImportDirectory": reflect.ValueOf((*pe.ImportDirectory)(nil)),
"OptionalHeader32": reflect.ValueOf((*pe.OptionalHeader32)(nil)),
"OptionalHeader64": reflect.ValueOf((*pe.OptionalHeader64)(nil)),
"Reloc": reflect.ValueOf((*pe.Reloc)(nil)),
"Section": reflect.ValueOf((*pe.Section)(nil)),
"SectionHeader": reflect.ValueOf((*pe.SectionHeader)(nil)),
"SectionHeader32": reflect.ValueOf((*pe.SectionHeader32)(nil)),
"StringTable": reflect.ValueOf((*pe.StringTable)(nil)),
"Symbol": reflect.ValueOf((*pe.Symbol)(nil)),
}
}
================================================
FILE: stdlib/go1_21_debug_plan9obj.go
================================================
// Code generated by 'yaegi extract debug/plan9obj'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"debug/plan9obj"
"go/constant"
"go/token"
"reflect"
)
func init() {
Symbols["debug/plan9obj/plan9obj"] = map[string]reflect.Value{
// function, constant and variable definitions
"ErrNoSymbols": reflect.ValueOf(&plan9obj.ErrNoSymbols).Elem(),
"Magic386": reflect.ValueOf(constant.MakeFromLiteral("491", token.INT, 0)),
"Magic64": reflect.ValueOf(constant.MakeFromLiteral("32768", token.INT, 0)),
"MagicAMD64": reflect.ValueOf(constant.MakeFromLiteral("35479", token.INT, 0)),
"MagicARM": reflect.ValueOf(constant.MakeFromLiteral("1607", token.INT, 0)),
"NewFile": reflect.ValueOf(plan9obj.NewFile),
"Open": reflect.ValueOf(plan9obj.Open),
// type definitions
"File": reflect.ValueOf((*plan9obj.File)(nil)),
"FileHeader": reflect.ValueOf((*plan9obj.FileHeader)(nil)),
"Section": reflect.ValueOf((*plan9obj.Section)(nil)),
"SectionHeader": reflect.ValueOf((*plan9obj.SectionHeader)(nil)),
"Sym": reflect.ValueOf((*plan9obj.Sym)(nil)),
}
}
================================================
FILE: stdlib/go1_21_encoding.go
================================================
// Code generated by 'yaegi extract encoding'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"encoding"
"reflect"
)
func init() {
Symbols["encoding/encoding"] = map[string]reflect.Value{
// type definitions
"BinaryMarshaler": reflect.ValueOf((*encoding.BinaryMarshaler)(nil)),
"BinaryUnmarshaler": reflect.ValueOf((*encoding.BinaryUnmarshaler)(nil)),
"TextMarshaler": reflect.ValueOf((*encoding.TextMarshaler)(nil)),
"TextUnmarshaler": reflect.ValueOf((*encoding.TextUnmarshaler)(nil)),
// interface wrapper definitions
"_BinaryMarshaler": reflect.ValueOf((*_encoding_BinaryMarshaler)(nil)),
"_BinaryUnmarshaler": reflect.ValueOf((*_encoding_BinaryUnmarshaler)(nil)),
"_TextMarshaler": reflect.ValueOf((*_encoding_TextMarshaler)(nil)),
"_TextUnmarshaler": reflect.ValueOf((*_encoding_TextUnmarshaler)(nil)),
}
}
// _encoding_BinaryMarshaler is an interface wrapper for BinaryMarshaler type
type _encoding_BinaryMarshaler struct {
IValue interface{}
WMarshalBinary func() (data []byte, err error)
}
func (W _encoding_BinaryMarshaler) MarshalBinary() (data []byte, err error) {
return W.WMarshalBinary()
}
// _encoding_BinaryUnmarshaler is an interface wrapper for BinaryUnmarshaler type
type _encoding_BinaryUnmarshaler struct {
IValue interface{}
WUnmarshalBinary func(data []byte) error
}
func (W _encoding_BinaryUnmarshaler) UnmarshalBinary(data []byte) error {
return W.WUnmarshalBinary(data)
}
// _encoding_TextMarshaler is an interface wrapper for TextMarshaler type
type _encoding_TextMarshaler struct {
IValue interface{}
WMarshalText func() (text []byte, err error)
}
func (W _encoding_TextMarshaler) MarshalText() (text []byte, err error) { return W.WMarshalText() }
// _encoding_TextUnmarshaler is an interface wrapper for TextUnmarshaler type
type _encoding_TextUnmarshaler struct {
IValue interface{}
WUnmarshalText func(text []byte) error
}
func (W _encoding_TextUnmarshaler) UnmarshalText(text []byte) error { return W.WUnmarshalText(text) }
================================================
FILE: stdlib/go1_21_encoding_ascii85.go
================================================
// Code generated by 'yaegi extract encoding/ascii85'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"encoding/ascii85"
"reflect"
)
func init() {
Symbols["encoding/ascii85/ascii85"] = map[string]reflect.Value{
// function, constant and variable definitions
"Decode": reflect.ValueOf(ascii85.Decode),
"Encode": reflect.ValueOf(ascii85.Encode),
"MaxEncodedLen": reflect.ValueOf(ascii85.MaxEncodedLen),
"NewDecoder": reflect.ValueOf(ascii85.NewDecoder),
"NewEncoder": reflect.ValueOf(ascii85.NewEncoder),
// type definitions
"CorruptInputError": reflect.ValueOf((*ascii85.CorruptInputError)(nil)),
}
}
================================================
FILE: stdlib/go1_21_encoding_asn1.go
================================================
// Code generated by 'yaegi extract encoding/asn1'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"encoding/asn1"
"go/constant"
"go/token"
"reflect"
)
func init() {
Symbols["encoding/asn1/asn1"] = map[string]reflect.Value{
// function, constant and variable definitions
"ClassApplication": reflect.ValueOf(constant.MakeFromLiteral("1", token.INT, 0)),
"ClassContextSpecific": reflect.ValueOf(constant.MakeFromLiteral("2", token.INT, 0)),
"ClassPrivate": reflect.ValueOf(constant.MakeFromLiteral("3", token.INT, 0)),
"ClassUniversal": reflect.ValueOf(constant.MakeFromLiteral("0", token.INT, 0)),
"Marshal": reflect.ValueOf(asn1.Marshal),
"MarshalWithParams": reflect.ValueOf(asn1.MarshalWithParams),
"NullBytes": reflect.ValueOf(&asn1.NullBytes).Elem(),
"NullRawValue": reflect.ValueOf(&asn1.NullRawValue).Elem(),
"TagBMPString": reflect.ValueOf(constant.MakeFromLiteral("30", token.INT, 0)),
"TagBitString": reflect.ValueOf(constant.MakeFromLiteral("3", token.INT, 0)),
"TagBoolean": reflect.ValueOf(constant.MakeFromLiteral("1", token.INT, 0)),
"TagEnum": reflect.ValueOf(constant.MakeFromLiteral("10", token.INT, 0)),
"TagGeneralString": reflect.ValueOf(constant.MakeFromLiteral("27", token.INT, 0)),
"TagGeneralizedTime": reflect.ValueOf(constant.MakeFromLiteral("24", token.INT, 0)),
"TagIA5String": reflect.ValueOf(constant.MakeFromLiteral("22", token.INT, 0)),
"TagInteger": reflect.ValueOf(constant.MakeFromLiteral("2", token.INT, 0)),
"TagNull": reflect.ValueOf(constant.MakeFromLiteral("5", token.INT, 0)),
"TagNumericString": reflect.ValueOf(constant.MakeFromLiteral("18", token.INT, 0)),
"TagOID": reflect.ValueOf(constant.MakeFromLiteral("6", token.INT, 0)),
"TagOctetString": reflect.ValueOf(constant.MakeFromLiteral("4", token.INT, 0)),
"TagPrintableString": reflect.ValueOf(constant.MakeFromLiteral("19", token.INT, 0)),
"TagSequence": reflect.ValueOf(constant.MakeFromLiteral("16", token.INT, 0)),
"TagSet": reflect.ValueOf(constant.MakeFromLiteral("17", token.INT, 0)),
"TagT61String": reflect.ValueOf(constant.MakeFromLiteral("20", token.INT, 0)),
"TagUTCTime": reflect.ValueOf(constant.MakeFromLiteral("23", token.INT, 0)),
"TagUTF8String": reflect.ValueOf(constant.MakeFromLiteral("12", token.INT, 0)),
"Unmarshal": reflect.ValueOf(asn1.Unmarshal),
"UnmarshalWithParams": reflect.ValueOf(asn1.UnmarshalWithParams),
// type definitions
"BitString": reflect.ValueOf((*asn1.BitString)(nil)),
"Enumerated": reflect.ValueOf((*asn1.Enumerated)(nil)),
"Flag": reflect.ValueOf((*asn1.Flag)(nil)),
"ObjectIdentifier": reflect.ValueOf((*asn1.ObjectIdentifier)(nil)),
"RawContent": reflect.ValueOf((*asn1.RawContent)(nil)),
"RawValue": reflect.ValueOf((*asn1.RawValue)(nil)),
"StructuralError": reflect.ValueOf((*asn1.StructuralError)(nil)),
"SyntaxError": reflect.ValueOf((*asn1.SyntaxError)(nil)),
}
}
================================================
FILE: stdlib/go1_21_encoding_base32.go
================================================
// Code generated by 'yaegi extract encoding/base32'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"encoding/base32"
"reflect"
)
func init() {
Symbols["encoding/base32/base32"] = map[string]reflect.Value{
// function, constant and variable definitions
"HexEncoding": reflect.ValueOf(&base32.HexEncoding).Elem(),
"NewDecoder": reflect.ValueOf(base32.NewDecoder),
"NewEncoder": reflect.ValueOf(base32.NewEncoder),
"NewEncoding": reflect.ValueOf(base32.NewEncoding),
"NoPadding": reflect.ValueOf(base32.NoPadding),
"StdEncoding": reflect.ValueOf(&base32.StdEncoding).Elem(),
"StdPadding": reflect.ValueOf(base32.StdPadding),
// type definitions
"CorruptInputError": reflect.ValueOf((*base32.CorruptInputError)(nil)),
"Encoding": reflect.ValueOf((*base32.Encoding)(nil)),
}
}
================================================
FILE: stdlib/go1_21_encoding_base64.go
================================================
// Code generated by 'yaegi extract encoding/base64'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"encoding/base64"
"reflect"
)
func init() {
Symbols["encoding/base64/base64"] = map[string]reflect.Value{
// function, constant and variable definitions
"NewDecoder": reflect.ValueOf(base64.NewDecoder),
"NewEncoder": reflect.ValueOf(base64.NewEncoder),
"NewEncoding": reflect.ValueOf(base64.NewEncoding),
"NoPadding": reflect.ValueOf(base64.NoPadding),
"RawStdEncoding": reflect.ValueOf(&base64.RawStdEncoding).Elem(),
"RawURLEncoding": reflect.ValueOf(&base64.RawURLEncoding).Elem(),
"StdEncoding": reflect.ValueOf(&base64.StdEncoding).Elem(),
"StdPadding": reflect.ValueOf(base64.StdPadding),
"URLEncoding": reflect.ValueOf(&base64.URLEncoding).Elem(),
// type definitions
"CorruptInputError": reflect.ValueOf((*base64.CorruptInputError)(nil)),
"Encoding": reflect.ValueOf((*base64.Encoding)(nil)),
}
}
================================================
FILE: stdlib/go1_21_encoding_binary.go
================================================
// Code generated by 'yaegi extract encoding/binary'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"encoding/binary"
"go/constant"
"go/token"
"reflect"
)
func init() {
Symbols["encoding/binary/binary"] = map[string]reflect.Value{
// function, constant and variable definitions
"AppendUvarint": reflect.ValueOf(binary.AppendUvarint),
"AppendVarint": reflect.ValueOf(binary.AppendVarint),
"BigEndian": reflect.ValueOf(&binary.BigEndian).Elem(),
"LittleEndian": reflect.ValueOf(&binary.LittleEndian).Elem(),
"MaxVarintLen16": reflect.ValueOf(constant.MakeFromLiteral("3", token.INT, 0)),
"MaxVarintLen32": reflect.ValueOf(constant.MakeFromLiteral("5", token.INT, 0)),
"MaxVarintLen64": reflect.ValueOf(constant.MakeFromLiteral("10", token.INT, 0)),
"NativeEndian": reflect.ValueOf(&binary.NativeEndian).Elem(),
"PutUvarint": reflect.ValueOf(binary.PutUvarint),
"PutVarint": reflect.ValueOf(binary.PutVarint),
"Read": reflect.ValueOf(binary.Read),
"ReadUvarint": reflect.ValueOf(binary.ReadUvarint),
"ReadVarint": reflect.ValueOf(binary.ReadVarint),
"Size": reflect.ValueOf(binary.Size),
"Uvarint": reflect.ValueOf(binary.Uvarint),
"Varint": reflect.ValueOf(binary.Varint),
"Write": reflect.ValueOf(binary.Write),
// type definitions
"AppendByteOrder": reflect.ValueOf((*binary.AppendByteOrder)(nil)),
"ByteOrder": reflect.ValueOf((*binary.ByteOrder)(nil)),
// interface wrapper definitions
"_AppendByteOrder": reflect.ValueOf((*_encoding_binary_AppendByteOrder)(nil)),
"_ByteOrder": reflect.ValueOf((*_encoding_binary_ByteOrder)(nil)),
}
}
// _encoding_binary_AppendByteOrder is an interface wrapper for AppendByteOrder type
type _encoding_binary_AppendByteOrder struct {
IValue interface{}
WAppendUint16 func(a0 []byte, a1 uint16) []byte
WAppendUint32 func(a0 []byte, a1 uint32) []byte
WAppendUint64 func(a0 []byte, a1 uint64) []byte
WString func() string
}
func (W _encoding_binary_AppendByteOrder) AppendUint16(a0 []byte, a1 uint16) []byte {
return W.WAppendUint16(a0, a1)
}
func (W _encoding_binary_AppendByteOrder) AppendUint32(a0 []byte, a1 uint32) []byte {
return W.WAppendUint32(a0, a1)
}
func (W _encoding_binary_AppendByteOrder) AppendUint64(a0 []byte, a1 uint64) []byte {
return W.WAppendUint64(a0, a1)
}
func (W _encoding_binary_AppendByteOrder) String() string {
if W.WString == nil {
return ""
}
return W.WString()
}
// _encoding_binary_ByteOrder is an interface wrapper for ByteOrder type
type _encoding_binary_ByteOrder struct {
IValue interface{}
WPutUint16 func(a0 []byte, a1 uint16)
WPutUint32 func(a0 []byte, a1 uint32)
WPutUint64 func(a0 []byte, a1 uint64)
WString func() string
WUint16 func(a0 []byte) uint16
WUint32 func(a0 []byte) uint32
WUint64 func(a0 []byte) uint64
}
func (W _encoding_binary_ByteOrder) PutUint16(a0 []byte, a1 uint16) { W.WPutUint16(a0, a1) }
func (W _encoding_binary_ByteOrder) PutUint32(a0 []byte, a1 uint32) { W.WPutUint32(a0, a1) }
func (W _encoding_binary_ByteOrder) PutUint64(a0 []byte, a1 uint64) { W.WPutUint64(a0, a1) }
func (W _encoding_binary_ByteOrder) String() string {
if W.WString == nil {
return ""
}
return W.WString()
}
func (W _encoding_binary_ByteOrder) Uint16(a0 []byte) uint16 { return W.WUint16(a0) }
func (W _encoding_binary_ByteOrder) Uint32(a0 []byte) uint32 { return W.WUint32(a0) }
func (W _encoding_binary_ByteOrder) Uint64(a0 []byte) uint64 { return W.WUint64(a0) }
================================================
FILE: stdlib/go1_21_encoding_csv.go
================================================
// Code generated by 'yaegi extract encoding/csv'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"encoding/csv"
"reflect"
)
func init() {
Symbols["encoding/csv/csv"] = map[string]reflect.Value{
// function, constant and variable definitions
"ErrBareQuote": reflect.ValueOf(&csv.ErrBareQuote).Elem(),
"ErrFieldCount": reflect.ValueOf(&csv.ErrFieldCount).Elem(),
"ErrQuote": reflect.ValueOf(&csv.ErrQuote).Elem(),
"ErrTrailingComma": reflect.ValueOf(&csv.ErrTrailingComma).Elem(),
"NewReader": reflect.ValueOf(csv.NewReader),
"NewWriter": reflect.ValueOf(csv.NewWriter),
// type definitions
"ParseError": reflect.ValueOf((*csv.ParseError)(nil)),
"Reader": reflect.ValueOf((*csv.Reader)(nil)),
"Writer": reflect.ValueOf((*csv.Writer)(nil)),
}
}
================================================
FILE: stdlib/go1_21_encoding_gob.go
================================================
// Code generated by 'yaegi extract encoding/gob'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"encoding/gob"
"reflect"
)
func init() {
Symbols["encoding/gob/gob"] = map[string]reflect.Value{
// function, constant and variable definitions
"NewDecoder": reflect.ValueOf(gob.NewDecoder),
"NewEncoder": reflect.ValueOf(gob.NewEncoder),
"Register": reflect.ValueOf(gob.Register),
"RegisterName": reflect.ValueOf(gob.RegisterName),
// type definitions
"CommonType": reflect.ValueOf((*gob.CommonType)(nil)),
"Decoder": reflect.ValueOf((*gob.Decoder)(nil)),
"Encoder": reflect.ValueOf((*gob.Encoder)(nil)),
"GobDecoder": reflect.ValueOf((*gob.GobDecoder)(nil)),
"GobEncoder": reflect.ValueOf((*gob.GobEncoder)(nil)),
// interface wrapper definitions
"_GobDecoder": reflect.ValueOf((*_encoding_gob_GobDecoder)(nil)),
"_GobEncoder": reflect.ValueOf((*_encoding_gob_GobEncoder)(nil)),
}
}
// _encoding_gob_GobDecoder is an interface wrapper for GobDecoder type
type _encoding_gob_GobDecoder struct {
IValue interface{}
WGobDecode func(a0 []byte) error
}
func (W _encoding_gob_GobDecoder) GobDecode(a0 []byte) error { return W.WGobDecode(a0) }
// _encoding_gob_GobEncoder is an interface wrapper for GobEncoder type
type _encoding_gob_GobEncoder struct {
IValue interface{}
WGobEncode func() ([]byte, error)
}
func (W _encoding_gob_GobEncoder) GobEncode() ([]byte, error) { return W.WGobEncode() }
================================================
FILE: stdlib/go1_21_encoding_hex.go
================================================
// Code generated by 'yaegi extract encoding/hex'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"encoding/hex"
"reflect"
)
func init() {
Symbols["encoding/hex/hex"] = map[string]reflect.Value{
// function, constant and variable definitions
"Decode": reflect.ValueOf(hex.Decode),
"DecodeString": reflect.ValueOf(hex.DecodeString),
"DecodedLen": reflect.ValueOf(hex.DecodedLen),
"Dump": reflect.ValueOf(hex.Dump),
"Dumper": reflect.ValueOf(hex.Dumper),
"Encode": reflect.ValueOf(hex.Encode),
"EncodeToString": reflect.ValueOf(hex.EncodeToString),
"EncodedLen": reflect.ValueOf(hex.EncodedLen),
"ErrLength": reflect.ValueOf(&hex.ErrLength).Elem(),
"NewDecoder": reflect.ValueOf(hex.NewDecoder),
"NewEncoder": reflect.ValueOf(hex.NewEncoder),
// type definitions
"InvalidByteError": reflect.ValueOf((*hex.InvalidByteError)(nil)),
}
}
================================================
FILE: stdlib/go1_21_encoding_json.go
================================================
// Code generated by 'yaegi extract encoding/json'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"encoding/json"
"reflect"
)
func init() {
Symbols["encoding/json/json"] = map[string]reflect.Value{
// function, constant and variable definitions
"Compact": reflect.ValueOf(json.Compact),
"HTMLEscape": reflect.ValueOf(json.HTMLEscape),
"Indent": reflect.ValueOf(json.Indent),
"Marshal": reflect.ValueOf(json.Marshal),
"MarshalIndent": reflect.ValueOf(json.MarshalIndent),
"NewDecoder": reflect.ValueOf(json.NewDecoder),
"NewEncoder": reflect.ValueOf(json.NewEncoder),
"Unmarshal": reflect.ValueOf(json.Unmarshal),
"Valid": reflect.ValueOf(json.Valid),
// type definitions
"Decoder": reflect.ValueOf((*json.Decoder)(nil)),
"Delim": reflect.ValueOf((*json.Delim)(nil)),
"Encoder": reflect.ValueOf((*json.Encoder)(nil)),
"InvalidUTF8Error": reflect.ValueOf((*json.InvalidUTF8Error)(nil)),
"InvalidUnmarshalError": reflect.ValueOf((*json.InvalidUnmarshalError)(nil)),
"Marshaler": reflect.ValueOf((*json.Marshaler)(nil)),
"MarshalerError": reflect.ValueOf((*json.MarshalerError)(nil)),
"Number": reflect.ValueOf((*json.Number)(nil)),
"RawMessage": reflect.ValueOf((*json.RawMessage)(nil)),
"SyntaxError": reflect.ValueOf((*json.SyntaxError)(nil)),
"Token": reflect.ValueOf((*json.Token)(nil)),
"UnmarshalFieldError": reflect.ValueOf((*json.UnmarshalFieldError)(nil)),
"UnmarshalTypeError": reflect.ValueOf((*json.UnmarshalTypeError)(nil)),
"Unmarshaler": reflect.ValueOf((*json.Unmarshaler)(nil)),
"UnsupportedTypeError": reflect.ValueOf((*json.UnsupportedTypeError)(nil)),
"UnsupportedValueError": reflect.ValueOf((*json.UnsupportedValueError)(nil)),
// interface wrapper definitions
"_Marshaler": reflect.ValueOf((*_encoding_json_Marshaler)(nil)),
"_Token": reflect.ValueOf((*_encoding_json_Token)(nil)),
"_Unmarshaler": reflect.ValueOf((*_encoding_json_Unmarshaler)(nil)),
}
}
// _encoding_json_Marshaler is an interface wrapper for Marshaler type
type _encoding_json_Marshaler struct {
IValue interface{}
WMarshalJSON func() ([]byte, error)
}
func (W _encoding_json_Marshaler) MarshalJSON() ([]byte, error) { return W.WMarshalJSON() }
// _encoding_json_Token is an interface wrapper for Token type
type _encoding_json_Token struct {
IValue interface{}
}
// _encoding_json_Unmarshaler is an interface wrapper for Unmarshaler type
type _encoding_json_Unmarshaler struct {
IValue interface{}
WUnmarshalJSON func(a0 []byte) error
}
func (W _encoding_json_Unmarshaler) UnmarshalJSON(a0 []byte) error { return W.WUnmarshalJSON(a0) }
================================================
FILE: stdlib/go1_21_encoding_pem.go
================================================
// Code generated by 'yaegi extract encoding/pem'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"encoding/pem"
"reflect"
)
func init() {
Symbols["encoding/pem/pem"] = map[string]reflect.Value{
// function, constant and variable definitions
"Decode": reflect.ValueOf(pem.Decode),
"Encode": reflect.ValueOf(pem.Encode),
"EncodeToMemory": reflect.ValueOf(pem.EncodeToMemory),
// type definitions
"Block": reflect.ValueOf((*pem.Block)(nil)),
}
}
================================================
FILE: stdlib/go1_21_encoding_xml.go
================================================
// Code generated by 'yaegi extract encoding/xml'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"encoding/xml"
"go/constant"
"go/token"
"reflect"
)
func init() {
Symbols["encoding/xml/xml"] = map[string]reflect.Value{
// function, constant and variable definitions
"CopyToken": reflect.ValueOf(xml.CopyToken),
"Escape": reflect.ValueOf(xml.Escape),
"EscapeText": reflect.ValueOf(xml.EscapeText),
"HTMLAutoClose": reflect.ValueOf(&xml.HTMLAutoClose).Elem(),
"HTMLEntity": reflect.ValueOf(&xml.HTMLEntity).Elem(),
"Header": reflect.ValueOf(constant.MakeFromLiteral("\"\\n\"", token.STRING, 0)),
"Marshal": reflect.ValueOf(xml.Marshal),
"MarshalIndent": reflect.ValueOf(xml.MarshalIndent),
"NewDecoder": reflect.ValueOf(xml.NewDecoder),
"NewEncoder": reflect.ValueOf(xml.NewEncoder),
"NewTokenDecoder": reflect.ValueOf(xml.NewTokenDecoder),
"Unmarshal": reflect.ValueOf(xml.Unmarshal),
// type definitions
"Attr": reflect.ValueOf((*xml.Attr)(nil)),
"CharData": reflect.ValueOf((*xml.CharData)(nil)),
"Comment": reflect.ValueOf((*xml.Comment)(nil)),
"Decoder": reflect.ValueOf((*xml.Decoder)(nil)),
"Directive": reflect.ValueOf((*xml.Directive)(nil)),
"Encoder": reflect.ValueOf((*xml.Encoder)(nil)),
"EndElement": reflect.ValueOf((*xml.EndElement)(nil)),
"Marshaler": reflect.ValueOf((*xml.Marshaler)(nil)),
"MarshalerAttr": reflect.ValueOf((*xml.MarshalerAttr)(nil)),
"Name": reflect.ValueOf((*xml.Name)(nil)),
"ProcInst": reflect.ValueOf((*xml.ProcInst)(nil)),
"StartElement": reflect.ValueOf((*xml.StartElement)(nil)),
"SyntaxError": reflect.ValueOf((*xml.SyntaxError)(nil)),
"TagPathError": reflect.ValueOf((*xml.TagPathError)(nil)),
"Token": reflect.ValueOf((*xml.Token)(nil)),
"TokenReader": reflect.ValueOf((*xml.TokenReader)(nil)),
"UnmarshalError": reflect.ValueOf((*xml.UnmarshalError)(nil)),
"Unmarshaler": reflect.ValueOf((*xml.Unmarshaler)(nil)),
"UnmarshalerAttr": reflect.ValueOf((*xml.UnmarshalerAttr)(nil)),
"UnsupportedTypeError": reflect.ValueOf((*xml.UnsupportedTypeError)(nil)),
// interface wrapper definitions
"_Marshaler": reflect.ValueOf((*_encoding_xml_Marshaler)(nil)),
"_MarshalerAttr": reflect.ValueOf((*_encoding_xml_MarshalerAttr)(nil)),
"_Token": reflect.ValueOf((*_encoding_xml_Token)(nil)),
"_TokenReader": reflect.ValueOf((*_encoding_xml_TokenReader)(nil)),
"_Unmarshaler": reflect.ValueOf((*_encoding_xml_Unmarshaler)(nil)),
"_UnmarshalerAttr": reflect.ValueOf((*_encoding_xml_UnmarshalerAttr)(nil)),
}
}
// _encoding_xml_Marshaler is an interface wrapper for Marshaler type
type _encoding_xml_Marshaler struct {
IValue interface{}
WMarshalXML func(e *xml.Encoder, start xml.StartElement) error
}
func (W _encoding_xml_Marshaler) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
return W.WMarshalXML(e, start)
}
// _encoding_xml_MarshalerAttr is an interface wrapper for MarshalerAttr type
type _encoding_xml_MarshalerAttr struct {
IValue interface{}
WMarshalXMLAttr func(name xml.Name) (xml.Attr, error)
}
func (W _encoding_xml_MarshalerAttr) MarshalXMLAttr(name xml.Name) (xml.Attr, error) {
return W.WMarshalXMLAttr(name)
}
// _encoding_xml_Token is an interface wrapper for Token type
type _encoding_xml_Token struct {
IValue interface{}
}
// _encoding_xml_TokenReader is an interface wrapper for TokenReader type
type _encoding_xml_TokenReader struct {
IValue interface{}
WToken func() (xml.Token, error)
}
func (W _encoding_xml_TokenReader) Token() (xml.Token, error) { return W.WToken() }
// _encoding_xml_Unmarshaler is an interface wrapper for Unmarshaler type
type _encoding_xml_Unmarshaler struct {
IValue interface{}
WUnmarshalXML func(d *xml.Decoder, start xml.StartElement) error
}
func (W _encoding_xml_Unmarshaler) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
return W.WUnmarshalXML(d, start)
}
// _encoding_xml_UnmarshalerAttr is an interface wrapper for UnmarshalerAttr type
type _encoding_xml_UnmarshalerAttr struct {
IValue interface{}
WUnmarshalXMLAttr func(attr xml.Attr) error
}
func (W _encoding_xml_UnmarshalerAttr) UnmarshalXMLAttr(attr xml.Attr) error {
return W.WUnmarshalXMLAttr(attr)
}
================================================
FILE: stdlib/go1_21_errors.go
================================================
// Code generated by 'yaegi extract errors'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"errors"
"reflect"
)
func init() {
Symbols["errors/errors"] = map[string]reflect.Value{
// function, constant and variable definitions
"As": reflect.ValueOf(errors.As),
"ErrUnsupported": reflect.ValueOf(&errors.ErrUnsupported).Elem(),
"Is": reflect.ValueOf(errors.Is),
"Join": reflect.ValueOf(errors.Join),
"New": reflect.ValueOf(errors.New),
"Unwrap": reflect.ValueOf(errors.Unwrap),
}
}
================================================
FILE: stdlib/go1_21_expvar.go
================================================
// Code generated by 'yaegi extract expvar'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"expvar"
"reflect"
)
func init() {
Symbols["expvar/expvar"] = map[string]reflect.Value{
// function, constant and variable definitions
"Do": reflect.ValueOf(expvar.Do),
"Get": reflect.ValueOf(expvar.Get),
"Handler": reflect.ValueOf(expvar.Handler),
"NewFloat": reflect.ValueOf(expvar.NewFloat),
"NewInt": reflect.ValueOf(expvar.NewInt),
"NewMap": reflect.ValueOf(expvar.NewMap),
"NewString": reflect.ValueOf(expvar.NewString),
"Publish": reflect.ValueOf(expvar.Publish),
// type definitions
"Float": reflect.ValueOf((*expvar.Float)(nil)),
"Func": reflect.ValueOf((*expvar.Func)(nil)),
"Int": reflect.ValueOf((*expvar.Int)(nil)),
"KeyValue": reflect.ValueOf((*expvar.KeyValue)(nil)),
"Map": reflect.ValueOf((*expvar.Map)(nil)),
"String": reflect.ValueOf((*expvar.String)(nil)),
"Var": reflect.ValueOf((*expvar.Var)(nil)),
// interface wrapper definitions
"_Var": reflect.ValueOf((*_expvar_Var)(nil)),
}
}
// _expvar_Var is an interface wrapper for Var type
type _expvar_Var struct {
IValue interface{}
WString func() string
}
func (W _expvar_Var) String() string {
if W.WString == nil {
return ""
}
return W.WString()
}
================================================
FILE: stdlib/go1_21_flag.go
================================================
// Code generated by 'yaegi extract flag'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"flag"
"reflect"
)
func init() {
Symbols["flag/flag"] = map[string]reflect.Value{
// function, constant and variable definitions
"Arg": reflect.ValueOf(flag.Arg),
"Args": reflect.ValueOf(flag.Args),
"Bool": reflect.ValueOf(flag.Bool),
"BoolFunc": reflect.ValueOf(flag.BoolFunc),
"BoolVar": reflect.ValueOf(flag.BoolVar),
"CommandLine": reflect.ValueOf(&flag.CommandLine).Elem(),
"ContinueOnError": reflect.ValueOf(flag.ContinueOnError),
"Duration": reflect.ValueOf(flag.Duration),
"DurationVar": reflect.ValueOf(flag.DurationVar),
"ErrHelp": reflect.ValueOf(&flag.ErrHelp).Elem(),
"ExitOnError": reflect.ValueOf(flag.ExitOnError),
"Float64": reflect.ValueOf(flag.Float64),
"Float64Var": reflect.ValueOf(flag.Float64Var),
"Func": reflect.ValueOf(flag.Func),
"Int": reflect.ValueOf(flag.Int),
"Int64": reflect.ValueOf(flag.Int64),
"Int64Var": reflect.ValueOf(flag.Int64Var),
"IntVar": reflect.ValueOf(flag.IntVar),
"Lookup": reflect.ValueOf(flag.Lookup),
"NArg": reflect.ValueOf(flag.NArg),
"NFlag": reflect.ValueOf(flag.NFlag),
"NewFlagSet": reflect.ValueOf(flag.NewFlagSet),
"PanicOnError": reflect.ValueOf(flag.PanicOnError),
"Parse": reflect.ValueOf(flag.Parse),
"Parsed": reflect.ValueOf(flag.Parsed),
"PrintDefaults": reflect.ValueOf(flag.PrintDefaults),
"Set": reflect.ValueOf(flag.Set),
"String": reflect.ValueOf(flag.String),
"StringVar": reflect.ValueOf(flag.StringVar),
"TextVar": reflect.ValueOf(flag.TextVar),
"Uint": reflect.ValueOf(flag.Uint),
"Uint64": reflect.ValueOf(flag.Uint64),
"Uint64Var": reflect.ValueOf(flag.Uint64Var),
"UintVar": reflect.ValueOf(flag.UintVar),
"UnquoteUsage": reflect.ValueOf(flag.UnquoteUsage),
"Usage": reflect.ValueOf(&flag.Usage).Elem(),
"Var": reflect.ValueOf(flag.Var),
"Visit": reflect.ValueOf(flag.Visit),
"VisitAll": reflect.ValueOf(flag.VisitAll),
// type definitions
"ErrorHandling": reflect.ValueOf((*flag.ErrorHandling)(nil)),
"Flag": reflect.ValueOf((*flag.Flag)(nil)),
"FlagSet": reflect.ValueOf((*flag.FlagSet)(nil)),
"Getter": reflect.ValueOf((*flag.Getter)(nil)),
"Value": reflect.ValueOf((*flag.Value)(nil)),
// interface wrapper definitions
"_Getter": reflect.ValueOf((*_flag_Getter)(nil)),
"_Value": reflect.ValueOf((*_flag_Value)(nil)),
}
}
// _flag_Getter is an interface wrapper for Getter type
type _flag_Getter struct {
IValue interface{}
WGet func() any
WSet func(a0 string) error
WString func() string
}
func (W _flag_Getter) Get() any { return W.WGet() }
func (W _flag_Getter) Set(a0 string) error { return W.WSet(a0) }
func (W _flag_Getter) String() string {
if W.WString == nil {
return ""
}
return W.WString()
}
// _flag_Value is an interface wrapper for Value type
type _flag_Value struct {
IValue interface{}
WSet func(a0 string) error
WString func() string
}
func (W _flag_Value) Set(a0 string) error { return W.WSet(a0) }
func (W _flag_Value) String() string {
if W.WString == nil {
return ""
}
return W.WString()
}
================================================
FILE: stdlib/go1_21_fmt.go
================================================
// Code generated by 'yaegi extract fmt'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"fmt"
"reflect"
)
func init() {
Symbols["fmt/fmt"] = map[string]reflect.Value{
// function, constant and variable definitions
"Append": reflect.ValueOf(fmt.Append),
"Appendf": reflect.ValueOf(fmt.Appendf),
"Appendln": reflect.ValueOf(fmt.Appendln),
"Errorf": reflect.ValueOf(fmt.Errorf),
"FormatString": reflect.ValueOf(fmt.FormatString),
"Fprint": reflect.ValueOf(fmt.Fprint),
"Fprintf": reflect.ValueOf(fmt.Fprintf),
"Fprintln": reflect.ValueOf(fmt.Fprintln),
"Fscan": reflect.ValueOf(fmt.Fscan),
"Fscanf": reflect.ValueOf(fmt.Fscanf),
"Fscanln": reflect.ValueOf(fmt.Fscanln),
"Print": reflect.ValueOf(fmt.Print),
"Printf": reflect.ValueOf(fmt.Printf),
"Println": reflect.ValueOf(fmt.Println),
"Scan": reflect.ValueOf(fmt.Scan),
"Scanf": reflect.ValueOf(fmt.Scanf),
"Scanln": reflect.ValueOf(fmt.Scanln),
"Sprint": reflect.ValueOf(fmt.Sprint),
"Sprintf": reflect.ValueOf(fmt.Sprintf),
"Sprintln": reflect.ValueOf(fmt.Sprintln),
"Sscan": reflect.ValueOf(fmt.Sscan),
"Sscanf": reflect.ValueOf(fmt.Sscanf),
"Sscanln": reflect.ValueOf(fmt.Sscanln),
// type definitions
"Formatter": reflect.ValueOf((*fmt.Formatter)(nil)),
"GoStringer": reflect.ValueOf((*fmt.GoStringer)(nil)),
"ScanState": reflect.ValueOf((*fmt.ScanState)(nil)),
"Scanner": reflect.ValueOf((*fmt.Scanner)(nil)),
"State": reflect.ValueOf((*fmt.State)(nil)),
"Stringer": reflect.ValueOf((*fmt.Stringer)(nil)),
// interface wrapper definitions
"_Formatter": reflect.ValueOf((*_fmt_Formatter)(nil)),
"_GoStringer": reflect.ValueOf((*_fmt_GoStringer)(nil)),
"_ScanState": reflect.ValueOf((*_fmt_ScanState)(nil)),
"_Scanner": reflect.ValueOf((*_fmt_Scanner)(nil)),
"_State": reflect.ValueOf((*_fmt_State)(nil)),
"_Stringer": reflect.ValueOf((*_fmt_Stringer)(nil)),
}
}
// _fmt_Formatter is an interface wrapper for Formatter type
type _fmt_Formatter struct {
IValue interface{}
WFormat func(f fmt.State, verb rune)
}
func (W _fmt_Formatter) Format(f fmt.State, verb rune) { W.WFormat(f, verb) }
// _fmt_GoStringer is an interface wrapper for GoStringer type
type _fmt_GoStringer struct {
IValue interface{}
WGoString func() string
}
func (W _fmt_GoStringer) GoString() string { return W.WGoString() }
// _fmt_ScanState is an interface wrapper for ScanState type
type _fmt_ScanState struct {
IValue interface{}
WRead func(buf []byte) (n int, err error)
WReadRune func() (r rune, size int, err error)
WSkipSpace func()
WToken func(skipSpace bool, f func(rune) bool) (token []byte, err error)
WUnreadRune func() error
WWidth func() (wid int, ok bool)
}
func (W _fmt_ScanState) Read(buf []byte) (n int, err error) { return W.WRead(buf) }
func (W _fmt_ScanState) ReadRune() (r rune, size int, err error) { return W.WReadRune() }
func (W _fmt_ScanState) SkipSpace() { W.WSkipSpace() }
func (W _fmt_ScanState) Token(skipSpace bool, f func(rune) bool) (token []byte, err error) {
return W.WToken(skipSpace, f)
}
func (W _fmt_ScanState) UnreadRune() error { return W.WUnreadRune() }
func (W _fmt_ScanState) Width() (wid int, ok bool) { return W.WWidth() }
// _fmt_Scanner is an interface wrapper for Scanner type
type _fmt_Scanner struct {
IValue interface{}
WScan func(state fmt.ScanState, verb rune) error
}
func (W _fmt_Scanner) Scan(state fmt.ScanState, verb rune) error { return W.WScan(state, verb) }
// _fmt_State is an interface wrapper for State type
type _fmt_State struct {
IValue interface{}
WFlag func(c int) bool
WPrecision func() (prec int, ok bool)
WWidth func() (wid int, ok bool)
WWrite func(b []byte) (n int, err error)
}
func (W _fmt_State) Flag(c int) bool { return W.WFlag(c) }
func (W _fmt_State) Precision() (prec int, ok bool) { return W.WPrecision() }
func (W _fmt_State) Width() (wid int, ok bool) { return W.WWidth() }
func (W _fmt_State) Write(b []byte) (n int, err error) { return W.WWrite(b) }
// _fmt_Stringer is an interface wrapper for Stringer type
type _fmt_Stringer struct {
IValue interface{}
WString func() string
}
func (W _fmt_Stringer) String() string {
if W.WString == nil {
return ""
}
return W.WString()
}
================================================
FILE: stdlib/go1_21_go_ast.go
================================================
// Code generated by 'yaegi extract go/ast'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"go/ast"
"go/token"
"reflect"
)
func init() {
Symbols["go/ast/ast"] = map[string]reflect.Value{
// function, constant and variable definitions
"Bad": reflect.ValueOf(ast.Bad),
"Con": reflect.ValueOf(ast.Con),
"FileExports": reflect.ValueOf(ast.FileExports),
"FilterDecl": reflect.ValueOf(ast.FilterDecl),
"FilterFile": reflect.ValueOf(ast.FilterFile),
"FilterFuncDuplicates": reflect.ValueOf(ast.FilterFuncDuplicates),
"FilterImportDuplicates": reflect.ValueOf(ast.FilterImportDuplicates),
"FilterPackage": reflect.ValueOf(ast.FilterPackage),
"FilterUnassociatedComments": reflect.ValueOf(ast.FilterUnassociatedComments),
"Fprint": reflect.ValueOf(ast.Fprint),
"Fun": reflect.ValueOf(ast.Fun),
"Inspect": reflect.ValueOf(ast.Inspect),
"IsExported": reflect.ValueOf(ast.IsExported),
"IsGenerated": reflect.ValueOf(ast.IsGenerated),
"Lbl": reflect.ValueOf(ast.Lbl),
"MergePackageFiles": reflect.ValueOf(ast.MergePackageFiles),
"NewCommentMap": reflect.ValueOf(ast.NewCommentMap),
"NewIdent": reflect.ValueOf(ast.NewIdent),
"NewObj": reflect.ValueOf(ast.NewObj),
"NewPackage": reflect.ValueOf(ast.NewPackage),
"NewScope": reflect.ValueOf(ast.NewScope),
"NotNilFilter": reflect.ValueOf(ast.NotNilFilter),
"PackageExports": reflect.ValueOf(ast.PackageExports),
"Pkg": reflect.ValueOf(ast.Pkg),
"Print": reflect.ValueOf(ast.Print),
"RECV": reflect.ValueOf(ast.RECV),
"SEND": reflect.ValueOf(ast.SEND),
"SortImports": reflect.ValueOf(ast.SortImports),
"Typ": reflect.ValueOf(ast.Typ),
"Var": reflect.ValueOf(ast.Var),
"Walk": reflect.ValueOf(ast.Walk),
// type definitions
"ArrayType": reflect.ValueOf((*ast.ArrayType)(nil)),
"AssignStmt": reflect.ValueOf((*ast.AssignStmt)(nil)),
"BadDecl": reflect.ValueOf((*ast.BadDecl)(nil)),
"BadExpr": reflect.ValueOf((*ast.BadExpr)(nil)),
"BadStmt": reflect.ValueOf((*ast.BadStmt)(nil)),
"BasicLit": reflect.ValueOf((*ast.BasicLit)(nil)),
"BinaryExpr": reflect.ValueOf((*ast.BinaryExpr)(nil)),
"BlockStmt": reflect.ValueOf((*ast.BlockStmt)(nil)),
"BranchStmt": reflect.ValueOf((*ast.BranchStmt)(nil)),
"CallExpr": reflect.ValueOf((*ast.CallExpr)(nil)),
"CaseClause": reflect.ValueOf((*ast.CaseClause)(nil)),
"ChanDir": reflect.ValueOf((*ast.ChanDir)(nil)),
"ChanType": reflect.ValueOf((*ast.ChanType)(nil)),
"CommClause": reflect.ValueOf((*ast.CommClause)(nil)),
"Comment": reflect.ValueOf((*ast.Comment)(nil)),
"CommentGroup": reflect.ValueOf((*ast.CommentGroup)(nil)),
"CommentMap": reflect.ValueOf((*ast.CommentMap)(nil)),
"CompositeLit": reflect.ValueOf((*ast.CompositeLit)(nil)),
"Decl": reflect.ValueOf((*ast.Decl)(nil)),
"DeclStmt": reflect.ValueOf((*ast.DeclStmt)(nil)),
"DeferStmt": reflect.ValueOf((*ast.DeferStmt)(nil)),
"Ellipsis": reflect.ValueOf((*ast.Ellipsis)(nil)),
"EmptyStmt": reflect.ValueOf((*ast.EmptyStmt)(nil)),
"Expr": reflect.ValueOf((*ast.Expr)(nil)),
"ExprStmt": reflect.ValueOf((*ast.ExprStmt)(nil)),
"Field": reflect.ValueOf((*ast.Field)(nil)),
"FieldFilter": reflect.ValueOf((*ast.FieldFilter)(nil)),
"FieldList": reflect.ValueOf((*ast.FieldList)(nil)),
"File": reflect.ValueOf((*ast.File)(nil)),
"Filter": reflect.ValueOf((*ast.Filter)(nil)),
"ForStmt": reflect.ValueOf((*ast.ForStmt)(nil)),
"FuncDecl": reflect.ValueOf((*ast.FuncDecl)(nil)),
"FuncLit": reflect.ValueOf((*ast.FuncLit)(nil)),
"FuncType": reflect.ValueOf((*ast.FuncType)(nil)),
"GenDecl": reflect.ValueOf((*ast.GenDecl)(nil)),
"GoStmt": reflect.ValueOf((*ast.GoStmt)(nil)),
"Ident": reflect.ValueOf((*ast.Ident)(nil)),
"IfStmt": reflect.ValueOf((*ast.IfStmt)(nil)),
"ImportSpec": reflect.ValueOf((*ast.ImportSpec)(nil)),
"Importer": reflect.ValueOf((*ast.Importer)(nil)),
"IncDecStmt": reflect.ValueOf((*ast.IncDecStmt)(nil)),
"IndexExpr": reflect.ValueOf((*ast.IndexExpr)(nil)),
"IndexListExpr": reflect.ValueOf((*ast.IndexListExpr)(nil)),
"InterfaceType": reflect.ValueOf((*ast.InterfaceType)(nil)),
"KeyValueExpr": reflect.ValueOf((*ast.KeyValueExpr)(nil)),
"LabeledStmt": reflect.ValueOf((*ast.LabeledStmt)(nil)),
"MapType": reflect.ValueOf((*ast.MapType)(nil)),
"MergeMode": reflect.ValueOf((*ast.MergeMode)(nil)),
"Node": reflect.ValueOf((*ast.Node)(nil)),
"ObjKind": reflect.ValueOf((*ast.ObjKind)(nil)),
"Object": reflect.ValueOf((*ast.Object)(nil)),
"Package": reflect.ValueOf((*ast.Package)(nil)),
"ParenExpr": reflect.ValueOf((*ast.ParenExpr)(nil)),
"RangeStmt": reflect.ValueOf((*ast.RangeStmt)(nil)),
"ReturnStmt": reflect.ValueOf((*ast.ReturnStmt)(nil)),
"Scope": reflect.ValueOf((*ast.Scope)(nil)),
"SelectStmt": reflect.ValueOf((*ast.SelectStmt)(nil)),
"SelectorExpr": reflect.ValueOf((*ast.SelectorExpr)(nil)),
"SendStmt": reflect.ValueOf((*ast.SendStmt)(nil)),
"SliceExpr": reflect.ValueOf((*ast.SliceExpr)(nil)),
"Spec": reflect.ValueOf((*ast.Spec)(nil)),
"StarExpr": reflect.ValueOf((*ast.StarExpr)(nil)),
"Stmt": reflect.ValueOf((*ast.Stmt)(nil)),
"StructType": reflect.ValueOf((*ast.StructType)(nil)),
"SwitchStmt": reflect.ValueOf((*ast.SwitchStmt)(nil)),
"TypeAssertExpr": reflect.ValueOf((*ast.TypeAssertExpr)(nil)),
"TypeSpec": reflect.ValueOf((*ast.TypeSpec)(nil)),
"TypeSwitchStmt": reflect.ValueOf((*ast.TypeSwitchStmt)(nil)),
"UnaryExpr": reflect.ValueOf((*ast.UnaryExpr)(nil)),
"ValueSpec": reflect.ValueOf((*ast.ValueSpec)(nil)),
"Visitor": reflect.ValueOf((*ast.Visitor)(nil)),
// interface wrapper definitions
"_Decl": reflect.ValueOf((*_go_ast_Decl)(nil)),
"_Expr": reflect.ValueOf((*_go_ast_Expr)(nil)),
"_Node": reflect.ValueOf((*_go_ast_Node)(nil)),
"_Spec": reflect.ValueOf((*_go_ast_Spec)(nil)),
"_Stmt": reflect.ValueOf((*_go_ast_Stmt)(nil)),
"_Visitor": reflect.ValueOf((*_go_ast_Visitor)(nil)),
}
}
// _go_ast_Decl is an interface wrapper for Decl type
type _go_ast_Decl struct {
IValue interface{}
WEnd func() token.Pos
WPos func() token.Pos
}
func (W _go_ast_Decl) End() token.Pos { return W.WEnd() }
func (W _go_ast_Decl) Pos() token.Pos { return W.WPos() }
// _go_ast_Expr is an interface wrapper for Expr type
type _go_ast_Expr struct {
IValue interface{}
WEnd func() token.Pos
WPos func() token.Pos
}
func (W _go_ast_Expr) End() token.Pos { return W.WEnd() }
func (W _go_ast_Expr) Pos() token.Pos { return W.WPos() }
// _go_ast_Node is an interface wrapper for Node type
type _go_ast_Node struct {
IValue interface{}
WEnd func() token.Pos
WPos func() token.Pos
}
func (W _go_ast_Node) End() token.Pos { return W.WEnd() }
func (W _go_ast_Node) Pos() token.Pos { return W.WPos() }
// _go_ast_Spec is an interface wrapper for Spec type
type _go_ast_Spec struct {
IValue interface{}
WEnd func() token.Pos
WPos func() token.Pos
}
func (W _go_ast_Spec) End() token.Pos { return W.WEnd() }
func (W _go_ast_Spec) Pos() token.Pos { return W.WPos() }
// _go_ast_Stmt is an interface wrapper for Stmt type
type _go_ast_Stmt struct {
IValue interface{}
WEnd func() token.Pos
WPos func() token.Pos
}
func (W _go_ast_Stmt) End() token.Pos { return W.WEnd() }
func (W _go_ast_Stmt) Pos() token.Pos { return W.WPos() }
// _go_ast_Visitor is an interface wrapper for Visitor type
type _go_ast_Visitor struct {
IValue interface{}
WVisit func(node ast.Node) (w ast.Visitor)
}
func (W _go_ast_Visitor) Visit(node ast.Node) (w ast.Visitor) { return W.WVisit(node) }
================================================
FILE: stdlib/go1_21_go_build.go
================================================
// Code generated by 'yaegi extract go/build'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"go/build"
"reflect"
)
func init() {
Symbols["go/build/build"] = map[string]reflect.Value{
// function, constant and variable definitions
"AllowBinary": reflect.ValueOf(build.AllowBinary),
"ArchChar": reflect.ValueOf(build.ArchChar),
"Default": reflect.ValueOf(&build.Default).Elem(),
"FindOnly": reflect.ValueOf(build.FindOnly),
"IgnoreVendor": reflect.ValueOf(build.IgnoreVendor),
"Import": reflect.ValueOf(build.Import),
"ImportComment": reflect.ValueOf(build.ImportComment),
"ImportDir": reflect.ValueOf(build.ImportDir),
"IsLocalImport": reflect.ValueOf(build.IsLocalImport),
"ToolDir": reflect.ValueOf(&build.ToolDir).Elem(),
// type definitions
"Context": reflect.ValueOf((*build.Context)(nil)),
"Directive": reflect.ValueOf((*build.Directive)(nil)),
"ImportMode": reflect.ValueOf((*build.ImportMode)(nil)),
"MultiplePackageError": reflect.ValueOf((*build.MultiplePackageError)(nil)),
"NoGoError": reflect.ValueOf((*build.NoGoError)(nil)),
"Package": reflect.ValueOf((*build.Package)(nil)),
}
}
================================================
FILE: stdlib/go1_21_go_build_constraint.go
================================================
// Code generated by 'yaegi extract go/build/constraint'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"go/build/constraint"
"reflect"
)
func init() {
Symbols["go/build/constraint/constraint"] = map[string]reflect.Value{
// function, constant and variable definitions
"GoVersion": reflect.ValueOf(constraint.GoVersion),
"IsGoBuild": reflect.ValueOf(constraint.IsGoBuild),
"IsPlusBuild": reflect.ValueOf(constraint.IsPlusBuild),
"Parse": reflect.ValueOf(constraint.Parse),
"PlusBuildLines": reflect.ValueOf(constraint.PlusBuildLines),
// type definitions
"AndExpr": reflect.ValueOf((*constraint.AndExpr)(nil)),
"Expr": reflect.ValueOf((*constraint.Expr)(nil)),
"NotExpr": reflect.ValueOf((*constraint.NotExpr)(nil)),
"OrExpr": reflect.ValueOf((*constraint.OrExpr)(nil)),
"SyntaxError": reflect.ValueOf((*constraint.SyntaxError)(nil)),
"TagExpr": reflect.ValueOf((*constraint.TagExpr)(nil)),
// interface wrapper definitions
"_Expr": reflect.ValueOf((*_go_build_constraint_Expr)(nil)),
}
}
// _go_build_constraint_Expr is an interface wrapper for Expr type
type _go_build_constraint_Expr struct {
IValue interface{}
WEval func(ok func(tag string) bool) bool
WString func() string
}
func (W _go_build_constraint_Expr) Eval(ok func(tag string) bool) bool { return W.WEval(ok) }
func (W _go_build_constraint_Expr) String() string {
if W.WString == nil {
return ""
}
return W.WString()
}
================================================
FILE: stdlib/go1_21_go_constant.go
================================================
// Code generated by 'yaegi extract go/constant'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"go/constant"
"reflect"
)
func init() {
Symbols["go/constant/constant"] = map[string]reflect.Value{
// function, constant and variable definitions
"BinaryOp": reflect.ValueOf(constant.BinaryOp),
"BitLen": reflect.ValueOf(constant.BitLen),
"Bool": reflect.ValueOf(constant.Bool),
"BoolVal": reflect.ValueOf(constant.BoolVal),
"Bytes": reflect.ValueOf(constant.Bytes),
"Compare": reflect.ValueOf(constant.Compare),
"Complex": reflect.ValueOf(constant.Complex),
"Denom": reflect.ValueOf(constant.Denom),
"Float": reflect.ValueOf(constant.Float),
"Float32Val": reflect.ValueOf(constant.Float32Val),
"Float64Val": reflect.ValueOf(constant.Float64Val),
"Imag": reflect.ValueOf(constant.Imag),
"Int": reflect.ValueOf(constant.Int),
"Int64Val": reflect.ValueOf(constant.Int64Val),
"Make": reflect.ValueOf(constant.Make),
"MakeBool": reflect.ValueOf(constant.MakeBool),
"MakeFloat64": reflect.ValueOf(constant.MakeFloat64),
"MakeFromBytes": reflect.ValueOf(constant.MakeFromBytes),
"MakeFromLiteral": reflect.ValueOf(constant.MakeFromLiteral),
"MakeImag": reflect.ValueOf(constant.MakeImag),
"MakeInt64": reflect.ValueOf(constant.MakeInt64),
"MakeString": reflect.ValueOf(constant.MakeString),
"MakeUint64": reflect.ValueOf(constant.MakeUint64),
"MakeUnknown": reflect.ValueOf(constant.MakeUnknown),
"Num": reflect.ValueOf(constant.Num),
"Real": reflect.ValueOf(constant.Real),
"Shift": reflect.ValueOf(constant.Shift),
"Sign": reflect.ValueOf(constant.Sign),
"String": reflect.ValueOf(constant.String),
"StringVal": reflect.ValueOf(constant.StringVal),
"ToComplex": reflect.ValueOf(constant.ToComplex),
"ToFloat": reflect.ValueOf(constant.ToFloat),
"ToInt": reflect.ValueOf(constant.ToInt),
"Uint64Val": reflect.ValueOf(constant.Uint64Val),
"UnaryOp": reflect.ValueOf(constant.UnaryOp),
"Unknown": reflect.ValueOf(constant.Unknown),
"Val": reflect.ValueOf(constant.Val),
// type definitions
"Kind": reflect.ValueOf((*constant.Kind)(nil)),
"Value": reflect.ValueOf((*constant.Value)(nil)),
// interface wrapper definitions
"_Value": reflect.ValueOf((*_go_constant_Value)(nil)),
}
}
// _go_constant_Value is an interface wrapper for Value type
type _go_constant_Value struct {
IValue interface{}
WExactString func() string
WKind func() constant.Kind
WString func() string
}
func (W _go_constant_Value) ExactString() string { return W.WExactString() }
func (W _go_constant_Value) Kind() constant.Kind { return W.WKind() }
func (W _go_constant_Value) String() string {
if W.WString == nil {
return ""
}
return W.WString()
}
================================================
FILE: stdlib/go1_21_go_doc.go
================================================
// Code generated by 'yaegi extract go/doc'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"go/doc"
"reflect"
)
func init() {
Symbols["go/doc/doc"] = map[string]reflect.Value{
// function, constant and variable definitions
"AllDecls": reflect.ValueOf(doc.AllDecls),
"AllMethods": reflect.ValueOf(doc.AllMethods),
"Examples": reflect.ValueOf(doc.Examples),
"IllegalPrefixes": reflect.ValueOf(&doc.IllegalPrefixes).Elem(),
"IsPredeclared": reflect.ValueOf(doc.IsPredeclared),
"New": reflect.ValueOf(doc.New),
"NewFromFiles": reflect.ValueOf(doc.NewFromFiles),
"PreserveAST": reflect.ValueOf(doc.PreserveAST),
"Synopsis": reflect.ValueOf(doc.Synopsis),
"ToHTML": reflect.ValueOf(doc.ToHTML),
"ToText": reflect.ValueOf(doc.ToText),
// type definitions
"Example": reflect.ValueOf((*doc.Example)(nil)),
"Filter": reflect.ValueOf((*doc.Filter)(nil)),
"Func": reflect.ValueOf((*doc.Func)(nil)),
"Mode": reflect.ValueOf((*doc.Mode)(nil)),
"Note": reflect.ValueOf((*doc.Note)(nil)),
"Package": reflect.ValueOf((*doc.Package)(nil)),
"Type": reflect.ValueOf((*doc.Type)(nil)),
"Value": reflect.ValueOf((*doc.Value)(nil)),
}
}
================================================
FILE: stdlib/go1_21_go_doc_comment.go
================================================
// Code generated by 'yaegi extract go/doc/comment'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"go/doc/comment"
"reflect"
)
func init() {
Symbols["go/doc/comment/comment"] = map[string]reflect.Value{
// function, constant and variable definitions
"DefaultLookupPackage": reflect.ValueOf(comment.DefaultLookupPackage),
// type definitions
"Block": reflect.ValueOf((*comment.Block)(nil)),
"Code": reflect.ValueOf((*comment.Code)(nil)),
"Doc": reflect.ValueOf((*comment.Doc)(nil)),
"DocLink": reflect.ValueOf((*comment.DocLink)(nil)),
"Heading": reflect.ValueOf((*comment.Heading)(nil)),
"Italic": reflect.ValueOf((*comment.Italic)(nil)),
"Link": reflect.ValueOf((*comment.Link)(nil)),
"LinkDef": reflect.ValueOf((*comment.LinkDef)(nil)),
"List": reflect.ValueOf((*comment.List)(nil)),
"ListItem": reflect.ValueOf((*comment.ListItem)(nil)),
"Paragraph": reflect.ValueOf((*comment.Paragraph)(nil)),
"Parser": reflect.ValueOf((*comment.Parser)(nil)),
"Plain": reflect.ValueOf((*comment.Plain)(nil)),
"Printer": reflect.ValueOf((*comment.Printer)(nil)),
"Text": reflect.ValueOf((*comment.Text)(nil)),
// interface wrapper definitions
"_Block": reflect.ValueOf((*_go_doc_comment_Block)(nil)),
"_Text": reflect.ValueOf((*_go_doc_comment_Text)(nil)),
}
}
// _go_doc_comment_Block is an interface wrapper for Block type
type _go_doc_comment_Block struct {
IValue interface{}
}
// _go_doc_comment_Text is an interface wrapper for Text type
type _go_doc_comment_Text struct {
IValue interface{}
}
================================================
FILE: stdlib/go1_21_go_format.go
================================================
// Code generated by 'yaegi extract go/format'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"go/format"
"reflect"
)
func init() {
Symbols["go/format/format"] = map[string]reflect.Value{
// function, constant and variable definitions
"Node": reflect.ValueOf(format.Node),
"Source": reflect.ValueOf(format.Source),
}
}
================================================
FILE: stdlib/go1_21_go_importer.go
================================================
// Code generated by 'yaegi extract go/importer'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"go/importer"
"reflect"
)
func init() {
Symbols["go/importer/importer"] = map[string]reflect.Value{
// function, constant and variable definitions
"Default": reflect.ValueOf(importer.Default),
"For": reflect.ValueOf(importer.For),
"ForCompiler": reflect.ValueOf(importer.ForCompiler),
// type definitions
"Lookup": reflect.ValueOf((*importer.Lookup)(nil)),
}
}
================================================
FILE: stdlib/go1_21_go_parser.go
================================================
// Code generated by 'yaegi extract go/parser'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"go/parser"
"reflect"
)
func init() {
Symbols["go/parser/parser"] = map[string]reflect.Value{
// function, constant and variable definitions
"AllErrors": reflect.ValueOf(parser.AllErrors),
"DeclarationErrors": reflect.ValueOf(parser.DeclarationErrors),
"ImportsOnly": reflect.ValueOf(parser.ImportsOnly),
"PackageClauseOnly": reflect.ValueOf(parser.PackageClauseOnly),
"ParseComments": reflect.ValueOf(parser.ParseComments),
"ParseDir": reflect.ValueOf(parser.ParseDir),
"ParseExpr": reflect.ValueOf(parser.ParseExpr),
"ParseExprFrom": reflect.ValueOf(parser.ParseExprFrom),
"ParseFile": reflect.ValueOf(parser.ParseFile),
"SkipObjectResolution": reflect.ValueOf(parser.SkipObjectResolution),
"SpuriousErrors": reflect.ValueOf(parser.SpuriousErrors),
"Trace": reflect.ValueOf(parser.Trace),
// type definitions
"Mode": reflect.ValueOf((*parser.Mode)(nil)),
}
}
================================================
FILE: stdlib/go1_21_go_printer.go
================================================
// Code generated by 'yaegi extract go/printer'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"go/printer"
"reflect"
)
func init() {
Symbols["go/printer/printer"] = map[string]reflect.Value{
// function, constant and variable definitions
"Fprint": reflect.ValueOf(printer.Fprint),
"RawFormat": reflect.ValueOf(printer.RawFormat),
"SourcePos": reflect.ValueOf(printer.SourcePos),
"TabIndent": reflect.ValueOf(printer.TabIndent),
"UseSpaces": reflect.ValueOf(printer.UseSpaces),
// type definitions
"CommentedNode": reflect.ValueOf((*printer.CommentedNode)(nil)),
"Config": reflect.ValueOf((*printer.Config)(nil)),
"Mode": reflect.ValueOf((*printer.Mode)(nil)),
}
}
================================================
FILE: stdlib/go1_21_go_scanner.go
================================================
// Code generated by 'yaegi extract go/scanner'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"go/scanner"
"reflect"
)
func init() {
Symbols["go/scanner/scanner"] = map[string]reflect.Value{
// function, constant and variable definitions
"PrintError": reflect.ValueOf(scanner.PrintError),
"ScanComments": reflect.ValueOf(scanner.ScanComments),
// type definitions
"Error": reflect.ValueOf((*scanner.Error)(nil)),
"ErrorHandler": reflect.ValueOf((*scanner.ErrorHandler)(nil)),
"ErrorList": reflect.ValueOf((*scanner.ErrorList)(nil)),
"Mode": reflect.ValueOf((*scanner.Mode)(nil)),
"Scanner": reflect.ValueOf((*scanner.Scanner)(nil)),
}
}
================================================
FILE: stdlib/go1_21_go_token.go
================================================
// Code generated by 'yaegi extract go/token'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"go/constant"
"go/token"
"reflect"
)
func init() {
Symbols["go/token/token"] = map[string]reflect.Value{
// function, constant and variable definitions
"ADD": reflect.ValueOf(token.ADD),
"ADD_ASSIGN": reflect.ValueOf(token.ADD_ASSIGN),
"AND": reflect.ValueOf(token.AND),
"AND_ASSIGN": reflect.ValueOf(token.AND_ASSIGN),
"AND_NOT": reflect.ValueOf(token.AND_NOT),
"AND_NOT_ASSIGN": reflect.ValueOf(token.AND_NOT_ASSIGN),
"ARROW": reflect.ValueOf(token.ARROW),
"ASSIGN": reflect.ValueOf(token.ASSIGN),
"BREAK": reflect.ValueOf(token.BREAK),
"CASE": reflect.ValueOf(token.CASE),
"CHAN": reflect.ValueOf(token.CHAN),
"CHAR": reflect.ValueOf(token.CHAR),
"COLON": reflect.ValueOf(token.COLON),
"COMMA": reflect.ValueOf(token.COMMA),
"COMMENT": reflect.ValueOf(token.COMMENT),
"CONST": reflect.ValueOf(token.CONST),
"CONTINUE": reflect.ValueOf(token.CONTINUE),
"DEC": reflect.ValueOf(token.DEC),
"DEFAULT": reflect.ValueOf(token.DEFAULT),
"DEFER": reflect.ValueOf(token.DEFER),
"DEFINE": reflect.ValueOf(token.DEFINE),
"ELLIPSIS": reflect.ValueOf(token.ELLIPSIS),
"ELSE": reflect.ValueOf(token.ELSE),
"EOF": reflect.ValueOf(token.EOF),
"EQL": reflect.ValueOf(token.EQL),
"FALLTHROUGH": reflect.ValueOf(token.FALLTHROUGH),
"FLOAT": reflect.ValueOf(token.FLOAT),
"FOR": reflect.ValueOf(token.FOR),
"FUNC": reflect.ValueOf(token.FUNC),
"GEQ": reflect.ValueOf(token.GEQ),
"GO": reflect.ValueOf(token.GO),
"GOTO": reflect.ValueOf(token.GOTO),
"GTR": reflect.ValueOf(token.GTR),
"HighestPrec": reflect.ValueOf(constant.MakeFromLiteral("7", token.INT, 0)),
"IDENT": reflect.ValueOf(token.IDENT),
"IF": reflect.ValueOf(token.IF),
"ILLEGAL": reflect.ValueOf(token.ILLEGAL),
"IMAG": reflect.ValueOf(token.IMAG),
"IMPORT": reflect.ValueOf(token.IMPORT),
"INC": reflect.ValueOf(token.INC),
"INT": reflect.ValueOf(token.INT),
"INTERFACE": reflect.ValueOf(token.INTERFACE),
"IsExported": reflect.ValueOf(token.IsExported),
"IsIdentifier": reflect.ValueOf(token.IsIdentifier),
"IsKeyword": reflect.ValueOf(token.IsKeyword),
"LAND": reflect.ValueOf(token.LAND),
"LBRACE": reflect.ValueOf(token.LBRACE),
"LBRACK": reflect.ValueOf(token.LBRACK),
"LEQ": reflect.ValueOf(token.LEQ),
"LOR": reflect.ValueOf(token.LOR),
"LPAREN": reflect.ValueOf(token.LPAREN),
"LSS": reflect.ValueOf(token.LSS),
"Lookup": reflect.ValueOf(token.Lookup),
"LowestPrec": reflect.ValueOf(constant.MakeFromLiteral("0", token.INT, 0)),
"MAP": reflect.ValueOf(token.MAP),
"MUL": reflect.ValueOf(token.MUL),
"MUL_ASSIGN": reflect.ValueOf(token.MUL_ASSIGN),
"NEQ": reflect.ValueOf(token.NEQ),
"NOT": reflect.ValueOf(token.NOT),
"NewFileSet": reflect.ValueOf(token.NewFileSet),
"NoPos": reflect.ValueOf(token.NoPos),
"OR": reflect.ValueOf(token.OR),
"OR_ASSIGN": reflect.ValueOf(token.OR_ASSIGN),
"PACKAGE": reflect.ValueOf(token.PACKAGE),
"PERIOD": reflect.ValueOf(token.PERIOD),
"QUO": reflect.ValueOf(token.QUO),
"QUO_ASSIGN": reflect.ValueOf(token.QUO_ASSIGN),
"RANGE": reflect.ValueOf(token.RANGE),
"RBRACE": reflect.ValueOf(token.RBRACE),
"RBRACK": reflect.ValueOf(token.RBRACK),
"REM": reflect.ValueOf(token.REM),
"REM_ASSIGN": reflect.ValueOf(token.REM_ASSIGN),
"RETURN": reflect.ValueOf(token.RETURN),
"RPAREN": reflect.ValueOf(token.RPAREN),
"SELECT": reflect.ValueOf(token.SELECT),
"SEMICOLON": reflect.ValueOf(token.SEMICOLON),
"SHL": reflect.ValueOf(token.SHL),
"SHL_ASSIGN": reflect.ValueOf(token.SHL_ASSIGN),
"SHR": reflect.ValueOf(token.SHR),
"SHR_ASSIGN": reflect.ValueOf(token.SHR_ASSIGN),
"STRING": reflect.ValueOf(token.STRING),
"STRUCT": reflect.ValueOf(token.STRUCT),
"SUB": reflect.ValueOf(token.SUB),
"SUB_ASSIGN": reflect.ValueOf(token.SUB_ASSIGN),
"SWITCH": reflect.ValueOf(token.SWITCH),
"TILDE": reflect.ValueOf(token.TILDE),
"TYPE": reflect.ValueOf(token.TYPE),
"UnaryPrec": reflect.ValueOf(constant.MakeFromLiteral("6", token.INT, 0)),
"VAR": reflect.ValueOf(token.VAR),
"XOR": reflect.ValueOf(token.XOR),
"XOR_ASSIGN": reflect.ValueOf(token.XOR_ASSIGN),
// type definitions
"File": reflect.ValueOf((*token.File)(nil)),
"FileSet": reflect.ValueOf((*token.FileSet)(nil)),
"Pos": reflect.ValueOf((*token.Pos)(nil)),
"Position": reflect.ValueOf((*token.Position)(nil)),
"Token": reflect.ValueOf((*token.Token)(nil)),
}
}
================================================
FILE: stdlib/go1_21_go_types.go
================================================
// Code generated by 'yaegi extract go/types'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"go/token"
"go/types"
"reflect"
)
func init() {
Symbols["go/types/types"] = map[string]reflect.Value{
// function, constant and variable definitions
"AssertableTo": reflect.ValueOf(types.AssertableTo),
"AssignableTo": reflect.ValueOf(types.AssignableTo),
"Bool": reflect.ValueOf(types.Bool),
"Byte": reflect.ValueOf(types.Byte),
"CheckExpr": reflect.ValueOf(types.CheckExpr),
"Comparable": reflect.ValueOf(types.Comparable),
"Complex128": reflect.ValueOf(types.Complex128),
"Complex64": reflect.ValueOf(types.Complex64),
"ConvertibleTo": reflect.ValueOf(types.ConvertibleTo),
"DefPredeclaredTestFuncs": reflect.ValueOf(types.DefPredeclaredTestFuncs),
"Default": reflect.ValueOf(types.Default),
"Eval": reflect.ValueOf(types.Eval),
"ExprString": reflect.ValueOf(types.ExprString),
"FieldVal": reflect.ValueOf(types.FieldVal),
"Float32": reflect.ValueOf(types.Float32),
"Float64": reflect.ValueOf(types.Float64),
"Id": reflect.ValueOf(types.Id),
"Identical": reflect.ValueOf(types.Identical),
"IdenticalIgnoreTags": reflect.ValueOf(types.IdenticalIgnoreTags),
"Implements": reflect.ValueOf(types.Implements),
"Instantiate": reflect.ValueOf(types.Instantiate),
"Int": reflect.ValueOf(types.Int),
"Int16": reflect.ValueOf(types.Int16),
"Int32": reflect.ValueOf(types.Int32),
"Int64": reflect.ValueOf(types.Int64),
"Int8": reflect.ValueOf(types.Int8),
"Invalid": reflect.ValueOf(types.Invalid),
"IsBoolean": reflect.ValueOf(types.IsBoolean),
"IsComplex": reflect.ValueOf(types.IsComplex),
"IsConstType": reflect.ValueOf(types.IsConstType),
"IsFloat": reflect.ValueOf(types.IsFloat),
"IsInteger": reflect.ValueOf(types.IsInteger),
"IsInterface": reflect.ValueOf(types.IsInterface),
"IsNumeric": reflect.ValueOf(types.IsNumeric),
"IsOrdered": reflect.ValueOf(types.IsOrdered),
"IsString": reflect.ValueOf(types.IsString),
"IsUnsigned": reflect.ValueOf(types.IsUnsigned),
"IsUntyped": reflect.ValueOf(types.IsUntyped),
"LookupFieldOrMethod": reflect.ValueOf(types.LookupFieldOrMethod),
"MethodExpr": reflect.ValueOf(types.MethodExpr),
"MethodVal": reflect.ValueOf(types.MethodVal),
"MissingMethod": reflect.ValueOf(types.MissingMethod),
"NewArray": reflect.ValueOf(types.NewArray),
"NewChan": reflect.ValueOf(types.NewChan),
"NewChecker": reflect.ValueOf(types.NewChecker),
"NewConst": reflect.ValueOf(types.NewConst),
"NewContext": reflect.ValueOf(types.NewContext),
"NewField": reflect.ValueOf(types.NewField),
"NewFunc": reflect.ValueOf(types.NewFunc),
"NewInterface": reflect.ValueOf(types.NewInterface),
"NewInterfaceType": reflect.ValueOf(types.NewInterfaceType),
"NewLabel": reflect.ValueOf(types.NewLabel),
"NewMap": reflect.ValueOf(types.NewMap),
"NewMethodSet": reflect.ValueOf(types.NewMethodSet),
"NewNamed": reflect.ValueOf(types.NewNamed),
"NewPackage": reflect.ValueOf(types.NewPackage),
"NewParam": reflect.ValueOf(types.NewParam),
"NewPkgName": reflect.ValueOf(types.NewPkgName),
"NewPointer": reflect.ValueOf(types.NewPointer),
"NewScope": reflect.ValueOf(types.NewScope),
"NewSignature": reflect.ValueOf(types.NewSignature),
"NewSignatureType": reflect.ValueOf(types.NewSignatureType),
"NewSlice": reflect.ValueOf(types.NewSlice),
"NewStruct": reflect.ValueOf(types.NewStruct),
"NewTerm": reflect.ValueOf(types.NewTerm),
"NewTuple": reflect.ValueOf(types.NewTuple),
"NewTypeName": reflect.ValueOf(types.NewTypeName),
"NewTypeParam": reflect.ValueOf(types.NewTypeParam),
"NewUnion": reflect.ValueOf(types.NewUnion),
"NewVar": reflect.ValueOf(types.NewVar),
"ObjectString": reflect.ValueOf(types.ObjectString),
"RecvOnly": reflect.ValueOf(types.RecvOnly),
"RelativeTo": reflect.ValueOf(types.RelativeTo),
"Rune": reflect.ValueOf(types.Rune),
"Satisfies": reflect.ValueOf(types.Satisfies),
"SelectionString": reflect.ValueOf(types.SelectionString),
"SendOnly": reflect.ValueOf(types.SendOnly),
"SendRecv": reflect.ValueOf(types.SendRecv),
"SizesFor": reflect.ValueOf(types.SizesFor),
"String": reflect.ValueOf(types.String),
"Typ": reflect.ValueOf(&types.Typ).Elem(),
"TypeString": reflect.ValueOf(types.TypeString),
"Uint": reflect.ValueOf(types.Uint),
"Uint16": reflect.ValueOf(types.Uint16),
"Uint32": reflect.ValueOf(types.Uint32),
"Uint64": reflect.ValueOf(types.Uint64),
"Uint8": reflect.ValueOf(types.Uint8),
"Uintptr": reflect.ValueOf(types.Uintptr),
"Universe": reflect.ValueOf(&types.Universe).Elem(),
"Unsafe": reflect.ValueOf(&types.Unsafe).Elem(),
"UnsafePointer": reflect.ValueOf(types.UnsafePointer),
"UntypedBool": reflect.ValueOf(types.UntypedBool),
"UntypedComplex": reflect.ValueOf(types.UntypedComplex),
"UntypedFloat": reflect.ValueOf(types.UntypedFloat),
"UntypedInt": reflect.ValueOf(types.UntypedInt),
"UntypedNil": reflect.ValueOf(types.UntypedNil),
"UntypedRune": reflect.ValueOf(types.UntypedRune),
"UntypedString": reflect.ValueOf(types.UntypedString),
"WriteExpr": reflect.ValueOf(types.WriteExpr),
"WriteSignature": reflect.ValueOf(types.WriteSignature),
"WriteType": reflect.ValueOf(types.WriteType),
// type definitions
"ArgumentError": reflect.ValueOf((*types.ArgumentError)(nil)),
"Array": reflect.ValueOf((*types.Array)(nil)),
"Basic": reflect.ValueOf((*types.Basic)(nil)),
"BasicInfo": reflect.ValueOf((*types.BasicInfo)(nil)),
"BasicKind": reflect.ValueOf((*types.BasicKind)(nil)),
"Builtin": reflect.ValueOf((*types.Builtin)(nil)),
"Chan": reflect.ValueOf((*types.Chan)(nil)),
"ChanDir": reflect.ValueOf((*types.ChanDir)(nil)),
"Checker": reflect.ValueOf((*types.Checker)(nil)),
"Config": reflect.ValueOf((*types.Config)(nil)),
"Const": reflect.ValueOf((*types.Const)(nil)),
"Context": reflect.ValueOf((*types.Context)(nil)),
"Error": reflect.ValueOf((*types.Error)(nil)),
"Func": reflect.ValueOf((*types.Func)(nil)),
"ImportMode": reflect.ValueOf((*types.ImportMode)(nil)),
"Importer": reflect.ValueOf((*types.Importer)(nil)),
"ImporterFrom": reflect.ValueOf((*types.ImporterFrom)(nil)),
"Info": reflect.ValueOf((*types.Info)(nil)),
"Initializer": reflect.ValueOf((*types.Initializer)(nil)),
"Instance": reflect.ValueOf((*types.Instance)(nil)),
"Interface": reflect.ValueOf((*types.Interface)(nil)),
"Label": reflect.ValueOf((*types.Label)(nil)),
"Map": reflect.ValueOf((*types.Map)(nil)),
"MethodSet": reflect.ValueOf((*types.MethodSet)(nil)),
"Named": reflect.ValueOf((*types.Named)(nil)),
"Nil": reflect.ValueOf((*types.Nil)(nil)),
"Object": reflect.ValueOf((*types.Object)(nil)),
"Package": reflect.ValueOf((*types.Package)(nil)),
"PkgName": reflect.ValueOf((*types.PkgName)(nil)),
"Pointer": reflect.ValueOf((*types.Pointer)(nil)),
"Qualifier": reflect.ValueOf((*types.Qualifier)(nil)),
"Scope": reflect.ValueOf((*types.Scope)(nil)),
"Selection": reflect.ValueOf((*types.Selection)(nil)),
"SelectionKind": reflect.ValueOf((*types.SelectionKind)(nil)),
"Signature": reflect.ValueOf((*types.Signature)(nil)),
"Sizes": reflect.ValueOf((*types.Sizes)(nil)),
"Slice": reflect.ValueOf((*types.Slice)(nil)),
"StdSizes": reflect.ValueOf((*types.StdSizes)(nil)),
"Struct": reflect.ValueOf((*types.Struct)(nil)),
"Term": reflect.ValueOf((*types.Term)(nil)),
"Tuple": reflect.ValueOf((*types.Tuple)(nil)),
"Type": reflect.ValueOf((*types.Type)(nil)),
"TypeAndValue": reflect.ValueOf((*types.TypeAndValue)(nil)),
"TypeList": reflect.ValueOf((*types.TypeList)(nil)),
"TypeName": reflect.ValueOf((*types.TypeName)(nil)),
"TypeParam": reflect.ValueOf((*types.TypeParam)(nil)),
"TypeParamList": reflect.ValueOf((*types.TypeParamList)(nil)),
"Union": reflect.ValueOf((*types.Union)(nil)),
"Var": reflect.ValueOf((*types.Var)(nil)),
// interface wrapper definitions
"_Importer": reflect.ValueOf((*_go_types_Importer)(nil)),
"_ImporterFrom": reflect.ValueOf((*_go_types_ImporterFrom)(nil)),
"_Object": reflect.ValueOf((*_go_types_Object)(nil)),
"_Sizes": reflect.ValueOf((*_go_types_Sizes)(nil)),
"_Type": reflect.ValueOf((*_go_types_Type)(nil)),
}
}
// _go_types_Importer is an interface wrapper for Importer type
type _go_types_Importer struct {
IValue interface{}
WImport func(path string) (*types.Package, error)
}
func (W _go_types_Importer) Import(path string) (*types.Package, error) { return W.WImport(path) }
// _go_types_ImporterFrom is an interface wrapper for ImporterFrom type
type _go_types_ImporterFrom struct {
IValue interface{}
WImport func(path string) (*types.Package, error)
WImportFrom func(path string, dir string, mode types.ImportMode) (*types.Package, error)
}
func (W _go_types_ImporterFrom) Import(path string) (*types.Package, error) { return W.WImport(path) }
func (W _go_types_ImporterFrom) ImportFrom(path string, dir string, mode types.ImportMode) (*types.Package, error) {
return W.WImportFrom(path, dir, mode)
}
// _go_types_Object is an interface wrapper for Object type
type _go_types_Object struct {
IValue interface{}
WExported func() bool
WId func() string
WName func() string
WParent func() *types.Scope
WPkg func() *types.Package
WPos func() token.Pos
WString func() string
WType func() types.Type
}
func (W _go_types_Object) Exported() bool { return W.WExported() }
func (W _go_types_Object) Id() string { return W.WId() }
func (W _go_types_Object) Name() string { return W.WName() }
func (W _go_types_Object) Parent() *types.Scope { return W.WParent() }
func (W _go_types_Object) Pkg() *types.Package { return W.WPkg() }
func (W _go_types_Object) Pos() token.Pos { return W.WPos() }
func (W _go_types_Object) String() string {
if W.WString == nil {
return ""
}
return W.WString()
}
func (W _go_types_Object) Type() types.Type { return W.WType() }
// _go_types_Sizes is an interface wrapper for Sizes type
type _go_types_Sizes struct {
IValue interface{}
WAlignof func(T types.Type) int64
WOffsetsof func(fields []*types.Var) []int64
WSizeof func(T types.Type) int64
}
func (W _go_types_Sizes) Alignof(T types.Type) int64 { return W.WAlignof(T) }
func (W _go_types_Sizes) Offsetsof(fields []*types.Var) []int64 { return W.WOffsetsof(fields) }
func (W _go_types_Sizes) Sizeof(T types.Type) int64 { return W.WSizeof(T) }
// _go_types_Type is an interface wrapper for Type type
type _go_types_Type struct {
IValue interface{}
WString func() string
WUnderlying func() types.Type
}
func (W _go_types_Type) String() string {
if W.WString == nil {
return ""
}
return W.WString()
}
func (W _go_types_Type) Underlying() types.Type { return W.WUnderlying() }
================================================
FILE: stdlib/go1_21_hash.go
================================================
// Code generated by 'yaegi extract hash'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"hash"
"reflect"
)
func init() {
Symbols["hash/hash"] = map[string]reflect.Value{
// type definitions
"Hash": reflect.ValueOf((*hash.Hash)(nil)),
"Hash32": reflect.ValueOf((*hash.Hash32)(nil)),
"Hash64": reflect.ValueOf((*hash.Hash64)(nil)),
// interface wrapper definitions
"_Hash": reflect.ValueOf((*_hash_Hash)(nil)),
"_Hash32": reflect.ValueOf((*_hash_Hash32)(nil)),
"_Hash64": reflect.ValueOf((*_hash_Hash64)(nil)),
}
}
// _hash_Hash is an interface wrapper for Hash type
type _hash_Hash struct {
IValue interface{}
WBlockSize func() int
WReset func()
WSize func() int
WSum func(b []byte) []byte
WWrite func(p []byte) (n int, err error)
}
func (W _hash_Hash) BlockSize() int { return W.WBlockSize() }
func (W _hash_Hash) Reset() { W.WReset() }
func (W _hash_Hash) Size() int { return W.WSize() }
func (W _hash_Hash) Sum(b []byte) []byte { return W.WSum(b) }
func (W _hash_Hash) Write(p []byte) (n int, err error) { return W.WWrite(p) }
// _hash_Hash32 is an interface wrapper for Hash32 type
type _hash_Hash32 struct {
IValue interface{}
WBlockSize func() int
WReset func()
WSize func() int
WSum func(b []byte) []byte
WSum32 func() uint32
WWrite func(p []byte) (n int, err error)
}
func (W _hash_Hash32) BlockSize() int { return W.WBlockSize() }
func (W _hash_Hash32) Reset() { W.WReset() }
func (W _hash_Hash32) Size() int { return W.WSize() }
func (W _hash_Hash32) Sum(b []byte) []byte { return W.WSum(b) }
func (W _hash_Hash32) Sum32() uint32 { return W.WSum32() }
func (W _hash_Hash32) Write(p []byte) (n int, err error) { return W.WWrite(p) }
// _hash_Hash64 is an interface wrapper for Hash64 type
type _hash_Hash64 struct {
IValue interface{}
WBlockSize func() int
WReset func()
WSize func() int
WSum func(b []byte) []byte
WSum64 func() uint64
WWrite func(p []byte) (n int, err error)
}
func (W _hash_Hash64) BlockSize() int { return W.WBlockSize() }
func (W _hash_Hash64) Reset() { W.WReset() }
func (W _hash_Hash64) Size() int { return W.WSize() }
func (W _hash_Hash64) Sum(b []byte) []byte { return W.WSum(b) }
func (W _hash_Hash64) Sum64() uint64 { return W.WSum64() }
func (W _hash_Hash64) Write(p []byte) (n int, err error) { return W.WWrite(p) }
================================================
FILE: stdlib/go1_21_hash_adler32.go
================================================
// Code generated by 'yaegi extract hash/adler32'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"go/constant"
"go/token"
"hash/adler32"
"reflect"
)
func init() {
Symbols["hash/adler32/adler32"] = map[string]reflect.Value{
// function, constant and variable definitions
"Checksum": reflect.ValueOf(adler32.Checksum),
"New": reflect.ValueOf(adler32.New),
"Size": reflect.ValueOf(constant.MakeFromLiteral("4", token.INT, 0)),
}
}
================================================
FILE: stdlib/go1_21_hash_crc32.go
================================================
// Code generated by 'yaegi extract hash/crc32'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"go/constant"
"go/token"
"hash/crc32"
"reflect"
)
func init() {
Symbols["hash/crc32/crc32"] = map[string]reflect.Value{
// function, constant and variable definitions
"Castagnoli": reflect.ValueOf(constant.MakeFromLiteral("2197175160", token.INT, 0)),
"Checksum": reflect.ValueOf(crc32.Checksum),
"ChecksumIEEE": reflect.ValueOf(crc32.ChecksumIEEE),
"IEEE": reflect.ValueOf(constant.MakeFromLiteral("3988292384", token.INT, 0)),
"IEEETable": reflect.ValueOf(&crc32.IEEETable).Elem(),
"Koopman": reflect.ValueOf(constant.MakeFromLiteral("3945912366", token.INT, 0)),
"MakeTable": reflect.ValueOf(crc32.MakeTable),
"New": reflect.ValueOf(crc32.New),
"NewIEEE": reflect.ValueOf(crc32.NewIEEE),
"Size": reflect.ValueOf(constant.MakeFromLiteral("4", token.INT, 0)),
"Update": reflect.ValueOf(crc32.Update),
// type definitions
"Table": reflect.ValueOf((*crc32.Table)(nil)),
}
}
================================================
FILE: stdlib/go1_21_hash_crc64.go
================================================
// Code generated by 'yaegi extract hash/crc64'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"go/constant"
"go/token"
"hash/crc64"
"reflect"
)
func init() {
Symbols["hash/crc64/crc64"] = map[string]reflect.Value{
// function, constant and variable definitions
"Checksum": reflect.ValueOf(crc64.Checksum),
"ECMA": reflect.ValueOf(constant.MakeFromLiteral("14514072000185962306", token.INT, 0)),
"ISO": reflect.ValueOf(constant.MakeFromLiteral("15564440312192434176", token.INT, 0)),
"MakeTable": reflect.ValueOf(crc64.MakeTable),
"New": reflect.ValueOf(crc64.New),
"Size": reflect.ValueOf(constant.MakeFromLiteral("8", token.INT, 0)),
"Update": reflect.ValueOf(crc64.Update),
// type definitions
"Table": reflect.ValueOf((*crc64.Table)(nil)),
}
}
================================================
FILE: stdlib/go1_21_hash_fnv.go
================================================
// Code generated by 'yaegi extract hash/fnv'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"hash/fnv"
"reflect"
)
func init() {
Symbols["hash/fnv/fnv"] = map[string]reflect.Value{
// function, constant and variable definitions
"New128": reflect.ValueOf(fnv.New128),
"New128a": reflect.ValueOf(fnv.New128a),
"New32": reflect.ValueOf(fnv.New32),
"New32a": reflect.ValueOf(fnv.New32a),
"New64": reflect.ValueOf(fnv.New64),
"New64a": reflect.ValueOf(fnv.New64a),
}
}
================================================
FILE: stdlib/go1_21_hash_maphash.go
================================================
// Code generated by 'yaegi extract hash/maphash'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"hash/maphash"
"reflect"
)
func init() {
Symbols["hash/maphash/maphash"] = map[string]reflect.Value{
// function, constant and variable definitions
"Bytes": reflect.ValueOf(maphash.Bytes),
"MakeSeed": reflect.ValueOf(maphash.MakeSeed),
"String": reflect.ValueOf(maphash.String),
// type definitions
"Hash": reflect.ValueOf((*maphash.Hash)(nil)),
"Seed": reflect.ValueOf((*maphash.Seed)(nil)),
}
}
================================================
FILE: stdlib/go1_21_html.go
================================================
// Code generated by 'yaegi extract html'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"html"
"reflect"
)
func init() {
Symbols["html/html"] = map[string]reflect.Value{
// function, constant and variable definitions
"EscapeString": reflect.ValueOf(html.EscapeString),
"UnescapeString": reflect.ValueOf(html.UnescapeString),
}
}
================================================
FILE: stdlib/go1_21_html_template.go
================================================
// Code generated by 'yaegi extract html/template'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"html/template"
"reflect"
)
func init() {
Symbols["html/template/template"] = map[string]reflect.Value{
// function, constant and variable definitions
"ErrAmbigContext": reflect.ValueOf(template.ErrAmbigContext),
"ErrBadHTML": reflect.ValueOf(template.ErrBadHTML),
"ErrBranchEnd": reflect.ValueOf(template.ErrBranchEnd),
"ErrEndContext": reflect.ValueOf(template.ErrEndContext),
"ErrJSTemplate": reflect.ValueOf(template.ErrJSTemplate),
"ErrNoSuchTemplate": reflect.ValueOf(template.ErrNoSuchTemplate),
"ErrOutputContext": reflect.ValueOf(template.ErrOutputContext),
"ErrPartialCharset": reflect.ValueOf(template.ErrPartialCharset),
"ErrPartialEscape": reflect.ValueOf(template.ErrPartialEscape),
"ErrPredefinedEscaper": reflect.ValueOf(template.ErrPredefinedEscaper),
"ErrRangeLoopReentry": reflect.ValueOf(template.ErrRangeLoopReentry),
"ErrSlashAmbig": reflect.ValueOf(template.ErrSlashAmbig),
"HTMLEscape": reflect.ValueOf(template.HTMLEscape),
"HTMLEscapeString": reflect.ValueOf(template.HTMLEscapeString),
"HTMLEscaper": reflect.ValueOf(template.HTMLEscaper),
"IsTrue": reflect.ValueOf(template.IsTrue),
"JSEscape": reflect.ValueOf(template.JSEscape),
"JSEscapeString": reflect.ValueOf(template.JSEscapeString),
"JSEscaper": reflect.ValueOf(template.JSEscaper),
"Must": reflect.ValueOf(template.Must),
"New": reflect.ValueOf(template.New),
"OK": reflect.ValueOf(template.OK),
"ParseFS": reflect.ValueOf(template.ParseFS),
"ParseFiles": reflect.ValueOf(template.ParseFiles),
"ParseGlob": reflect.ValueOf(template.ParseGlob),
"URLQueryEscaper": reflect.ValueOf(template.URLQueryEscaper),
// type definitions
"CSS": reflect.ValueOf((*template.CSS)(nil)),
"Error": reflect.ValueOf((*template.Error)(nil)),
"ErrorCode": reflect.ValueOf((*template.ErrorCode)(nil)),
"FuncMap": reflect.ValueOf((*template.FuncMap)(nil)),
"HTML": reflect.ValueOf((*template.HTML)(nil)),
"HTMLAttr": reflect.ValueOf((*template.HTMLAttr)(nil)),
"JS": reflect.ValueOf((*template.JS)(nil)),
"JSStr": reflect.ValueOf((*template.JSStr)(nil)),
"Srcset": reflect.ValueOf((*template.Srcset)(nil)),
"Template": reflect.ValueOf((*template.Template)(nil)),
"URL": reflect.ValueOf((*template.URL)(nil)),
}
}
================================================
FILE: stdlib/go1_21_image.go
================================================
// Code generated by 'yaegi extract image'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"image"
"image/color"
"reflect"
)
func init() {
Symbols["image/image"] = map[string]reflect.Value{
// function, constant and variable definitions
"Black": reflect.ValueOf(&image.Black).Elem(),
"Decode": reflect.ValueOf(image.Decode),
"DecodeConfig": reflect.ValueOf(image.DecodeConfig),
"ErrFormat": reflect.ValueOf(&image.ErrFormat).Elem(),
"NewAlpha": reflect.ValueOf(image.NewAlpha),
"NewAlpha16": reflect.ValueOf(image.NewAlpha16),
"NewCMYK": reflect.ValueOf(image.NewCMYK),
"NewGray": reflect.ValueOf(image.NewGray),
"NewGray16": reflect.ValueOf(image.NewGray16),
"NewNRGBA": reflect.ValueOf(image.NewNRGBA),
"NewNRGBA64": reflect.ValueOf(image.NewNRGBA64),
"NewNYCbCrA": reflect.ValueOf(image.NewNYCbCrA),
"NewPaletted": reflect.ValueOf(image.NewPaletted),
"NewRGBA": reflect.ValueOf(image.NewRGBA),
"NewRGBA64": reflect.ValueOf(image.NewRGBA64),
"NewUniform": reflect.ValueOf(image.NewUniform),
"NewYCbCr": reflect.ValueOf(image.NewYCbCr),
"Opaque": reflect.ValueOf(&image.Opaque).Elem(),
"Pt": reflect.ValueOf(image.Pt),
"Rect": reflect.ValueOf(image.Rect),
"RegisterFormat": reflect.ValueOf(image.RegisterFormat),
"Transparent": reflect.ValueOf(&image.Transparent).Elem(),
"White": reflect.ValueOf(&image.White).Elem(),
"YCbCrSubsampleRatio410": reflect.ValueOf(image.YCbCrSubsampleRatio410),
"YCbCrSubsampleRatio411": reflect.ValueOf(image.YCbCrSubsampleRatio411),
"YCbCrSubsampleRatio420": reflect.ValueOf(image.YCbCrSubsampleRatio420),
"YCbCrSubsampleRatio422": reflect.ValueOf(image.YCbCrSubsampleRatio422),
"YCbCrSubsampleRatio440": reflect.ValueOf(image.YCbCrSubsampleRatio440),
"YCbCrSubsampleRatio444": reflect.ValueOf(image.YCbCrSubsampleRatio444),
"ZP": reflect.ValueOf(&image.ZP).Elem(),
"ZR": reflect.ValueOf(&image.ZR).Elem(),
// type definitions
"Alpha": reflect.ValueOf((*image.Alpha)(nil)),
"Alpha16": reflect.ValueOf((*image.Alpha16)(nil)),
"CMYK": reflect.ValueOf((*image.CMYK)(nil)),
"Config": reflect.ValueOf((*image.Config)(nil)),
"Gray": reflect.ValueOf((*image.Gray)(nil)),
"Gray16": reflect.ValueOf((*image.Gray16)(nil)),
"Image": reflect.ValueOf((*image.Image)(nil)),
"NRGBA": reflect.ValueOf((*image.NRGBA)(nil)),
"NRGBA64": reflect.ValueOf((*image.NRGBA64)(nil)),
"NYCbCrA": reflect.ValueOf((*image.NYCbCrA)(nil)),
"Paletted": reflect.ValueOf((*image.Paletted)(nil)),
"PalettedImage": reflect.ValueOf((*image.PalettedImage)(nil)),
"Point": reflect.ValueOf((*image.Point)(nil)),
"RGBA": reflect.ValueOf((*image.RGBA)(nil)),
"RGBA64": reflect.ValueOf((*image.RGBA64)(nil)),
"RGBA64Image": reflect.ValueOf((*image.RGBA64Image)(nil)),
"Rectangle": reflect.ValueOf((*image.Rectangle)(nil)),
"Uniform": reflect.ValueOf((*image.Uniform)(nil)),
"YCbCr": reflect.ValueOf((*image.YCbCr)(nil)),
"YCbCrSubsampleRatio": reflect.ValueOf((*image.YCbCrSubsampleRatio)(nil)),
// interface wrapper definitions
"_Image": reflect.ValueOf((*_image_Image)(nil)),
"_PalettedImage": reflect.ValueOf((*_image_PalettedImage)(nil)),
"_RGBA64Image": reflect.ValueOf((*_image_RGBA64Image)(nil)),
}
}
// _image_Image is an interface wrapper for Image type
type _image_Image struct {
IValue interface{}
WAt func(x int, y int) color.Color
WBounds func() image.Rectangle
WColorModel func() color.Model
}
func (W _image_Image) At(x int, y int) color.Color { return W.WAt(x, y) }
func (W _image_Image) Bounds() image.Rectangle { return W.WBounds() }
func (W _image_Image) ColorModel() color.Model { return W.WColorModel() }
// _image_PalettedImage is an interface wrapper for PalettedImage type
type _image_PalettedImage struct {
IValue interface{}
WAt func(x int, y int) color.Color
WBounds func() image.Rectangle
WColorIndexAt func(x int, y int) uint8
WColorModel func() color.Model
}
func (W _image_PalettedImage) At(x int, y int) color.Color { return W.WAt(x, y) }
func (W _image_PalettedImage) Bounds() image.Rectangle { return W.WBounds() }
func (W _image_PalettedImage) ColorIndexAt(x int, y int) uint8 { return W.WColorIndexAt(x, y) }
func (W _image_PalettedImage) ColorModel() color.Model { return W.WColorModel() }
// _image_RGBA64Image is an interface wrapper for RGBA64Image type
type _image_RGBA64Image struct {
IValue interface{}
WAt func(x int, y int) color.Color
WBounds func() image.Rectangle
WColorModel func() color.Model
WRGBA64At func(x int, y int) color.RGBA64
}
func (W _image_RGBA64Image) At(x int, y int) color.Color { return W.WAt(x, y) }
func (W _image_RGBA64Image) Bounds() image.Rectangle { return W.WBounds() }
func (W _image_RGBA64Image) ColorModel() color.Model { return W.WColorModel() }
func (W _image_RGBA64Image) RGBA64At(x int, y int) color.RGBA64 { return W.WRGBA64At(x, y) }
================================================
FILE: stdlib/go1_21_image_color.go
================================================
// Code generated by 'yaegi extract image/color'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"image/color"
"reflect"
)
func init() {
Symbols["image/color/color"] = map[string]reflect.Value{
// function, constant and variable definitions
"Alpha16Model": reflect.ValueOf(&color.Alpha16Model).Elem(),
"AlphaModel": reflect.ValueOf(&color.AlphaModel).Elem(),
"Black": reflect.ValueOf(&color.Black).Elem(),
"CMYKModel": reflect.ValueOf(&color.CMYKModel).Elem(),
"CMYKToRGB": reflect.ValueOf(color.CMYKToRGB),
"Gray16Model": reflect.ValueOf(&color.Gray16Model).Elem(),
"GrayModel": reflect.ValueOf(&color.GrayModel).Elem(),
"ModelFunc": reflect.ValueOf(color.ModelFunc),
"NRGBA64Model": reflect.ValueOf(&color.NRGBA64Model).Elem(),
"NRGBAModel": reflect.ValueOf(&color.NRGBAModel).Elem(),
"NYCbCrAModel": reflect.ValueOf(&color.NYCbCrAModel).Elem(),
"Opaque": reflect.ValueOf(&color.Opaque).Elem(),
"RGBA64Model": reflect.ValueOf(&color.RGBA64Model).Elem(),
"RGBAModel": reflect.ValueOf(&color.RGBAModel).Elem(),
"RGBToCMYK": reflect.ValueOf(color.RGBToCMYK),
"RGBToYCbCr": reflect.ValueOf(color.RGBToYCbCr),
"Transparent": reflect.ValueOf(&color.Transparent).Elem(),
"White": reflect.ValueOf(&color.White).Elem(),
"YCbCrModel": reflect.ValueOf(&color.YCbCrModel).Elem(),
"YCbCrToRGB": reflect.ValueOf(color.YCbCrToRGB),
// type definitions
"Alpha": reflect.ValueOf((*color.Alpha)(nil)),
"Alpha16": reflect.ValueOf((*color.Alpha16)(nil)),
"CMYK": reflect.ValueOf((*color.CMYK)(nil)),
"Color": reflect.ValueOf((*color.Color)(nil)),
"Gray": reflect.ValueOf((*color.Gray)(nil)),
"Gray16": reflect.ValueOf((*color.Gray16)(nil)),
"Model": reflect.ValueOf((*color.Model)(nil)),
"NRGBA": reflect.ValueOf((*color.NRGBA)(nil)),
"NRGBA64": reflect.ValueOf((*color.NRGBA64)(nil)),
"NYCbCrA": reflect.ValueOf((*color.NYCbCrA)(nil)),
"Palette": reflect.ValueOf((*color.Palette)(nil)),
"RGBA": reflect.ValueOf((*color.RGBA)(nil)),
"RGBA64": reflect.ValueOf((*color.RGBA64)(nil)),
"YCbCr": reflect.ValueOf((*color.YCbCr)(nil)),
// interface wrapper definitions
"_Color": reflect.ValueOf((*_image_color_Color)(nil)),
"_Model": reflect.ValueOf((*_image_color_Model)(nil)),
}
}
// _image_color_Color is an interface wrapper for Color type
type _image_color_Color struct {
IValue interface{}
WRGBA func() (r uint32, g uint32, b uint32, a uint32)
}
func (W _image_color_Color) RGBA() (r uint32, g uint32, b uint32, a uint32) { return W.WRGBA() }
// _image_color_Model is an interface wrapper for Model type
type _image_color_Model struct {
IValue interface{}
WConvert func(c color.Color) color.Color
}
func (W _image_color_Model) Convert(c color.Color) color.Color { return W.WConvert(c) }
================================================
FILE: stdlib/go1_21_image_color_palette.go
================================================
// Code generated by 'yaegi extract image/color/palette'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"image/color/palette"
"reflect"
)
func init() {
Symbols["image/color/palette/palette"] = map[string]reflect.Value{
// function, constant and variable definitions
"Plan9": reflect.ValueOf(&palette.Plan9).Elem(),
"WebSafe": reflect.ValueOf(&palette.WebSafe).Elem(),
}
}
================================================
FILE: stdlib/go1_21_image_draw.go
================================================
// Code generated by 'yaegi extract image/draw'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"image"
"image/color"
"image/draw"
"reflect"
)
func init() {
Symbols["image/draw/draw"] = map[string]reflect.Value{
// function, constant and variable definitions
"Draw": reflect.ValueOf(draw.Draw),
"DrawMask": reflect.ValueOf(draw.DrawMask),
"FloydSteinberg": reflect.ValueOf(&draw.FloydSteinberg).Elem(),
"Over": reflect.ValueOf(draw.Over),
"Src": reflect.ValueOf(draw.Src),
// type definitions
"Drawer": reflect.ValueOf((*draw.Drawer)(nil)),
"Image": reflect.ValueOf((*draw.Image)(nil)),
"Op": reflect.ValueOf((*draw.Op)(nil)),
"Quantizer": reflect.ValueOf((*draw.Quantizer)(nil)),
"RGBA64Image": reflect.ValueOf((*draw.RGBA64Image)(nil)),
// interface wrapper definitions
"_Drawer": reflect.ValueOf((*_image_draw_Drawer)(nil)),
"_Image": reflect.ValueOf((*_image_draw_Image)(nil)),
"_Quantizer": reflect.ValueOf((*_image_draw_Quantizer)(nil)),
"_RGBA64Image": reflect.ValueOf((*_image_draw_RGBA64Image)(nil)),
}
}
// _image_draw_Drawer is an interface wrapper for Drawer type
type _image_draw_Drawer struct {
IValue interface{}
WDraw func(dst draw.Image, r image.Rectangle, src image.Image, sp image.Point)
}
func (W _image_draw_Drawer) Draw(dst draw.Image, r image.Rectangle, src image.Image, sp image.Point) {
W.WDraw(dst, r, src, sp)
}
// _image_draw_Image is an interface wrapper for Image type
type _image_draw_Image struct {
IValue interface{}
WAt func(x int, y int) color.Color
WBounds func() image.Rectangle
WColorModel func() color.Model
WSet func(x int, y int, c color.Color)
}
func (W _image_draw_Image) At(x int, y int) color.Color { return W.WAt(x, y) }
func (W _image_draw_Image) Bounds() image.Rectangle { return W.WBounds() }
func (W _image_draw_Image) ColorModel() color.Model { return W.WColorModel() }
func (W _image_draw_Image) Set(x int, y int, c color.Color) { W.WSet(x, y, c) }
// _image_draw_Quantizer is an interface wrapper for Quantizer type
type _image_draw_Quantizer struct {
IValue interface{}
WQuantize func(p color.Palette, m image.Image) color.Palette
}
func (W _image_draw_Quantizer) Quantize(p color.Palette, m image.Image) color.Palette {
return W.WQuantize(p, m)
}
// _image_draw_RGBA64Image is an interface wrapper for RGBA64Image type
type _image_draw_RGBA64Image struct {
IValue interface{}
WAt func(x int, y int) color.Color
WBounds func() image.Rectangle
WColorModel func() color.Model
WRGBA64At func(x int, y int) color.RGBA64
WSet func(x int, y int, c color.Color)
WSetRGBA64 func(x int, y int, c color.RGBA64)
}
func (W _image_draw_RGBA64Image) At(x int, y int) color.Color { return W.WAt(x, y) }
func (W _image_draw_RGBA64Image) Bounds() image.Rectangle { return W.WBounds() }
func (W _image_draw_RGBA64Image) ColorModel() color.Model { return W.WColorModel() }
func (W _image_draw_RGBA64Image) RGBA64At(x int, y int) color.RGBA64 { return W.WRGBA64At(x, y) }
func (W _image_draw_RGBA64Image) Set(x int, y int, c color.Color) { W.WSet(x, y, c) }
func (W _image_draw_RGBA64Image) SetRGBA64(x int, y int, c color.RGBA64) { W.WSetRGBA64(x, y, c) }
================================================
FILE: stdlib/go1_21_image_gif.go
================================================
// Code generated by 'yaegi extract image/gif'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"go/constant"
"go/token"
"image/gif"
"reflect"
)
func init() {
Symbols["image/gif/gif"] = map[string]reflect.Value{
// function, constant and variable definitions
"Decode": reflect.ValueOf(gif.Decode),
"DecodeAll": reflect.ValueOf(gif.DecodeAll),
"DecodeConfig": reflect.ValueOf(gif.DecodeConfig),
"DisposalBackground": reflect.ValueOf(constant.MakeFromLiteral("2", token.INT, 0)),
"DisposalNone": reflect.ValueOf(constant.MakeFromLiteral("1", token.INT, 0)),
"DisposalPrevious": reflect.ValueOf(constant.MakeFromLiteral("3", token.INT, 0)),
"Encode": reflect.ValueOf(gif.Encode),
"EncodeAll": reflect.ValueOf(gif.EncodeAll),
// type definitions
"GIF": reflect.ValueOf((*gif.GIF)(nil)),
"Options": reflect.ValueOf((*gif.Options)(nil)),
}
}
================================================
FILE: stdlib/go1_21_image_jpeg.go
================================================
// Code generated by 'yaegi extract image/jpeg'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"go/constant"
"go/token"
"image/jpeg"
"reflect"
)
func init() {
Symbols["image/jpeg/jpeg"] = map[string]reflect.Value{
// function, constant and variable definitions
"Decode": reflect.ValueOf(jpeg.Decode),
"DecodeConfig": reflect.ValueOf(jpeg.DecodeConfig),
"DefaultQuality": reflect.ValueOf(constant.MakeFromLiteral("75", token.INT, 0)),
"Encode": reflect.ValueOf(jpeg.Encode),
// type definitions
"FormatError": reflect.ValueOf((*jpeg.FormatError)(nil)),
"Options": reflect.ValueOf((*jpeg.Options)(nil)),
"Reader": reflect.ValueOf((*jpeg.Reader)(nil)),
"UnsupportedError": reflect.ValueOf((*jpeg.UnsupportedError)(nil)),
// interface wrapper definitions
"_Reader": reflect.ValueOf((*_image_jpeg_Reader)(nil)),
}
}
// _image_jpeg_Reader is an interface wrapper for Reader type
type _image_jpeg_Reader struct {
IValue interface{}
WRead func(p []byte) (n int, err error)
WReadByte func() (byte, error)
}
func (W _image_jpeg_Reader) Read(p []byte) (n int, err error) { return W.WRead(p) }
func (W _image_jpeg_Reader) ReadByte() (byte, error) { return W.WReadByte() }
================================================
FILE: stdlib/go1_21_image_png.go
================================================
// Code generated by 'yaegi extract image/png'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"image/png"
"reflect"
)
func init() {
Symbols["image/png/png"] = map[string]reflect.Value{
// function, constant and variable definitions
"BestCompression": reflect.ValueOf(png.BestCompression),
"BestSpeed": reflect.ValueOf(png.BestSpeed),
"Decode": reflect.ValueOf(png.Decode),
"DecodeConfig": reflect.ValueOf(png.DecodeConfig),
"DefaultCompression": reflect.ValueOf(png.DefaultCompression),
"Encode": reflect.ValueOf(png.Encode),
"NoCompression": reflect.ValueOf(png.NoCompression),
// type definitions
"CompressionLevel": reflect.ValueOf((*png.CompressionLevel)(nil)),
"Encoder": reflect.ValueOf((*png.Encoder)(nil)),
"EncoderBuffer": reflect.ValueOf((*png.EncoderBuffer)(nil)),
"EncoderBufferPool": reflect.ValueOf((*png.EncoderBufferPool)(nil)),
"FormatError": reflect.ValueOf((*png.FormatError)(nil)),
"UnsupportedError": reflect.ValueOf((*png.UnsupportedError)(nil)),
// interface wrapper definitions
"_EncoderBufferPool": reflect.ValueOf((*_image_png_EncoderBufferPool)(nil)),
}
}
// _image_png_EncoderBufferPool is an interface wrapper for EncoderBufferPool type
type _image_png_EncoderBufferPool struct {
IValue interface{}
WGet func() *png.EncoderBuffer
WPut func(a0 *png.EncoderBuffer)
}
func (W _image_png_EncoderBufferPool) Get() *png.EncoderBuffer { return W.WGet() }
func (W _image_png_EncoderBufferPool) Put(a0 *png.EncoderBuffer) { W.WPut(a0) }
================================================
FILE: stdlib/go1_21_index_suffixarray.go
================================================
// Code generated by 'yaegi extract index/suffixarray'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"index/suffixarray"
"reflect"
)
func init() {
Symbols["index/suffixarray/suffixarray"] = map[string]reflect.Value{
// function, constant and variable definitions
"New": reflect.ValueOf(suffixarray.New),
// type definitions
"Index": reflect.ValueOf((*suffixarray.Index)(nil)),
}
}
================================================
FILE: stdlib/go1_21_io.go
================================================
// Code generated by 'yaegi extract io'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"go/constant"
"go/token"
"io"
"reflect"
)
func init() {
Symbols["io/io"] = map[string]reflect.Value{
// function, constant and variable definitions
"Copy": reflect.ValueOf(io.Copy),
"CopyBuffer": reflect.ValueOf(io.CopyBuffer),
"CopyN": reflect.ValueOf(io.CopyN),
"Discard": reflect.ValueOf(&io.Discard).Elem(),
"EOF": reflect.ValueOf(&io.EOF).Elem(),
"ErrClosedPipe": reflect.ValueOf(&io.ErrClosedPipe).Elem(),
"ErrNoProgress": reflect.ValueOf(&io.ErrNoProgress).Elem(),
"ErrShortBuffer": reflect.ValueOf(&io.ErrShortBuffer).Elem(),
"ErrShortWrite": reflect.ValueOf(&io.ErrShortWrite).Elem(),
"ErrUnexpectedEOF": reflect.ValueOf(&io.ErrUnexpectedEOF).Elem(),
"LimitReader": reflect.ValueOf(io.LimitReader),
"MultiReader": reflect.ValueOf(io.MultiReader),
"MultiWriter": reflect.ValueOf(io.MultiWriter),
"NewOffsetWriter": reflect.ValueOf(io.NewOffsetWriter),
"NewSectionReader": reflect.ValueOf(io.NewSectionReader),
"NopCloser": reflect.ValueOf(io.NopCloser),
"Pipe": reflect.ValueOf(io.Pipe),
"ReadAll": reflect.ValueOf(io.ReadAll),
"ReadAtLeast": reflect.ValueOf(io.ReadAtLeast),
"ReadFull": reflect.ValueOf(io.ReadFull),
"SeekCurrent": reflect.ValueOf(constant.MakeFromLiteral("1", token.INT, 0)),
"SeekEnd": reflect.ValueOf(constant.MakeFromLiteral("2", token.INT, 0)),
"SeekStart": reflect.ValueOf(constant.MakeFromLiteral("0", token.INT, 0)),
"TeeReader": reflect.ValueOf(io.TeeReader),
"WriteString": reflect.ValueOf(io.WriteString),
// type definitions
"ByteReader": reflect.ValueOf((*io.ByteReader)(nil)),
"ByteScanner": reflect.ValueOf((*io.ByteScanner)(nil)),
"ByteWriter": reflect.ValueOf((*io.ByteWriter)(nil)),
"Closer": reflect.ValueOf((*io.Closer)(nil)),
"LimitedReader": reflect.ValueOf((*io.LimitedReader)(nil)),
"OffsetWriter": reflect.ValueOf((*io.OffsetWriter)(nil)),
"PipeReader": reflect.ValueOf((*io.PipeReader)(nil)),
"PipeWriter": reflect.ValueOf((*io.PipeWriter)(nil)),
"ReadCloser": reflect.ValueOf((*io.ReadCloser)(nil)),
"ReadSeekCloser": reflect.ValueOf((*io.ReadSeekCloser)(nil)),
"ReadSeeker": reflect.ValueOf((*io.ReadSeeker)(nil)),
"ReadWriteCloser": reflect.ValueOf((*io.ReadWriteCloser)(nil)),
"ReadWriteSeeker": reflect.ValueOf((*io.ReadWriteSeeker)(nil)),
"ReadWriter": reflect.ValueOf((*io.ReadWriter)(nil)),
"Reader": reflect.ValueOf((*io.Reader)(nil)),
"ReaderAt": reflect.ValueOf((*io.ReaderAt)(nil)),
"ReaderFrom": reflect.ValueOf((*io.ReaderFrom)(nil)),
"RuneReader": reflect.ValueOf((*io.RuneReader)(nil)),
"RuneScanner": reflect.ValueOf((*io.RuneScanner)(nil)),
"SectionReader": reflect.ValueOf((*io.SectionReader)(nil)),
"Seeker": reflect.ValueOf((*io.Seeker)(nil)),
"StringWriter": reflect.ValueOf((*io.StringWriter)(nil)),
"WriteCloser": reflect.ValueOf((*io.WriteCloser)(nil)),
"WriteSeeker": reflect.ValueOf((*io.WriteSeeker)(nil)),
"Writer": reflect.ValueOf((*io.Writer)(nil)),
"WriterAt": reflect.ValueOf((*io.WriterAt)(nil)),
"WriterTo": reflect.ValueOf((*io.WriterTo)(nil)),
// interface wrapper definitions
"_ByteReader": reflect.ValueOf((*_io_ByteReader)(nil)),
"_ByteScanner": reflect.ValueOf((*_io_ByteScanner)(nil)),
"_ByteWriter": reflect.ValueOf((*_io_ByteWriter)(nil)),
"_Closer": reflect.ValueOf((*_io_Closer)(nil)),
"_ReadCloser": reflect.ValueOf((*_io_ReadCloser)(nil)),
"_ReadSeekCloser": reflect.ValueOf((*_io_ReadSeekCloser)(nil)),
"_ReadSeeker": reflect.ValueOf((*_io_ReadSeeker)(nil)),
"_ReadWriteCloser": reflect.ValueOf((*_io_ReadWriteCloser)(nil)),
"_ReadWriteSeeker": reflect.ValueOf((*_io_ReadWriteSeeker)(nil)),
"_ReadWriter": reflect.ValueOf((*_io_ReadWriter)(nil)),
"_Reader": reflect.ValueOf((*_io_Reader)(nil)),
"_ReaderAt": reflect.ValueOf((*_io_ReaderAt)(nil)),
"_ReaderFrom": reflect.ValueOf((*_io_ReaderFrom)(nil)),
"_RuneReader": reflect.ValueOf((*_io_RuneReader)(nil)),
"_RuneScanner": reflect.ValueOf((*_io_RuneScanner)(nil)),
"_Seeker": reflect.ValueOf((*_io_Seeker)(nil)),
"_StringWriter": reflect.ValueOf((*_io_StringWriter)(nil)),
"_WriteCloser": reflect.ValueOf((*_io_WriteCloser)(nil)),
"_WriteSeeker": reflect.ValueOf((*_io_WriteSeeker)(nil)),
"_Writer": reflect.ValueOf((*_io_Writer)(nil)),
"_WriterAt": reflect.ValueOf((*_io_WriterAt)(nil)),
"_WriterTo": reflect.ValueOf((*_io_WriterTo)(nil)),
}
}
// _io_ByteReader is an interface wrapper for ByteReader type
type _io_ByteReader struct {
IValue interface{}
WReadByte func() (byte, error)
}
func (W _io_ByteReader) ReadByte() (byte, error) { return W.WReadByte() }
// _io_ByteScanner is an interface wrapper for ByteScanner type
type _io_ByteScanner struct {
IValue interface{}
WReadByte func() (byte, error)
WUnreadByte func() error
}
func (W _io_ByteScanner) ReadByte() (byte, error) { return W.WReadByte() }
func (W _io_ByteScanner) UnreadByte() error { return W.WUnreadByte() }
// _io_ByteWriter is an interface wrapper for ByteWriter type
type _io_ByteWriter struct {
IValue interface{}
WWriteByte func(c byte) error
}
func (W _io_ByteWriter) WriteByte(c byte) error { return W.WWriteByte(c) }
// _io_Closer is an interface wrapper for Closer type
type _io_Closer struct {
IValue interface{}
WClose func() error
}
func (W _io_Closer) Close() error { return W.WClose() }
// _io_ReadCloser is an interface wrapper for ReadCloser type
type _io_ReadCloser struct {
IValue interface{}
WClose func() error
WRead func(p []byte) (n int, err error)
}
func (W _io_ReadCloser) Close() error { return W.WClose() }
func (W _io_ReadCloser) Read(p []byte) (n int, err error) { return W.WRead(p) }
// _io_ReadSeekCloser is an interface wrapper for ReadSeekCloser type
type _io_ReadSeekCloser struct {
IValue interface{}
WClose func() error
WRead func(p []byte) (n int, err error)
WSeek func(offset int64, whence int) (int64, error)
}
func (W _io_ReadSeekCloser) Close() error { return W.WClose() }
func (W _io_ReadSeekCloser) Read(p []byte) (n int, err error) { return W.WRead(p) }
func (W _io_ReadSeekCloser) Seek(offset int64, whence int) (int64, error) {
return W.WSeek(offset, whence)
}
// _io_ReadSeeker is an interface wrapper for ReadSeeker type
type _io_ReadSeeker struct {
IValue interface{}
WRead func(p []byte) (n int, err error)
WSeek func(offset int64, whence int) (int64, error)
}
func (W _io_ReadSeeker) Read(p []byte) (n int, err error) { return W.WRead(p) }
func (W _io_ReadSeeker) Seek(offset int64, whence int) (int64, error) { return W.WSeek(offset, whence) }
// _io_ReadWriteCloser is an interface wrapper for ReadWriteCloser type
type _io_ReadWriteCloser struct {
IValue interface{}
WClose func() error
WRead func(p []byte) (n int, err error)
WWrite func(p []byte) (n int, err error)
}
func (W _io_ReadWriteCloser) Close() error { return W.WClose() }
func (W _io_ReadWriteCloser) Read(p []byte) (n int, err error) { return W.WRead(p) }
func (W _io_ReadWriteCloser) Write(p []byte) (n int, err error) { return W.WWrite(p) }
// _io_ReadWriteSeeker is an interface wrapper for ReadWriteSeeker type
type _io_ReadWriteSeeker struct {
IValue interface{}
WRead func(p []byte) (n int, err error)
WSeek func(offset int64, whence int) (int64, error)
WWrite func(p []byte) (n int, err error)
}
func (W _io_ReadWriteSeeker) Read(p []byte) (n int, err error) { return W.WRead(p) }
func (W _io_ReadWriteSeeker) Seek(offset int64, whence int) (int64, error) {
return W.WSeek(offset, whence)
}
func (W _io_ReadWriteSeeker) Write(p []byte) (n int, err error) { return W.WWrite(p) }
// _io_ReadWriter is an interface wrapper for ReadWriter type
type _io_ReadWriter struct {
IValue interface{}
WRead func(p []byte) (n int, err error)
WWrite func(p []byte) (n int, err error)
}
func (W _io_ReadWriter) Read(p []byte) (n int, err error) { return W.WRead(p) }
func (W _io_ReadWriter) Write(p []byte) (n int, err error) { return W.WWrite(p) }
// _io_Reader is an interface wrapper for Reader type
type _io_Reader struct {
IValue interface{}
WRead func(p []byte) (n int, err error)
}
func (W _io_Reader) Read(p []byte) (n int, err error) { return W.WRead(p) }
// _io_ReaderAt is an interface wrapper for ReaderAt type
type _io_ReaderAt struct {
IValue interface{}
WReadAt func(p []byte, off int64) (n int, err error)
}
func (W _io_ReaderAt) ReadAt(p []byte, off int64) (n int, err error) { return W.WReadAt(p, off) }
// _io_ReaderFrom is an interface wrapper for ReaderFrom type
type _io_ReaderFrom struct {
IValue interface{}
WReadFrom func(r io.Reader) (n int64, err error)
}
func (W _io_ReaderFrom) ReadFrom(r io.Reader) (n int64, err error) { return W.WReadFrom(r) }
// _io_RuneReader is an interface wrapper for RuneReader type
type _io_RuneReader struct {
IValue interface{}
WReadRune func() (r rune, size int, err error)
}
func (W _io_RuneReader) ReadRune() (r rune, size int, err error) { return W.WReadRune() }
// _io_RuneScanner is an interface wrapper for RuneScanner type
type _io_RuneScanner struct {
IValue interface{}
WReadRune func() (r rune, size int, err error)
WUnreadRune func() error
}
func (W _io_RuneScanner) ReadRune() (r rune, size int, err error) { return W.WReadRune() }
func (W _io_RuneScanner) UnreadRune() error { return W.WUnreadRune() }
// _io_Seeker is an interface wrapper for Seeker type
type _io_Seeker struct {
IValue interface{}
WSeek func(offset int64, whence int) (int64, error)
}
func (W _io_Seeker) Seek(offset int64, whence int) (int64, error) { return W.WSeek(offset, whence) }
// _io_StringWriter is an interface wrapper for StringWriter type
type _io_StringWriter struct {
IValue interface{}
WWriteString func(s string) (n int, err error)
}
func (W _io_StringWriter) WriteString(s string) (n int, err error) { return W.WWriteString(s) }
// _io_WriteCloser is an interface wrapper for WriteCloser type
type _io_WriteCloser struct {
IValue interface{}
WClose func() error
WWrite func(p []byte) (n int, err error)
}
func (W _io_WriteCloser) Close() error { return W.WClose() }
func (W _io_WriteCloser) Write(p []byte) (n int, err error) { return W.WWrite(p) }
// _io_WriteSeeker is an interface wrapper for WriteSeeker type
type _io_WriteSeeker struct {
IValue interface{}
WSeek func(offset int64, whence int) (int64, error)
WWrite func(p []byte) (n int, err error)
}
func (W _io_WriteSeeker) Seek(offset int64, whence int) (int64, error) {
return W.WSeek(offset, whence)
}
func (W _io_WriteSeeker) Write(p []byte) (n int, err error) { return W.WWrite(p) }
// _io_Writer is an interface wrapper for Writer type
type _io_Writer struct {
IValue interface{}
WWrite func(p []byte) (n int, err error)
}
func (W _io_Writer) Write(p []byte) (n int, err error) { return W.WWrite(p) }
// _io_WriterAt is an interface wrapper for WriterAt type
type _io_WriterAt struct {
IValue interface{}
WWriteAt func(p []byte, off int64) (n int, err error)
}
func (W _io_WriterAt) WriteAt(p []byte, off int64) (n int, err error) { return W.WWriteAt(p, off) }
// _io_WriterTo is an interface wrapper for WriterTo type
type _io_WriterTo struct {
IValue interface{}
WWriteTo func(w io.Writer) (n int64, err error)
}
func (W _io_WriterTo) WriteTo(w io.Writer) (n int64, err error) { return W.WWriteTo(w) }
================================================
FILE: stdlib/go1_21_io_fs.go
================================================
// Code generated by 'yaegi extract io/fs'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"io/fs"
"reflect"
"time"
)
func init() {
Symbols["io/fs/fs"] = map[string]reflect.Value{
// function, constant and variable definitions
"ErrClosed": reflect.ValueOf(&fs.ErrClosed).Elem(),
"ErrExist": reflect.ValueOf(&fs.ErrExist).Elem(),
"ErrInvalid": reflect.ValueOf(&fs.ErrInvalid).Elem(),
"ErrNotExist": reflect.ValueOf(&fs.ErrNotExist).Elem(),
"ErrPermission": reflect.ValueOf(&fs.ErrPermission).Elem(),
"FileInfoToDirEntry": reflect.ValueOf(fs.FileInfoToDirEntry),
"FormatDirEntry": reflect.ValueOf(fs.FormatDirEntry),
"FormatFileInfo": reflect.ValueOf(fs.FormatFileInfo),
"Glob": reflect.ValueOf(fs.Glob),
"ModeAppend": reflect.ValueOf(fs.ModeAppend),
"ModeCharDevice": reflect.ValueOf(fs.ModeCharDevice),
"ModeDevice": reflect.ValueOf(fs.ModeDevice),
"ModeDir": reflect.ValueOf(fs.ModeDir),
"ModeExclusive": reflect.ValueOf(fs.ModeExclusive),
"ModeIrregular": reflect.ValueOf(fs.ModeIrregular),
"ModeNamedPipe": reflect.ValueOf(fs.ModeNamedPipe),
"ModePerm": reflect.ValueOf(fs.ModePerm),
"ModeSetgid": reflect.ValueOf(fs.ModeSetgid),
"ModeSetuid": reflect.ValueOf(fs.ModeSetuid),
"ModeSocket": reflect.ValueOf(fs.ModeSocket),
"ModeSticky": reflect.ValueOf(fs.ModeSticky),
"ModeSymlink": reflect.ValueOf(fs.ModeSymlink),
"ModeTemporary": reflect.ValueOf(fs.ModeTemporary),
"ModeType": reflect.ValueOf(fs.ModeType),
"ReadDir": reflect.ValueOf(fs.ReadDir),
"ReadFile": reflect.ValueOf(fs.ReadFile),
"SkipAll": reflect.ValueOf(&fs.SkipAll).Elem(),
"SkipDir": reflect.ValueOf(&fs.SkipDir).Elem(),
"Stat": reflect.ValueOf(fs.Stat),
"Sub": reflect.ValueOf(fs.Sub),
"ValidPath": reflect.ValueOf(fs.ValidPath),
"WalkDir": reflect.ValueOf(fs.WalkDir),
// type definitions
"DirEntry": reflect.ValueOf((*fs.DirEntry)(nil)),
"FS": reflect.ValueOf((*fs.FS)(nil)),
"File": reflect.ValueOf((*fs.File)(nil)),
"FileInfo": reflect.ValueOf((*fs.FileInfo)(nil)),
"FileMode": reflect.ValueOf((*fs.FileMode)(nil)),
"GlobFS": reflect.ValueOf((*fs.GlobFS)(nil)),
"PathError": reflect.ValueOf((*fs.PathError)(nil)),
"ReadDirFS": reflect.ValueOf((*fs.ReadDirFS)(nil)),
"ReadDirFile": reflect.ValueOf((*fs.ReadDirFile)(nil)),
"ReadFileFS": reflect.ValueOf((*fs.ReadFileFS)(nil)),
"StatFS": reflect.ValueOf((*fs.StatFS)(nil)),
"SubFS": reflect.ValueOf((*fs.SubFS)(nil)),
"WalkDirFunc": reflect.ValueOf((*fs.WalkDirFunc)(nil)),
// interface wrapper definitions
"_DirEntry": reflect.ValueOf((*_io_fs_DirEntry)(nil)),
"_FS": reflect.ValueOf((*_io_fs_FS)(nil)),
"_File": reflect.ValueOf((*_io_fs_File)(nil)),
"_FileInfo": reflect.ValueOf((*_io_fs_FileInfo)(nil)),
"_GlobFS": reflect.ValueOf((*_io_fs_GlobFS)(nil)),
"_ReadDirFS": reflect.ValueOf((*_io_fs_ReadDirFS)(nil)),
"_ReadDirFile": reflect.ValueOf((*_io_fs_ReadDirFile)(nil)),
"_ReadFileFS": reflect.ValueOf((*_io_fs_ReadFileFS)(nil)),
"_StatFS": reflect.ValueOf((*_io_fs_StatFS)(nil)),
"_SubFS": reflect.ValueOf((*_io_fs_SubFS)(nil)),
}
}
// _io_fs_DirEntry is an interface wrapper for DirEntry type
type _io_fs_DirEntry struct {
IValue interface{}
WInfo func() (fs.FileInfo, error)
WIsDir func() bool
WName func() string
WType func() fs.FileMode
}
func (W _io_fs_DirEntry) Info() (fs.FileInfo, error) { return W.WInfo() }
func (W _io_fs_DirEntry) IsDir() bool { return W.WIsDir() }
func (W _io_fs_DirEntry) Name() string { return W.WName() }
func (W _io_fs_DirEntry) Type() fs.FileMode { return W.WType() }
// _io_fs_FS is an interface wrapper for FS type
type _io_fs_FS struct {
IValue interface{}
WOpen func(name string) (fs.File, error)
}
func (W _io_fs_FS) Open(name string) (fs.File, error) { return W.WOpen(name) }
// _io_fs_File is an interface wrapper for File type
type _io_fs_File struct {
IValue interface{}
WClose func() error
WRead func(a0 []byte) (int, error)
WStat func() (fs.FileInfo, error)
}
func (W _io_fs_File) Close() error { return W.WClose() }
func (W _io_fs_File) Read(a0 []byte) (int, error) { return W.WRead(a0) }
func (W _io_fs_File) Stat() (fs.FileInfo, error) { return W.WStat() }
// _io_fs_FileInfo is an interface wrapper for FileInfo type
type _io_fs_FileInfo struct {
IValue interface{}
WIsDir func() bool
WModTime func() time.Time
WMode func() fs.FileMode
WName func() string
WSize func() int64
WSys func() any
}
func (W _io_fs_FileInfo) IsDir() bool { return W.WIsDir() }
func (W _io_fs_FileInfo) ModTime() time.Time { return W.WModTime() }
func (W _io_fs_FileInfo) Mode() fs.FileMode { return W.WMode() }
func (W _io_fs_FileInfo) Name() string { return W.WName() }
func (W _io_fs_FileInfo) Size() int64 { return W.WSize() }
func (W _io_fs_FileInfo) Sys() any { return W.WSys() }
// _io_fs_GlobFS is an interface wrapper for GlobFS type
type _io_fs_GlobFS struct {
IValue interface{}
WGlob func(pattern string) ([]string, error)
WOpen func(name string) (fs.File, error)
}
func (W _io_fs_GlobFS) Glob(pattern string) ([]string, error) { return W.WGlob(pattern) }
func (W _io_fs_GlobFS) Open(name string) (fs.File, error) { return W.WOpen(name) }
// _io_fs_ReadDirFS is an interface wrapper for ReadDirFS type
type _io_fs_ReadDirFS struct {
IValue interface{}
WOpen func(name string) (fs.File, error)
WReadDir func(name string) ([]fs.DirEntry, error)
}
func (W _io_fs_ReadDirFS) Open(name string) (fs.File, error) { return W.WOpen(name) }
func (W _io_fs_ReadDirFS) ReadDir(name string) ([]fs.DirEntry, error) { return W.WReadDir(name) }
// _io_fs_ReadDirFile is an interface wrapper for ReadDirFile type
type _io_fs_ReadDirFile struct {
IValue interface{}
WClose func() error
WRead func(a0 []byte) (int, error)
WReadDir func(n int) ([]fs.DirEntry, error)
WStat func() (fs.FileInfo, error)
}
func (W _io_fs_ReadDirFile) Close() error { return W.WClose() }
func (W _io_fs_ReadDirFile) Read(a0 []byte) (int, error) { return W.WRead(a0) }
func (W _io_fs_ReadDirFile) ReadDir(n int) ([]fs.DirEntry, error) { return W.WReadDir(n) }
func (W _io_fs_ReadDirFile) Stat() (fs.FileInfo, error) { return W.WStat() }
// _io_fs_ReadFileFS is an interface wrapper for ReadFileFS type
type _io_fs_ReadFileFS struct {
IValue interface{}
WOpen func(name string) (fs.File, error)
WReadFile func(name string) ([]byte, error)
}
func (W _io_fs_ReadFileFS) Open(name string) (fs.File, error) { return W.WOpen(name) }
func (W _io_fs_ReadFileFS) ReadFile(name string) ([]byte, error) { return W.WReadFile(name) }
// _io_fs_StatFS is an interface wrapper for StatFS type
type _io_fs_StatFS struct {
IValue interface{}
WOpen func(name string) (fs.File, error)
WStat func(name string) (fs.FileInfo, error)
}
func (W _io_fs_StatFS) Open(name string) (fs.File, error) { return W.WOpen(name) }
func (W _io_fs_StatFS) Stat(name string) (fs.FileInfo, error) { return W.WStat(name) }
// _io_fs_SubFS is an interface wrapper for SubFS type
type _io_fs_SubFS struct {
IValue interface{}
WOpen func(name string) (fs.File, error)
WSub func(dir string) (fs.FS, error)
}
func (W _io_fs_SubFS) Open(name string) (fs.File, error) { return W.WOpen(name) }
func (W _io_fs_SubFS) Sub(dir string) (fs.FS, error) { return W.WSub(dir) }
================================================
FILE: stdlib/go1_21_io_ioutil.go
================================================
// Code generated by 'yaegi extract io/ioutil'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"io/ioutil"
"reflect"
)
func init() {
Symbols["io/ioutil/ioutil"] = map[string]reflect.Value{
// function, constant and variable definitions
"Discard": reflect.ValueOf(&ioutil.Discard).Elem(),
"NopCloser": reflect.ValueOf(ioutil.NopCloser),
"ReadAll": reflect.ValueOf(ioutil.ReadAll),
"ReadDir": reflect.ValueOf(ioutil.ReadDir),
"ReadFile": reflect.ValueOf(ioutil.ReadFile),
"TempDir": reflect.ValueOf(ioutil.TempDir),
"TempFile": reflect.ValueOf(ioutil.TempFile),
"WriteFile": reflect.ValueOf(ioutil.WriteFile),
}
}
================================================
FILE: stdlib/go1_21_log.go
================================================
// Code generated by 'yaegi extract log'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"go/constant"
"go/token"
"log"
"reflect"
)
func init() {
Symbols["log/log"] = map[string]reflect.Value{
// function, constant and variable definitions
"Default": reflect.ValueOf(log.Default),
"Fatal": reflect.ValueOf(logFatal),
"Fatalf": reflect.ValueOf(logFatalf),
"Fatalln": reflect.ValueOf(logFatalln),
"Flags": reflect.ValueOf(log.Flags),
"LUTC": reflect.ValueOf(constant.MakeFromLiteral("32", token.INT, 0)),
"Ldate": reflect.ValueOf(constant.MakeFromLiteral("1", token.INT, 0)),
"Llongfile": reflect.ValueOf(constant.MakeFromLiteral("8", token.INT, 0)),
"Lmicroseconds": reflect.ValueOf(constant.MakeFromLiteral("4", token.INT, 0)),
"Lmsgprefix": reflect.ValueOf(constant.MakeFromLiteral("64", token.INT, 0)),
"Lshortfile": reflect.ValueOf(constant.MakeFromLiteral("16", token.INT, 0)),
"LstdFlags": reflect.ValueOf(constant.MakeFromLiteral("3", token.INT, 0)),
"Ltime": reflect.ValueOf(constant.MakeFromLiteral("2", token.INT, 0)),
"New": reflect.ValueOf(logNew),
"Output": reflect.ValueOf(log.Output),
"Panic": reflect.ValueOf(log.Panic),
"Panicf": reflect.ValueOf(log.Panicf),
"Panicln": reflect.ValueOf(log.Panicln),
"Prefix": reflect.ValueOf(log.Prefix),
"Print": reflect.ValueOf(log.Print),
"Printf": reflect.ValueOf(log.Printf),
"Println": reflect.ValueOf(log.Println),
"SetFlags": reflect.ValueOf(log.SetFlags),
"SetOutput": reflect.ValueOf(log.SetOutput),
"SetPrefix": reflect.ValueOf(log.SetPrefix),
"Writer": reflect.ValueOf(log.Writer),
// type definitions
"Logger": reflect.ValueOf((*logLogger)(nil)),
}
}
================================================
FILE: stdlib/go1_21_log_slog.go
================================================
// Code generated by 'yaegi extract log/slog'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"context"
"go/constant"
"go/token"
"log/slog"
"reflect"
)
func init() {
Symbols["log/slog/slog"] = map[string]reflect.Value{
// function, constant and variable definitions
"Any": reflect.ValueOf(slog.Any),
"AnyValue": reflect.ValueOf(slog.AnyValue),
"Bool": reflect.ValueOf(slog.Bool),
"BoolValue": reflect.ValueOf(slog.BoolValue),
"Debug": reflect.ValueOf(slog.Debug),
"DebugContext": reflect.ValueOf(slog.DebugContext),
"Default": reflect.ValueOf(slog.Default),
"Duration": reflect.ValueOf(slog.Duration),
"DurationValue": reflect.ValueOf(slog.DurationValue),
"Error": reflect.ValueOf(slog.Error),
"ErrorContext": reflect.ValueOf(slog.ErrorContext),
"Float64": reflect.ValueOf(slog.Float64),
"Float64Value": reflect.ValueOf(slog.Float64Value),
"Group": reflect.ValueOf(slog.Group),
"GroupValue": reflect.ValueOf(slog.GroupValue),
"Info": reflect.ValueOf(slog.Info),
"InfoContext": reflect.ValueOf(slog.InfoContext),
"Int": reflect.ValueOf(slog.Int),
"Int64": reflect.ValueOf(slog.Int64),
"Int64Value": reflect.ValueOf(slog.Int64Value),
"IntValue": reflect.ValueOf(slog.IntValue),
"KindAny": reflect.ValueOf(slog.KindAny),
"KindBool": reflect.ValueOf(slog.KindBool),
"KindDuration": reflect.ValueOf(slog.KindDuration),
"KindFloat64": reflect.ValueOf(slog.KindFloat64),
"KindGroup": reflect.ValueOf(slog.KindGroup),
"KindInt64": reflect.ValueOf(slog.KindInt64),
"KindLogValuer": reflect.ValueOf(slog.KindLogValuer),
"KindString": reflect.ValueOf(slog.KindString),
"KindTime": reflect.ValueOf(slog.KindTime),
"KindUint64": reflect.ValueOf(slog.KindUint64),
"LevelDebug": reflect.ValueOf(slog.LevelDebug),
"LevelError": reflect.ValueOf(slog.LevelError),
"LevelInfo": reflect.ValueOf(slog.LevelInfo),
"LevelKey": reflect.ValueOf(constant.MakeFromLiteral("\"level\"", token.STRING, 0)),
"LevelWarn": reflect.ValueOf(slog.LevelWarn),
"Log": reflect.ValueOf(slog.Log),
"LogAttrs": reflect.ValueOf(slog.LogAttrs),
"MessageKey": reflect.ValueOf(constant.MakeFromLiteral("\"msg\"", token.STRING, 0)),
"New": reflect.ValueOf(slog.New),
"NewJSONHandler": reflect.ValueOf(slog.NewJSONHandler),
"NewLogLogger": reflect.ValueOf(slog.NewLogLogger),
"NewRecord": reflect.ValueOf(slog.NewRecord),
"NewTextHandler": reflect.ValueOf(slog.NewTextHandler),
"SetDefault": reflect.ValueOf(slog.SetDefault),
"SourceKey": reflect.ValueOf(constant.MakeFromLiteral("\"source\"", token.STRING, 0)),
"String": reflect.ValueOf(slog.String),
"StringValue": reflect.ValueOf(slog.StringValue),
"Time": reflect.ValueOf(slog.Time),
"TimeKey": reflect.ValueOf(constant.MakeFromLiteral("\"time\"", token.STRING, 0)),
"TimeValue": reflect.ValueOf(slog.TimeValue),
"Uint64": reflect.ValueOf(slog.Uint64),
"Uint64Value": reflect.ValueOf(slog.Uint64Value),
"Warn": reflect.ValueOf(slog.Warn),
"WarnContext": reflect.ValueOf(slog.WarnContext),
"With": reflect.ValueOf(slog.With),
// type definitions
"Attr": reflect.ValueOf((*slog.Attr)(nil)),
"Handler": reflect.ValueOf((*slog.Handler)(nil)),
"HandlerOptions": reflect.ValueOf((*slog.HandlerOptions)(nil)),
"JSONHandler": reflect.ValueOf((*slog.JSONHandler)(nil)),
"Kind": reflect.ValueOf((*slog.Kind)(nil)),
"Level": reflect.ValueOf((*slog.Level)(nil)),
"LevelVar": reflect.ValueOf((*slog.LevelVar)(nil)),
"Leveler": reflect.ValueOf((*slog.Leveler)(nil)),
"LogValuer": reflect.ValueOf((*slog.LogValuer)(nil)),
"Logger": reflect.ValueOf((*slog.Logger)(nil)),
"Record": reflect.ValueOf((*slog.Record)(nil)),
"Source": reflect.ValueOf((*slog.Source)(nil)),
"TextHandler": reflect.ValueOf((*slog.TextHandler)(nil)),
"Value": reflect.ValueOf((*slog.Value)(nil)),
// interface wrapper definitions
"_Handler": reflect.ValueOf((*_log_slog_Handler)(nil)),
"_Leveler": reflect.ValueOf((*_log_slog_Leveler)(nil)),
"_LogValuer": reflect.ValueOf((*_log_slog_LogValuer)(nil)),
}
}
// _log_slog_Handler is an interface wrapper for Handler type
type _log_slog_Handler struct {
IValue interface{}
WEnabled func(a0 context.Context, a1 slog.Level) bool
WHandle func(a0 context.Context, a1 slog.Record) error
WWithAttrs func(attrs []slog.Attr) slog.Handler
WWithGroup func(name string) slog.Handler
}
func (W _log_slog_Handler) Enabled(a0 context.Context, a1 slog.Level) bool { return W.WEnabled(a0, a1) }
func (W _log_slog_Handler) Handle(a0 context.Context, a1 slog.Record) error { return W.WHandle(a0, a1) }
func (W _log_slog_Handler) WithAttrs(attrs []slog.Attr) slog.Handler { return W.WWithAttrs(attrs) }
func (W _log_slog_Handler) WithGroup(name string) slog.Handler { return W.WWithGroup(name) }
// _log_slog_Leveler is an interface wrapper for Leveler type
type _log_slog_Leveler struct {
IValue interface{}
WLevel func() slog.Level
}
func (W _log_slog_Leveler) Level() slog.Level { return W.WLevel() }
// _log_slog_LogValuer is an interface wrapper for LogValuer type
type _log_slog_LogValuer struct {
IValue interface{}
WLogValue func() slog.Value
}
func (W _log_slog_LogValuer) LogValue() slog.Value { return W.WLogValue() }
================================================
FILE: stdlib/go1_21_log_syslog.go
================================================
// Code generated by 'yaegi extract log/syslog'. DO NOT EDIT.
//go:build go1.21 && !go1.22 && !windows && !nacl && !plan9
// +build go1.21,!go1.22,!windows,!nacl,!plan9
package stdlib
import (
"log/syslog"
"reflect"
)
func init() {
Symbols["log/syslog/syslog"] = map[string]reflect.Value{
// function, constant and variable definitions
"Dial": reflect.ValueOf(syslog.Dial),
"LOG_ALERT": reflect.ValueOf(syslog.LOG_ALERT),
"LOG_AUTH": reflect.ValueOf(syslog.LOG_AUTH),
"LOG_AUTHPRIV": reflect.ValueOf(syslog.LOG_AUTHPRIV),
"LOG_CRIT": reflect.ValueOf(syslog.LOG_CRIT),
"LOG_CRON": reflect.ValueOf(syslog.LOG_CRON),
"LOG_DAEMON": reflect.ValueOf(syslog.LOG_DAEMON),
"LOG_DEBUG": reflect.ValueOf(syslog.LOG_DEBUG),
"LOG_EMERG": reflect.ValueOf(syslog.LOG_EMERG),
"LOG_ERR": reflect.ValueOf(syslog.LOG_ERR),
"LOG_FTP": reflect.ValueOf(syslog.LOG_FTP),
"LOG_INFO": reflect.ValueOf(syslog.LOG_INFO),
"LOG_KERN": reflect.ValueOf(syslog.LOG_KERN),
"LOG_LOCAL0": reflect.ValueOf(syslog.LOG_LOCAL0),
"LOG_LOCAL1": reflect.ValueOf(syslog.LOG_LOCAL1),
"LOG_LOCAL2": reflect.ValueOf(syslog.LOG_LOCAL2),
"LOG_LOCAL3": reflect.ValueOf(syslog.LOG_LOCAL3),
"LOG_LOCAL4": reflect.ValueOf(syslog.LOG_LOCAL4),
"LOG_LOCAL5": reflect.ValueOf(syslog.LOG_LOCAL5),
"LOG_LOCAL6": reflect.ValueOf(syslog.LOG_LOCAL6),
"LOG_LOCAL7": reflect.ValueOf(syslog.LOG_LOCAL7),
"LOG_LPR": reflect.ValueOf(syslog.LOG_LPR),
"LOG_MAIL": reflect.ValueOf(syslog.LOG_MAIL),
"LOG_NEWS": reflect.ValueOf(syslog.LOG_NEWS),
"LOG_NOTICE": reflect.ValueOf(syslog.LOG_NOTICE),
"LOG_SYSLOG": reflect.ValueOf(syslog.LOG_SYSLOG),
"LOG_USER": reflect.ValueOf(syslog.LOG_USER),
"LOG_UUCP": reflect.ValueOf(syslog.LOG_UUCP),
"LOG_WARNING": reflect.ValueOf(syslog.LOG_WARNING),
"New": reflect.ValueOf(syslog.New),
"NewLogger": reflect.ValueOf(syslog.NewLogger),
// type definitions
"Priority": reflect.ValueOf((*syslog.Priority)(nil)),
"Writer": reflect.ValueOf((*syslog.Writer)(nil)),
}
}
================================================
FILE: stdlib/go1_21_maps.go
================================================
// Code generated by 'yaegi extract maps'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"reflect"
)
func init() {
Symbols["maps/maps"] = map[string]reflect.Value{}
}
================================================
FILE: stdlib/go1_21_math.go
================================================
// Code generated by 'yaegi extract math'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"go/constant"
"go/token"
"math"
"reflect"
)
func init() {
Symbols["math/math"] = map[string]reflect.Value{
// function, constant and variable definitions
"Abs": reflect.ValueOf(math.Abs),
"Acos": reflect.ValueOf(math.Acos),
"Acosh": reflect.ValueOf(math.Acosh),
"Asin": reflect.ValueOf(math.Asin),
"Asinh": reflect.ValueOf(math.Asinh),
"Atan": reflect.ValueOf(math.Atan),
"Atan2": reflect.ValueOf(math.Atan2),
"Atanh": reflect.ValueOf(math.Atanh),
"Cbrt": reflect.ValueOf(math.Cbrt),
"Ceil": reflect.ValueOf(math.Ceil),
"Copysign": reflect.ValueOf(math.Copysign),
"Cos": reflect.ValueOf(math.Cos),
"Cosh": reflect.ValueOf(math.Cosh),
"Dim": reflect.ValueOf(math.Dim),
"E": reflect.ValueOf(constant.MakeFromLiteral("2.71828182845904523536028747135266249775724709369995957496696762566337824315673231520670375558666729784504486779277967997696994772644702281675346915668215131895555530285035761295375777990557253360748291015625", token.FLOAT, 0)),
"Erf": reflect.ValueOf(math.Erf),
"Erfc": reflect.ValueOf(math.Erfc),
"Erfcinv": reflect.ValueOf(math.Erfcinv),
"Erfinv": reflect.ValueOf(math.Erfinv),
"Exp": reflect.ValueOf(math.Exp),
"Exp2": reflect.ValueOf(math.Exp2),
"Expm1": reflect.ValueOf(math.Expm1),
"FMA": reflect.ValueOf(math.FMA),
"Float32bits": reflect.ValueOf(math.Float32bits),
"Float32frombits": reflect.ValueOf(math.Float32frombits),
"Float64bits": reflect.ValueOf(math.Float64bits),
"Float64frombits": reflect.ValueOf(math.Float64frombits),
"Floor": reflect.ValueOf(math.Floor),
"Frexp": reflect.ValueOf(math.Frexp),
"Gamma": reflect.ValueOf(math.Gamma),
"Hypot": reflect.ValueOf(math.Hypot),
"Ilogb": reflect.ValueOf(math.Ilogb),
"Inf": reflect.ValueOf(math.Inf),
"IsInf": reflect.ValueOf(math.IsInf),
"IsNaN": reflect.ValueOf(math.IsNaN),
"J0": reflect.ValueOf(math.J0),
"J1": reflect.ValueOf(math.J1),
"Jn": reflect.ValueOf(math.Jn),
"Ldexp": reflect.ValueOf(math.Ldexp),
"Lgamma": reflect.ValueOf(math.Lgamma),
"Ln10": reflect.ValueOf(constant.MakeFromLiteral("2.30258509299404568401799145468436420760110148862877297603332784146804725494827975466552490443295866962642372461496758838959542646932914211937012833592062802600362869664962772731087170541286468505859375", token.FLOAT, 0)),
"Ln2": reflect.ValueOf(constant.MakeFromLiteral("0.6931471805599453094172321214581765680755001343602552541206800092715999496201383079363438206637927920954189307729314303884387720696314608777673678644642390655170150035209453154294578780536539852619171142578125", token.FLOAT, 0)),
"Log": reflect.ValueOf(math.Log),
"Log10": reflect.ValueOf(math.Log10),
"Log10E": reflect.ValueOf(constant.MakeFromLiteral("0.43429448190325182765112891891660508229439700580366656611445378416636798190620320263064286300825210972160277489744884502676719847561509639618196799746596688688378591625127711495224502868950366973876953125", token.FLOAT, 0)),
"Log1p": reflect.ValueOf(math.Log1p),
"Log2": reflect.ValueOf(math.Log2),
"Log2E": reflect.ValueOf(constant.MakeFromLiteral("1.44269504088896340735992468100189213742664595415298593413544940772066427768997545329060870636212628972710992130324953463427359402479619301286929040235571747101382214539290471666532766903401352465152740478515625", token.FLOAT, 0)),
"Logb": reflect.ValueOf(math.Logb),
"Max": reflect.ValueOf(math.Max),
"MaxFloat32": reflect.ValueOf(constant.MakeFromLiteral("340282346638528859811704183484516925440", token.FLOAT, 0)),
"MaxFloat64": reflect.ValueOf(constant.MakeFromLiteral("179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368", token.FLOAT, 0)),
"MaxInt": reflect.ValueOf(constant.MakeFromLiteral("9223372036854775807", token.INT, 0)),
"MaxInt16": reflect.ValueOf(constant.MakeFromLiteral("32767", token.INT, 0)),
"MaxInt32": reflect.ValueOf(constant.MakeFromLiteral("2147483647", token.INT, 0)),
"MaxInt64": reflect.ValueOf(constant.MakeFromLiteral("9223372036854775807", token.INT, 0)),
"MaxInt8": reflect.ValueOf(constant.MakeFromLiteral("127", token.INT, 0)),
"MaxUint": reflect.ValueOf(constant.MakeFromLiteral("18446744073709551615", token.INT, 0)),
"MaxUint16": reflect.ValueOf(constant.MakeFromLiteral("65535", token.INT, 0)),
"MaxUint32": reflect.ValueOf(constant.MakeFromLiteral("4294967295", token.INT, 0)),
"MaxUint64": reflect.ValueOf(constant.MakeFromLiteral("18446744073709551615", token.INT, 0)),
"MaxUint8": reflect.ValueOf(constant.MakeFromLiteral("255", token.INT, 0)),
"Min": reflect.ValueOf(math.Min),
"MinInt": reflect.ValueOf(constant.MakeFromLiteral("-9223372036854775808", token.INT, 0)),
"MinInt16": reflect.ValueOf(constant.MakeFromLiteral("-32768", token.INT, 0)),
"MinInt32": reflect.ValueOf(constant.MakeFromLiteral("-2147483648", token.INT, 0)),
"MinInt64": reflect.ValueOf(constant.MakeFromLiteral("-9223372036854775808", token.INT, 0)),
"MinInt8": reflect.ValueOf(constant.MakeFromLiteral("-128", token.INT, 0)),
"Mod": reflect.ValueOf(math.Mod),
"Modf": reflect.ValueOf(math.Modf),
"NaN": reflect.ValueOf(math.NaN),
"Nextafter": reflect.ValueOf(math.Nextafter),
"Nextafter32": reflect.ValueOf(math.Nextafter32),
"Phi": reflect.ValueOf(constant.MakeFromLiteral("1.6180339887498948482045868343656381177203091798057628621354486119746080982153796619881086049305501566952211682590824739205931370737029882996587050475921915678674035433959321750307935872115194797515869140625", token.FLOAT, 0)),
"Pi": reflect.ValueOf(constant.MakeFromLiteral("3.141592653589793238462643383279502884197169399375105820974944594789982923695635954704435713335896673485663389728754819466702315787113662862838515639906529162340867271374644786874341662041842937469482421875", token.FLOAT, 0)),
"Pow": reflect.ValueOf(math.Pow),
"Pow10": reflect.ValueOf(math.Pow10),
"Remainder": reflect.ValueOf(math.Remainder),
"Round": reflect.ValueOf(math.Round),
"RoundToEven": reflect.ValueOf(math.RoundToEven),
"Signbit": reflect.ValueOf(math.Signbit),
"Sin": reflect.ValueOf(math.Sin),
"Sincos": reflect.ValueOf(math.Sincos),
"Sinh": reflect.ValueOf(math.Sinh),
"SmallestNonzeroFloat32": reflect.ValueOf(constant.MakeFromLiteral("1.40129846432481707092372958328991613128026194187651577175706828388979108268586060148663818836212158203125e-45", token.FLOAT, 0)),
"SmallestNonzeroFloat64": reflect.ValueOf(constant.MakeFromLiteral("4.940656458412465441765687928682213723650598026143247644255856825006755072702087518652998363616359923797965646954457177309266567103559397963987747960107818781263007131903114045278458171678489821036887186360569987307230500063874091535649843873124733972731696151400317153853980741262385655911710266585566867681870395603106249319452715914924553293054565444011274801297099995419319894090804165633245247571478690147267801593552386115501348035264934720193790268107107491703332226844753335720832431936092382893458368060106011506169809753078342277318329247904982524730776375927247874656084778203734469699533647017972677717585125660551199131504891101451037862738167250955837389733598993664809941164205702637090279242767544565229087538682506419718265533447265625e-324", token.FLOAT, 0)),
"Sqrt": reflect.ValueOf(math.Sqrt),
"Sqrt2": reflect.ValueOf(constant.MakeFromLiteral("1.414213562373095048801688724209698078569671875376948073176679739576083351575381440094441524123797447886801949755143139115339040409162552642832693297721230919563348109313505318596071447245776653289794921875", token.FLOAT, 0)),
"SqrtE": reflect.ValueOf(constant.MakeFromLiteral("1.64872127070012814684865078781416357165377610071014801157507931167328763229187870850146925823776361770041160388013884200789716007979526823569827080974091691342077871211546646890155898290686309337615966796875", token.FLOAT, 0)),
"SqrtPhi": reflect.ValueOf(constant.MakeFromLiteral("1.2720196495140689642524224617374914917156080418400962486166403754616080542166459302584536396369727769747312116100875915825863540562126478288118732191412003988041797518382391984914647764526307582855224609375", token.FLOAT, 0)),
"SqrtPi": reflect.ValueOf(constant.MakeFromLiteral("1.772453850905516027298167483341145182797549456122387128213807789740599698370237052541269446184448945647349951047154197675245574635259260134350885938555625028620527962319730619356050738133490085601806640625", token.FLOAT, 0)),
"Tan": reflect.ValueOf(math.Tan),
"Tanh": reflect.ValueOf(math.Tanh),
"Trunc": reflect.ValueOf(math.Trunc),
"Y0": reflect.ValueOf(math.Y0),
"Y1": reflect.ValueOf(math.Y1),
"Yn": reflect.ValueOf(math.Yn),
}
}
================================================
FILE: stdlib/go1_21_math_big.go
================================================
// Code generated by 'yaegi extract math/big'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"go/constant"
"go/token"
"math/big"
"reflect"
)
func init() {
Symbols["math/big/big"] = map[string]reflect.Value{
// function, constant and variable definitions
"Above": reflect.ValueOf(big.Above),
"AwayFromZero": reflect.ValueOf(big.AwayFromZero),
"Below": reflect.ValueOf(big.Below),
"Exact": reflect.ValueOf(big.Exact),
"Jacobi": reflect.ValueOf(big.Jacobi),
"MaxBase": reflect.ValueOf(constant.MakeFromLiteral("62", token.INT, 0)),
"MaxExp": reflect.ValueOf(constant.MakeFromLiteral("2147483647", token.INT, 0)),
"MaxPrec": reflect.ValueOf(constant.MakeFromLiteral("4294967295", token.INT, 0)),
"MinExp": reflect.ValueOf(constant.MakeFromLiteral("-2147483648", token.INT, 0)),
"NewFloat": reflect.ValueOf(big.NewFloat),
"NewInt": reflect.ValueOf(big.NewInt),
"NewRat": reflect.ValueOf(big.NewRat),
"ParseFloat": reflect.ValueOf(big.ParseFloat),
"ToNearestAway": reflect.ValueOf(big.ToNearestAway),
"ToNearestEven": reflect.ValueOf(big.ToNearestEven),
"ToNegativeInf": reflect.ValueOf(big.ToNegativeInf),
"ToPositiveInf": reflect.ValueOf(big.ToPositiveInf),
"ToZero": reflect.ValueOf(big.ToZero),
// type definitions
"Accuracy": reflect.ValueOf((*big.Accuracy)(nil)),
"ErrNaN": reflect.ValueOf((*big.ErrNaN)(nil)),
"Float": reflect.ValueOf((*big.Float)(nil)),
"Int": reflect.ValueOf((*big.Int)(nil)),
"Rat": reflect.ValueOf((*big.Rat)(nil)),
"RoundingMode": reflect.ValueOf((*big.RoundingMode)(nil)),
"Word": reflect.ValueOf((*big.Word)(nil)),
}
}
================================================
FILE: stdlib/go1_21_math_bits.go
================================================
// Code generated by 'yaegi extract math/bits'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"go/constant"
"go/token"
"math/bits"
"reflect"
)
func init() {
Symbols["math/bits/bits"] = map[string]reflect.Value{
// function, constant and variable definitions
"Add": reflect.ValueOf(bits.Add),
"Add32": reflect.ValueOf(bits.Add32),
"Add64": reflect.ValueOf(bits.Add64),
"Div": reflect.ValueOf(bits.Div),
"Div32": reflect.ValueOf(bits.Div32),
"Div64": reflect.ValueOf(bits.Div64),
"LeadingZeros": reflect.ValueOf(bits.LeadingZeros),
"LeadingZeros16": reflect.ValueOf(bits.LeadingZeros16),
"LeadingZeros32": reflect.ValueOf(bits.LeadingZeros32),
"LeadingZeros64": reflect.ValueOf(bits.LeadingZeros64),
"LeadingZeros8": reflect.ValueOf(bits.LeadingZeros8),
"Len": reflect.ValueOf(bits.Len),
"Len16": reflect.ValueOf(bits.Len16),
"Len32": reflect.ValueOf(bits.Len32),
"Len64": reflect.ValueOf(bits.Len64),
"Len8": reflect.ValueOf(bits.Len8),
"Mul": reflect.ValueOf(bits.Mul),
"Mul32": reflect.ValueOf(bits.Mul32),
"Mul64": reflect.ValueOf(bits.Mul64),
"OnesCount": reflect.ValueOf(bits.OnesCount),
"OnesCount16": reflect.ValueOf(bits.OnesCount16),
"OnesCount32": reflect.ValueOf(bits.OnesCount32),
"OnesCount64": reflect.ValueOf(bits.OnesCount64),
"OnesCount8": reflect.ValueOf(bits.OnesCount8),
"Rem": reflect.ValueOf(bits.Rem),
"Rem32": reflect.ValueOf(bits.Rem32),
"Rem64": reflect.ValueOf(bits.Rem64),
"Reverse": reflect.ValueOf(bits.Reverse),
"Reverse16": reflect.ValueOf(bits.Reverse16),
"Reverse32": reflect.ValueOf(bits.Reverse32),
"Reverse64": reflect.ValueOf(bits.Reverse64),
"Reverse8": reflect.ValueOf(bits.Reverse8),
"ReverseBytes": reflect.ValueOf(bits.ReverseBytes),
"ReverseBytes16": reflect.ValueOf(bits.ReverseBytes16),
"ReverseBytes32": reflect.ValueOf(bits.ReverseBytes32),
"ReverseBytes64": reflect.ValueOf(bits.ReverseBytes64),
"RotateLeft": reflect.ValueOf(bits.RotateLeft),
"RotateLeft16": reflect.ValueOf(bits.RotateLeft16),
"RotateLeft32": reflect.ValueOf(bits.RotateLeft32),
"RotateLeft64": reflect.ValueOf(bits.RotateLeft64),
"RotateLeft8": reflect.ValueOf(bits.RotateLeft8),
"Sub": reflect.ValueOf(bits.Sub),
"Sub32": reflect.ValueOf(bits.Sub32),
"Sub64": reflect.ValueOf(bits.Sub64),
"TrailingZeros": reflect.ValueOf(bits.TrailingZeros),
"TrailingZeros16": reflect.ValueOf(bits.TrailingZeros16),
"TrailingZeros32": reflect.ValueOf(bits.TrailingZeros32),
"TrailingZeros64": reflect.ValueOf(bits.TrailingZeros64),
"TrailingZeros8": reflect.ValueOf(bits.TrailingZeros8),
"UintSize": reflect.ValueOf(constant.MakeFromLiteral("64", token.INT, 0)),
}
}
================================================
FILE: stdlib/go1_21_math_cmplx.go
================================================
// Code generated by 'yaegi extract math/cmplx'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"math/cmplx"
"reflect"
)
func init() {
Symbols["math/cmplx/cmplx"] = map[string]reflect.Value{
// function, constant and variable definitions
"Abs": reflect.ValueOf(cmplx.Abs),
"Acos": reflect.ValueOf(cmplx.Acos),
"Acosh": reflect.ValueOf(cmplx.Acosh),
"Asin": reflect.ValueOf(cmplx.Asin),
"Asinh": reflect.ValueOf(cmplx.Asinh),
"Atan": reflect.ValueOf(cmplx.Atan),
"Atanh": reflect.ValueOf(cmplx.Atanh),
"Conj": reflect.ValueOf(cmplx.Conj),
"Cos": reflect.ValueOf(cmplx.Cos),
"Cosh": reflect.ValueOf(cmplx.Cosh),
"Cot": reflect.ValueOf(cmplx.Cot),
"Exp": reflect.ValueOf(cmplx.Exp),
"Inf": reflect.ValueOf(cmplx.Inf),
"IsInf": reflect.ValueOf(cmplx.IsInf),
"IsNaN": reflect.ValueOf(cmplx.IsNaN),
"Log": reflect.ValueOf(cmplx.Log),
"Log10": reflect.ValueOf(cmplx.Log10),
"NaN": reflect.ValueOf(cmplx.NaN),
"Phase": reflect.ValueOf(cmplx.Phase),
"Polar": reflect.ValueOf(cmplx.Polar),
"Pow": reflect.ValueOf(cmplx.Pow),
"Rect": reflect.ValueOf(cmplx.Rect),
"Sin": reflect.ValueOf(cmplx.Sin),
"Sinh": reflect.ValueOf(cmplx.Sinh),
"Sqrt": reflect.ValueOf(cmplx.Sqrt),
"Tan": reflect.ValueOf(cmplx.Tan),
"Tanh": reflect.ValueOf(cmplx.Tanh),
}
}
================================================
FILE: stdlib/go1_21_math_rand.go
================================================
// Code generated by 'yaegi extract math/rand'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"math/rand"
"reflect"
)
func init() {
Symbols["math/rand/rand"] = map[string]reflect.Value{
// function, constant and variable definitions
"ExpFloat64": reflect.ValueOf(rand.ExpFloat64),
"Float32": reflect.ValueOf(rand.Float32),
"Float64": reflect.ValueOf(rand.Float64),
"Int": reflect.ValueOf(rand.Int),
"Int31": reflect.ValueOf(rand.Int31),
"Int31n": reflect.ValueOf(rand.Int31n),
"Int63": reflect.ValueOf(rand.Int63),
"Int63n": reflect.ValueOf(rand.Int63n),
"Intn": reflect.ValueOf(rand.Intn),
"New": reflect.ValueOf(rand.New),
"NewSource": reflect.ValueOf(rand.NewSource),
"NewZipf": reflect.ValueOf(rand.NewZipf),
"NormFloat64": reflect.ValueOf(rand.NormFloat64),
"Perm": reflect.ValueOf(rand.Perm),
"Read": reflect.ValueOf(rand.Read),
"Seed": reflect.ValueOf(rand.Seed),
"Shuffle": reflect.ValueOf(rand.Shuffle),
"Uint32": reflect.ValueOf(rand.Uint32),
"Uint64": reflect.ValueOf(rand.Uint64),
// type definitions
"Rand": reflect.ValueOf((*rand.Rand)(nil)),
"Source": reflect.ValueOf((*rand.Source)(nil)),
"Source64": reflect.ValueOf((*rand.Source64)(nil)),
"Zipf": reflect.ValueOf((*rand.Zipf)(nil)),
// interface wrapper definitions
"_Source": reflect.ValueOf((*_math_rand_Source)(nil)),
"_Source64": reflect.ValueOf((*_math_rand_Source64)(nil)),
}
}
// _math_rand_Source is an interface wrapper for Source type
type _math_rand_Source struct {
IValue interface{}
WInt63 func() int64
WSeed func(seed int64)
}
func (W _math_rand_Source) Int63() int64 { return W.WInt63() }
func (W _math_rand_Source) Seed(seed int64) { W.WSeed(seed) }
// _math_rand_Source64 is an interface wrapper for Source64 type
type _math_rand_Source64 struct {
IValue interface{}
WInt63 func() int64
WSeed func(seed int64)
WUint64 func() uint64
}
func (W _math_rand_Source64) Int63() int64 { return W.WInt63() }
func (W _math_rand_Source64) Seed(seed int64) { W.WSeed(seed) }
func (W _math_rand_Source64) Uint64() uint64 { return W.WUint64() }
================================================
FILE: stdlib/go1_21_mime.go
================================================
// Code generated by 'yaegi extract mime'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"mime"
"reflect"
)
func init() {
Symbols["mime/mime"] = map[string]reflect.Value{
// function, constant and variable definitions
"AddExtensionType": reflect.ValueOf(mime.AddExtensionType),
"BEncoding": reflect.ValueOf(mime.BEncoding),
"ErrInvalidMediaParameter": reflect.ValueOf(&mime.ErrInvalidMediaParameter).Elem(),
"ExtensionsByType": reflect.ValueOf(mime.ExtensionsByType),
"FormatMediaType": reflect.ValueOf(mime.FormatMediaType),
"ParseMediaType": reflect.ValueOf(mime.ParseMediaType),
"QEncoding": reflect.ValueOf(mime.QEncoding),
"TypeByExtension": reflect.ValueOf(mime.TypeByExtension),
// type definitions
"WordDecoder": reflect.ValueOf((*mime.WordDecoder)(nil)),
"WordEncoder": reflect.ValueOf((*mime.WordEncoder)(nil)),
}
}
================================================
FILE: stdlib/go1_21_mime_multipart.go
================================================
// Code generated by 'yaegi extract mime/multipart'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"mime/multipart"
"reflect"
)
func init() {
Symbols["mime/multipart/multipart"] = map[string]reflect.Value{
// function, constant and variable definitions
"ErrMessageTooLarge": reflect.ValueOf(&multipart.ErrMessageTooLarge).Elem(),
"NewReader": reflect.ValueOf(multipart.NewReader),
"NewWriter": reflect.ValueOf(multipart.NewWriter),
// type definitions
"File": reflect.ValueOf((*multipart.File)(nil)),
"FileHeader": reflect.ValueOf((*multipart.FileHeader)(nil)),
"Form": reflect.ValueOf((*multipart.Form)(nil)),
"Part": reflect.ValueOf((*multipart.Part)(nil)),
"Reader": reflect.ValueOf((*multipart.Reader)(nil)),
"Writer": reflect.ValueOf((*multipart.Writer)(nil)),
// interface wrapper definitions
"_File": reflect.ValueOf((*_mime_multipart_File)(nil)),
}
}
// _mime_multipart_File is an interface wrapper for File type
type _mime_multipart_File struct {
IValue interface{}
WClose func() error
WRead func(p []byte) (n int, err error)
WReadAt func(p []byte, off int64) (n int, err error)
WSeek func(offset int64, whence int) (int64, error)
}
func (W _mime_multipart_File) Close() error { return W.WClose() }
func (W _mime_multipart_File) Read(p []byte) (n int, err error) { return W.WRead(p) }
func (W _mime_multipart_File) ReadAt(p []byte, off int64) (n int, err error) {
return W.WReadAt(p, off)
}
func (W _mime_multipart_File) Seek(offset int64, whence int) (int64, error) {
return W.WSeek(offset, whence)
}
================================================
FILE: stdlib/go1_21_mime_quotedprintable.go
================================================
// Code generated by 'yaegi extract mime/quotedprintable'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"mime/quotedprintable"
"reflect"
)
func init() {
Symbols["mime/quotedprintable/quotedprintable"] = map[string]reflect.Value{
// function, constant and variable definitions
"NewReader": reflect.ValueOf(quotedprintable.NewReader),
"NewWriter": reflect.ValueOf(quotedprintable.NewWriter),
// type definitions
"Reader": reflect.ValueOf((*quotedprintable.Reader)(nil)),
"Writer": reflect.ValueOf((*quotedprintable.Writer)(nil)),
}
}
================================================
FILE: stdlib/go1_21_net.go
================================================
// Code generated by 'yaegi extract net'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"go/constant"
"go/token"
"net"
"reflect"
"time"
)
func init() {
Symbols["net/net"] = map[string]reflect.Value{
// function, constant and variable definitions
"CIDRMask": reflect.ValueOf(net.CIDRMask),
"DefaultResolver": reflect.ValueOf(&net.DefaultResolver).Elem(),
"Dial": reflect.ValueOf(net.Dial),
"DialIP": reflect.ValueOf(net.DialIP),
"DialTCP": reflect.ValueOf(net.DialTCP),
"DialTimeout": reflect.ValueOf(net.DialTimeout),
"DialUDP": reflect.ValueOf(net.DialUDP),
"DialUnix": reflect.ValueOf(net.DialUnix),
"ErrClosed": reflect.ValueOf(&net.ErrClosed).Elem(),
"ErrWriteToConnected": reflect.ValueOf(&net.ErrWriteToConnected).Elem(),
"FileConn": reflect.ValueOf(net.FileConn),
"FileListener": reflect.ValueOf(net.FileListener),
"FilePacketConn": reflect.ValueOf(net.FilePacketConn),
"FlagBroadcast": reflect.ValueOf(net.FlagBroadcast),
"FlagLoopback": reflect.ValueOf(net.FlagLoopback),
"FlagMulticast": reflect.ValueOf(net.FlagMulticast),
"FlagPointToPoint": reflect.ValueOf(net.FlagPointToPoint),
"FlagRunning": reflect.ValueOf(net.FlagRunning),
"FlagUp": reflect.ValueOf(net.FlagUp),
"IPv4": reflect.ValueOf(net.IPv4),
"IPv4Mask": reflect.ValueOf(net.IPv4Mask),
"IPv4allrouter": reflect.ValueOf(&net.IPv4allrouter).Elem(),
"IPv4allsys": reflect.ValueOf(&net.IPv4allsys).Elem(),
"IPv4bcast": reflect.ValueOf(&net.IPv4bcast).Elem(),
"IPv4len": reflect.ValueOf(constant.MakeFromLiteral("4", token.INT, 0)),
"IPv4zero": reflect.ValueOf(&net.IPv4zero).Elem(),
"IPv6interfacelocalallnodes": reflect.ValueOf(&net.IPv6interfacelocalallnodes).Elem(),
"IPv6len": reflect.ValueOf(constant.MakeFromLiteral("16", token.INT, 0)),
"IPv6linklocalallnodes": reflect.ValueOf(&net.IPv6linklocalallnodes).Elem(),
"IPv6linklocalallrouters": reflect.ValueOf(&net.IPv6linklocalallrouters).Elem(),
"IPv6loopback": reflect.ValueOf(&net.IPv6loopback).Elem(),
"IPv6unspecified": reflect.ValueOf(&net.IPv6unspecified).Elem(),
"IPv6zero": reflect.ValueOf(&net.IPv6zero).Elem(),
"InterfaceAddrs": reflect.ValueOf(net.InterfaceAddrs),
"InterfaceByIndex": reflect.ValueOf(net.InterfaceByIndex),
"InterfaceByName": reflect.ValueOf(net.InterfaceByName),
"Interfaces": reflect.ValueOf(net.Interfaces),
"JoinHostPort": reflect.ValueOf(net.JoinHostPort),
"Listen": reflect.ValueOf(net.Listen),
"ListenIP": reflect.ValueOf(net.ListenIP),
"ListenMulticastUDP": reflect.ValueOf(net.ListenMulticastUDP),
"ListenPacket": reflect.ValueOf(net.ListenPacket),
"ListenTCP": reflect.ValueOf(net.ListenTCP),
"ListenUDP": reflect.ValueOf(net.ListenUDP),
"ListenUnix": reflect.ValueOf(net.ListenUnix),
"ListenUnixgram": reflect.ValueOf(net.ListenUnixgram),
"LookupAddr": reflect.ValueOf(net.LookupAddr),
"LookupCNAME": reflect.ValueOf(net.LookupCNAME),
"LookupHost": reflect.ValueOf(net.LookupHost),
"LookupIP": reflect.ValueOf(net.LookupIP),
"LookupMX": reflect.ValueOf(net.LookupMX),
"LookupNS": reflect.ValueOf(net.LookupNS),
"LookupPort": reflect.ValueOf(net.LookupPort),
"LookupSRV": reflect.ValueOf(net.LookupSRV),
"LookupTXT": reflect.ValueOf(net.LookupTXT),
"ParseCIDR": reflect.ValueOf(net.ParseCIDR),
"ParseIP": reflect.ValueOf(net.ParseIP),
"ParseMAC": reflect.ValueOf(net.ParseMAC),
"Pipe": reflect.ValueOf(net.Pipe),
"ResolveIPAddr": reflect.ValueOf(net.ResolveIPAddr),
"ResolveTCPAddr": reflect.ValueOf(net.ResolveTCPAddr),
"ResolveUDPAddr": reflect.ValueOf(net.ResolveUDPAddr),
"ResolveUnixAddr": reflect.ValueOf(net.ResolveUnixAddr),
"SplitHostPort": reflect.ValueOf(net.SplitHostPort),
"TCPAddrFromAddrPort": reflect.ValueOf(net.TCPAddrFromAddrPort),
"UDPAddrFromAddrPort": reflect.ValueOf(net.UDPAddrFromAddrPort),
// type definitions
"Addr": reflect.ValueOf((*net.Addr)(nil)),
"AddrError": reflect.ValueOf((*net.AddrError)(nil)),
"Buffers": reflect.ValueOf((*net.Buffers)(nil)),
"Conn": reflect.ValueOf((*net.Conn)(nil)),
"DNSConfigError": reflect.ValueOf((*net.DNSConfigError)(nil)),
"DNSError": reflect.ValueOf((*net.DNSError)(nil)),
"Dialer": reflect.ValueOf((*net.Dialer)(nil)),
"Error": reflect.ValueOf((*net.Error)(nil)),
"Flags": reflect.ValueOf((*net.Flags)(nil)),
"HardwareAddr": reflect.ValueOf((*net.HardwareAddr)(nil)),
"IP": reflect.ValueOf((*net.IP)(nil)),
"IPAddr": reflect.ValueOf((*net.IPAddr)(nil)),
"IPConn": reflect.ValueOf((*net.IPConn)(nil)),
"IPMask": reflect.ValueOf((*net.IPMask)(nil)),
"IPNet": reflect.ValueOf((*net.IPNet)(nil)),
"Interface": reflect.ValueOf((*net.Interface)(nil)),
"InvalidAddrError": reflect.ValueOf((*net.InvalidAddrError)(nil)),
"ListenConfig": reflect.ValueOf((*net.ListenConfig)(nil)),
"Listener": reflect.ValueOf((*net.Listener)(nil)),
"MX": reflect.ValueOf((*net.MX)(nil)),
"NS": reflect.ValueOf((*net.NS)(nil)),
"OpError": reflect.ValueOf((*net.OpError)(nil)),
"PacketConn": reflect.ValueOf((*net.PacketConn)(nil)),
"ParseError": reflect.ValueOf((*net.ParseError)(nil)),
"Resolver": reflect.ValueOf((*net.Resolver)(nil)),
"SRV": reflect.ValueOf((*net.SRV)(nil)),
"TCPAddr": reflect.ValueOf((*net.TCPAddr)(nil)),
"TCPConn": reflect.ValueOf((*net.TCPConn)(nil)),
"TCPListener": reflect.ValueOf((*net.TCPListener)(nil)),
"UDPAddr": reflect.ValueOf((*net.UDPAddr)(nil)),
"UDPConn": reflect.ValueOf((*net.UDPConn)(nil)),
"UnixAddr": reflect.ValueOf((*net.UnixAddr)(nil)),
"UnixConn": reflect.ValueOf((*net.UnixConn)(nil)),
"UnixListener": reflect.ValueOf((*net.UnixListener)(nil)),
"UnknownNetworkError": reflect.ValueOf((*net.UnknownNetworkError)(nil)),
// interface wrapper definitions
"_Addr": reflect.ValueOf((*_net_Addr)(nil)),
"_Conn": reflect.ValueOf((*_net_Conn)(nil)),
"_Error": reflect.ValueOf((*_net_Error)(nil)),
"_Listener": reflect.ValueOf((*_net_Listener)(nil)),
"_PacketConn": reflect.ValueOf((*_net_PacketConn)(nil)),
}
}
// _net_Addr is an interface wrapper for Addr type
type _net_Addr struct {
IValue interface{}
WNetwork func() string
WString func() string
}
func (W _net_Addr) Network() string { return W.WNetwork() }
func (W _net_Addr) String() string {
if W.WString == nil {
return ""
}
return W.WString()
}
// _net_Conn is an interface wrapper for Conn type
type _net_Conn struct {
IValue interface{}
WClose func() error
WLocalAddr func() net.Addr
WRead func(b []byte) (n int, err error)
WRemoteAddr func() net.Addr
WSetDeadline func(t time.Time) error
WSetReadDeadline func(t time.Time) error
WSetWriteDeadline func(t time.Time) error
WWrite func(b []byte) (n int, err error)
}
func (W _net_Conn) Close() error { return W.WClose() }
func (W _net_Conn) LocalAddr() net.Addr { return W.WLocalAddr() }
func (W _net_Conn) Read(b []byte) (n int, err error) { return W.WRead(b) }
func (W _net_Conn) RemoteAddr() net.Addr { return W.WRemoteAddr() }
func (W _net_Conn) SetDeadline(t time.Time) error { return W.WSetDeadline(t) }
func (W _net_Conn) SetReadDeadline(t time.Time) error { return W.WSetReadDeadline(t) }
func (W _net_Conn) SetWriteDeadline(t time.Time) error { return W.WSetWriteDeadline(t) }
func (W _net_Conn) Write(b []byte) (n int, err error) { return W.WWrite(b) }
// _net_Error is an interface wrapper for Error type
type _net_Error struct {
IValue interface{}
WError func() string
WTemporary func() bool
WTimeout func() bool
}
func (W _net_Error) Error() string { return W.WError() }
func (W _net_Error) Temporary() bool { return W.WTemporary() }
func (W _net_Error) Timeout() bool { return W.WTimeout() }
// _net_Listener is an interface wrapper for Listener type
type _net_Listener struct {
IValue interface{}
WAccept func() (net.Conn, error)
WAddr func() net.Addr
WClose func() error
}
func (W _net_Listener) Accept() (net.Conn, error) { return W.WAccept() }
func (W _net_Listener) Addr() net.Addr { return W.WAddr() }
func (W _net_Listener) Close() error { return W.WClose() }
// _net_PacketConn is an interface wrapper for PacketConn type
type _net_PacketConn struct {
IValue interface{}
WClose func() error
WLocalAddr func() net.Addr
WReadFrom func(p []byte) (n int, addr net.Addr, err error)
WSetDeadline func(t time.Time) error
WSetReadDeadline func(t time.Time) error
WSetWriteDeadline func(t time.Time) error
WWriteTo func(p []byte, addr net.Addr) (n int, err error)
}
func (W _net_PacketConn) Close() error { return W.WClose() }
func (W _net_PacketConn) LocalAddr() net.Addr { return W.WLocalAddr() }
func (W _net_PacketConn) ReadFrom(p []byte) (n int, addr net.Addr, err error) { return W.WReadFrom(p) }
func (W _net_PacketConn) SetDeadline(t time.Time) error { return W.WSetDeadline(t) }
func (W _net_PacketConn) SetReadDeadline(t time.Time) error { return W.WSetReadDeadline(t) }
func (W _net_PacketConn) SetWriteDeadline(t time.Time) error { return W.WSetWriteDeadline(t) }
func (W _net_PacketConn) WriteTo(p []byte, addr net.Addr) (n int, err error) {
return W.WWriteTo(p, addr)
}
================================================
FILE: stdlib/go1_21_net_http.go
================================================
// Code generated by 'yaegi extract net/http'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"bufio"
"go/constant"
"go/token"
"io/fs"
"net"
"net/http"
"net/url"
"reflect"
)
func init() {
Symbols["net/http/http"] = map[string]reflect.Value{
// function, constant and variable definitions
"AllowQuerySemicolons": reflect.ValueOf(http.AllowQuerySemicolons),
"CanonicalHeaderKey": reflect.ValueOf(http.CanonicalHeaderKey),
"DefaultClient": reflect.ValueOf(&http.DefaultClient).Elem(),
"DefaultMaxHeaderBytes": reflect.ValueOf(constant.MakeFromLiteral("1048576", token.INT, 0)),
"DefaultMaxIdleConnsPerHost": reflect.ValueOf(constant.MakeFromLiteral("2", token.INT, 0)),
"DefaultServeMux": reflect.ValueOf(&http.DefaultServeMux).Elem(),
"DefaultTransport": reflect.ValueOf(&http.DefaultTransport).Elem(),
"DetectContentType": reflect.ValueOf(http.DetectContentType),
"ErrAbortHandler": reflect.ValueOf(&http.ErrAbortHandler).Elem(),
"ErrBodyNotAllowed": reflect.ValueOf(&http.ErrBodyNotAllowed).Elem(),
"ErrBodyReadAfterClose": reflect.ValueOf(&http.ErrBodyReadAfterClose).Elem(),
"ErrContentLength": reflect.ValueOf(&http.ErrContentLength).Elem(),
"ErrHandlerTimeout": reflect.ValueOf(&http.ErrHandlerTimeout).Elem(),
"ErrHeaderTooLong": reflect.ValueOf(&http.ErrHeaderTooLong).Elem(),
"ErrHijacked": reflect.ValueOf(&http.ErrHijacked).Elem(),
"ErrLineTooLong": reflect.ValueOf(&http.ErrLineTooLong).Elem(),
"ErrMissingBoundary": reflect.ValueOf(&http.ErrMissingBoundary).Elem(),
"ErrMissingContentLength": reflect.ValueOf(&http.ErrMissingContentLength).Elem(),
"ErrMissingFile": reflect.ValueOf(&http.ErrMissingFile).Elem(),
"ErrNoCookie": reflect.ValueOf(&http.ErrNoCookie).Elem(),
"ErrNoLocation": reflect.ValueOf(&http.ErrNoLocation).Elem(),
"ErrNotMultipart": reflect.ValueOf(&http.ErrNotMultipart).Elem(),
"ErrNotSupported": reflect.ValueOf(&http.ErrNotSupported).Elem(),
"ErrSchemeMismatch": reflect.ValueOf(&http.ErrSchemeMismatch).Elem(),
"ErrServerClosed": reflect.ValueOf(&http.ErrServerClosed).Elem(),
"ErrShortBody": reflect.ValueOf(&http.ErrShortBody).Elem(),
"ErrSkipAltProtocol": reflect.ValueOf(&http.ErrSkipAltProtocol).Elem(),
"ErrUnexpectedTrailer": reflect.ValueOf(&http.ErrUnexpectedTrailer).Elem(),
"ErrUseLastResponse": reflect.ValueOf(&http.ErrUseLastResponse).Elem(),
"ErrWriteAfterFlush": reflect.ValueOf(&http.ErrWriteAfterFlush).Elem(),
"Error": reflect.ValueOf(http.Error),
"FS": reflect.ValueOf(http.FS),
"FileServer": reflect.ValueOf(http.FileServer),
"Get": reflect.ValueOf(http.Get),
"Handle": reflect.ValueOf(http.Handle),
"HandleFunc": reflect.ValueOf(http.HandleFunc),
"Head": reflect.ValueOf(http.Head),
"ListenAndServe": reflect.ValueOf(http.ListenAndServe),
"ListenAndServeTLS": reflect.ValueOf(http.ListenAndServeTLS),
"LocalAddrContextKey": reflect.ValueOf(&http.LocalAddrContextKey).Elem(),
"MaxBytesHandler": reflect.ValueOf(http.MaxBytesHandler),
"MaxBytesReader": reflect.ValueOf(http.MaxBytesReader),
"MethodConnect": reflect.ValueOf(constant.MakeFromLiteral("\"CONNECT\"", token.STRING, 0)),
"MethodDelete": reflect.ValueOf(constant.MakeFromLiteral("\"DELETE\"", token.STRING, 0)),
"MethodGet": reflect.ValueOf(constant.MakeFromLiteral("\"GET\"", token.STRING, 0)),
"MethodHead": reflect.ValueOf(constant.MakeFromLiteral("\"HEAD\"", token.STRING, 0)),
"MethodOptions": reflect.ValueOf(constant.MakeFromLiteral("\"OPTIONS\"", token.STRING, 0)),
"MethodPatch": reflect.ValueOf(constant.MakeFromLiteral("\"PATCH\"", token.STRING, 0)),
"MethodPost": reflect.ValueOf(constant.MakeFromLiteral("\"POST\"", token.STRING, 0)),
"MethodPut": reflect.ValueOf(constant.MakeFromLiteral("\"PUT\"", token.STRING, 0)),
"MethodTrace": reflect.ValueOf(constant.MakeFromLiteral("\"TRACE\"", token.STRING, 0)),
"NewFileTransport": reflect.ValueOf(http.NewFileTransport),
"NewRequest": reflect.ValueOf(http.NewRequest),
"NewRequestWithContext": reflect.ValueOf(http.NewRequestWithContext),
"NewResponseController": reflect.ValueOf(http.NewResponseController),
"NewServeMux": reflect.ValueOf(http.NewServeMux),
"NoBody": reflect.ValueOf(&http.NoBody).Elem(),
"NotFound": reflect.ValueOf(http.NotFound),
"NotFoundHandler": reflect.ValueOf(http.NotFoundHandler),
"ParseHTTPVersion": reflect.ValueOf(http.ParseHTTPVersion),
"ParseTime": reflect.ValueOf(http.ParseTime),
"Post": reflect.ValueOf(http.Post),
"PostForm": reflect.ValueOf(http.PostForm),
"ProxyFromEnvironment": reflect.ValueOf(http.ProxyFromEnvironment),
"ProxyURL": reflect.ValueOf(http.ProxyURL),
"ReadRequest": reflect.ValueOf(http.ReadRequest),
"ReadResponse": reflect.ValueOf(http.ReadResponse),
"Redirect": reflect.ValueOf(http.Redirect),
"RedirectHandler": reflect.ValueOf(http.RedirectHandler),
"SameSiteDefaultMode": reflect.ValueOf(http.SameSiteDefaultMode),
"SameSiteLaxMode": reflect.ValueOf(http.SameSiteLaxMode),
"SameSiteNoneMode": reflect.ValueOf(http.SameSiteNoneMode),
"SameSiteStrictMode": reflect.ValueOf(http.SameSiteStrictMode),
"Serve": reflect.ValueOf(http.Serve),
"ServeContent": reflect.ValueOf(http.ServeContent),
"ServeFile": reflect.ValueOf(http.ServeFile),
"ServeTLS": reflect.ValueOf(http.ServeTLS),
"ServerContextKey": reflect.ValueOf(&http.ServerContextKey).Elem(),
"SetCookie": reflect.ValueOf(http.SetCookie),
"StateActive": reflect.ValueOf(http.StateActive),
"StateClosed": reflect.ValueOf(http.StateClosed),
"StateHijacked": reflect.ValueOf(http.StateHijacked),
"StateIdle": reflect.ValueOf(http.StateIdle),
"StateNew": reflect.ValueOf(http.StateNew),
"StatusAccepted": reflect.ValueOf(constant.MakeFromLiteral("202", token.INT, 0)),
"StatusAlreadyReported": reflect.ValueOf(constant.MakeFromLiteral("208", token.INT, 0)),
"StatusBadGateway": reflect.ValueOf(constant.MakeFromLiteral("502", token.INT, 0)),
"StatusBadRequest": reflect.ValueOf(constant.MakeFromLiteral("400", token.INT, 0)),
"StatusConflict": reflect.ValueOf(constant.MakeFromLiteral("409", token.INT, 0)),
"StatusContinue": reflect.ValueOf(constant.MakeFromLiteral("100", token.INT, 0)),
"StatusCreated": reflect.ValueOf(constant.MakeFromLiteral("201", token.INT, 0)),
"StatusEarlyHints": reflect.ValueOf(constant.MakeFromLiteral("103", token.INT, 0)),
"StatusExpectationFailed": reflect.ValueOf(constant.MakeFromLiteral("417", token.INT, 0)),
"StatusFailedDependency": reflect.ValueOf(constant.MakeFromLiteral("424", token.INT, 0)),
"StatusForbidden": reflect.ValueOf(constant.MakeFromLiteral("403", token.INT, 0)),
"StatusFound": reflect.ValueOf(constant.MakeFromLiteral("302", token.INT, 0)),
"StatusGatewayTimeout": reflect.ValueOf(constant.MakeFromLiteral("504", token.INT, 0)),
"StatusGone": reflect.ValueOf(constant.MakeFromLiteral("410", token.INT, 0)),
"StatusHTTPVersionNotSupported": reflect.ValueOf(constant.MakeFromLiteral("505", token.INT, 0)),
"StatusIMUsed": reflect.ValueOf(constant.MakeFromLiteral("226", token.INT, 0)),
"StatusInsufficientStorage": reflect.ValueOf(constant.MakeFromLiteral("507", token.INT, 0)),
"StatusInternalServerError": reflect.ValueOf(constant.MakeFromLiteral("500", token.INT, 0)),
"StatusLengthRequired": reflect.ValueOf(constant.MakeFromLiteral("411", token.INT, 0)),
"StatusLocked": reflect.ValueOf(constant.MakeFromLiteral("423", token.INT, 0)),
"StatusLoopDetected": reflect.ValueOf(constant.MakeFromLiteral("508", token.INT, 0)),
"StatusMethodNotAllowed": reflect.ValueOf(constant.MakeFromLiteral("405", token.INT, 0)),
"StatusMisdirectedRequest": reflect.ValueOf(constant.MakeFromLiteral("421", token.INT, 0)),
"StatusMovedPermanently": reflect.ValueOf(constant.MakeFromLiteral("301", token.INT, 0)),
"StatusMultiStatus": reflect.ValueOf(constant.MakeFromLiteral("207", token.INT, 0)),
"StatusMultipleChoices": reflect.ValueOf(constant.MakeFromLiteral("300", token.INT, 0)),
"StatusNetworkAuthenticationRequired": reflect.ValueOf(constant.MakeFromLiteral("511", token.INT, 0)),
"StatusNoContent": reflect.ValueOf(constant.MakeFromLiteral("204", token.INT, 0)),
"StatusNonAuthoritativeInfo": reflect.ValueOf(constant.MakeFromLiteral("203", token.INT, 0)),
"StatusNotAcceptable": reflect.ValueOf(constant.MakeFromLiteral("406", token.INT, 0)),
"StatusNotExtended": reflect.ValueOf(constant.MakeFromLiteral("510", token.INT, 0)),
"StatusNotFound": reflect.ValueOf(constant.MakeFromLiteral("404", token.INT, 0)),
"StatusNotImplemented": reflect.ValueOf(constant.MakeFromLiteral("501", token.INT, 0)),
"StatusNotModified": reflect.ValueOf(constant.MakeFromLiteral("304", token.INT, 0)),
"StatusOK": reflect.ValueOf(constant.MakeFromLiteral("200", token.INT, 0)),
"StatusPartialContent": reflect.ValueOf(constant.MakeFromLiteral("206", token.INT, 0)),
"StatusPaymentRequired": reflect.ValueOf(constant.MakeFromLiteral("402", token.INT, 0)),
"StatusPermanentRedirect": reflect.ValueOf(constant.MakeFromLiteral("308", token.INT, 0)),
"StatusPreconditionFailed": reflect.ValueOf(constant.MakeFromLiteral("412", token.INT, 0)),
"StatusPreconditionRequired": reflect.ValueOf(constant.MakeFromLiteral("428", token.INT, 0)),
"StatusProcessing": reflect.ValueOf(constant.MakeFromLiteral("102", token.INT, 0)),
"StatusProxyAuthRequired": reflect.ValueOf(constant.MakeFromLiteral("407", token.INT, 0)),
"StatusRequestEntityTooLarge": reflect.ValueOf(constant.MakeFromLiteral("413", token.INT, 0)),
"StatusRequestHeaderFieldsTooLarge": reflect.ValueOf(constant.MakeFromLiteral("431", token.INT, 0)),
"StatusRequestTimeout": reflect.ValueOf(constant.MakeFromLiteral("408", token.INT, 0)),
"StatusRequestURITooLong": reflect.ValueOf(constant.MakeFromLiteral("414", token.INT, 0)),
"StatusRequestedRangeNotSatisfiable": reflect.ValueOf(constant.MakeFromLiteral("416", token.INT, 0)),
"StatusResetContent": reflect.ValueOf(constant.MakeFromLiteral("205", token.INT, 0)),
"StatusSeeOther": reflect.ValueOf(constant.MakeFromLiteral("303", token.INT, 0)),
"StatusServiceUnavailable": reflect.ValueOf(constant.MakeFromLiteral("503", token.INT, 0)),
"StatusSwitchingProtocols": reflect.ValueOf(constant.MakeFromLiteral("101", token.INT, 0)),
"StatusTeapot": reflect.ValueOf(constant.MakeFromLiteral("418", token.INT, 0)),
"StatusTemporaryRedirect": reflect.ValueOf(constant.MakeFromLiteral("307", token.INT, 0)),
"StatusText": reflect.ValueOf(http.StatusText),
"StatusTooEarly": reflect.ValueOf(constant.MakeFromLiteral("425", token.INT, 0)),
"StatusTooManyRequests": reflect.ValueOf(constant.MakeFromLiteral("429", token.INT, 0)),
"StatusUnauthorized": reflect.ValueOf(constant.MakeFromLiteral("401", token.INT, 0)),
"StatusUnavailableForLegalReasons": reflect.ValueOf(constant.MakeFromLiteral("451", token.INT, 0)),
"StatusUnprocessableEntity": reflect.ValueOf(constant.MakeFromLiteral("422", token.INT, 0)),
"StatusUnsupportedMediaType": reflect.ValueOf(constant.MakeFromLiteral("415", token.INT, 0)),
"StatusUpgradeRequired": reflect.ValueOf(constant.MakeFromLiteral("426", token.INT, 0)),
"StatusUseProxy": reflect.ValueOf(constant.MakeFromLiteral("305", token.INT, 0)),
"StatusVariantAlsoNegotiates": reflect.ValueOf(constant.MakeFromLiteral("506", token.INT, 0)),
"StripPrefix": reflect.ValueOf(http.StripPrefix),
"TimeFormat": reflect.ValueOf(constant.MakeFromLiteral("\"Mon, 02 Jan 2006 15:04:05 GMT\"", token.STRING, 0)),
"TimeoutHandler": reflect.ValueOf(http.TimeoutHandler),
"TrailerPrefix": reflect.ValueOf(constant.MakeFromLiteral("\"Trailer:\"", token.STRING, 0)),
// type definitions
"Client": reflect.ValueOf((*http.Client)(nil)),
"CloseNotifier": reflect.ValueOf((*http.CloseNotifier)(nil)),
"ConnState": reflect.ValueOf((*http.ConnState)(nil)),
"Cookie": reflect.ValueOf((*http.Cookie)(nil)),
"CookieJar": reflect.ValueOf((*http.CookieJar)(nil)),
"Dir": reflect.ValueOf((*http.Dir)(nil)),
"File": reflect.ValueOf((*http.File)(nil)),
"FileSystem": reflect.ValueOf((*http.FileSystem)(nil)),
"Flusher": reflect.ValueOf((*http.Flusher)(nil)),
"Handler": reflect.ValueOf((*http.Handler)(nil)),
"HandlerFunc": reflect.ValueOf((*http.HandlerFunc)(nil)),
"Header": reflect.ValueOf((*http.Header)(nil)),
"Hijacker": reflect.ValueOf((*http.Hijacker)(nil)),
"MaxBytesError": reflect.ValueOf((*http.MaxBytesError)(nil)),
"ProtocolError": reflect.ValueOf((*http.ProtocolError)(nil)),
"PushOptions": reflect.ValueOf((*http.PushOptions)(nil)),
"Pusher": reflect.ValueOf((*http.Pusher)(nil)),
"Request": reflect.ValueOf((*http.Request)(nil)),
"Response": reflect.ValueOf((*http.Response)(nil)),
"ResponseController": reflect.ValueOf((*http.ResponseController)(nil)),
"ResponseWriter": reflect.ValueOf((*http.ResponseWriter)(nil)),
"RoundTripper": reflect.ValueOf((*http.RoundTripper)(nil)),
"SameSite": reflect.ValueOf((*http.SameSite)(nil)),
"ServeMux": reflect.ValueOf((*http.ServeMux)(nil)),
"Server": reflect.ValueOf((*http.Server)(nil)),
"Transport": reflect.ValueOf((*http.Transport)(nil)),
// interface wrapper definitions
"_CloseNotifier": reflect.ValueOf((*_net_http_CloseNotifier)(nil)),
"_CookieJar": reflect.ValueOf((*_net_http_CookieJar)(nil)),
"_File": reflect.ValueOf((*_net_http_File)(nil)),
"_FileSystem": reflect.ValueOf((*_net_http_FileSystem)(nil)),
"_Flusher": reflect.ValueOf((*_net_http_Flusher)(nil)),
"_Handler": reflect.ValueOf((*_net_http_Handler)(nil)),
"_Hijacker": reflect.ValueOf((*_net_http_Hijacker)(nil)),
"_Pusher": reflect.ValueOf((*_net_http_Pusher)(nil)),
"_ResponseWriter": reflect.ValueOf((*_net_http_ResponseWriter)(nil)),
"_RoundTripper": reflect.ValueOf((*_net_http_RoundTripper)(nil)),
}
}
// _net_http_CloseNotifier is an interface wrapper for CloseNotifier type
type _net_http_CloseNotifier struct {
IValue interface{}
WCloseNotify func() <-chan bool
}
func (W _net_http_CloseNotifier) CloseNotify() <-chan bool { return W.WCloseNotify() }
// _net_http_CookieJar is an interface wrapper for CookieJar type
type _net_http_CookieJar struct {
IValue interface{}
WCookies func(u *url.URL) []*http.Cookie
WSetCookies func(u *url.URL, cookies []*http.Cookie)
}
func (W _net_http_CookieJar) Cookies(u *url.URL) []*http.Cookie { return W.WCookies(u) }
func (W _net_http_CookieJar) SetCookies(u *url.URL, cookies []*http.Cookie) {
W.WSetCookies(u, cookies)
}
// _net_http_File is an interface wrapper for File type
type _net_http_File struct {
IValue interface{}
WClose func() error
WRead func(p []byte) (n int, err error)
WReaddir func(count int) ([]fs.FileInfo, error)
WSeek func(offset int64, whence int) (int64, error)
WStat func() (fs.FileInfo, error)
}
func (W _net_http_File) Close() error { return W.WClose() }
func (W _net_http_File) Read(p []byte) (n int, err error) { return W.WRead(p) }
func (W _net_http_File) Readdir(count int) ([]fs.FileInfo, error) { return W.WReaddir(count) }
func (W _net_http_File) Seek(offset int64, whence int) (int64, error) { return W.WSeek(offset, whence) }
func (W _net_http_File) Stat() (fs.FileInfo, error) { return W.WStat() }
// _net_http_FileSystem is an interface wrapper for FileSystem type
type _net_http_FileSystem struct {
IValue interface{}
WOpen func(name string) (http.File, error)
}
func (W _net_http_FileSystem) Open(name string) (http.File, error) { return W.WOpen(name) }
// _net_http_Flusher is an interface wrapper for Flusher type
type _net_http_Flusher struct {
IValue interface{}
WFlush func()
}
func (W _net_http_Flusher) Flush() { W.WFlush() }
// _net_http_Handler is an interface wrapper for Handler type
type _net_http_Handler struct {
IValue interface{}
WServeHTTP func(a0 http.ResponseWriter, a1 *http.Request)
}
func (W _net_http_Handler) ServeHTTP(a0 http.ResponseWriter, a1 *http.Request) { W.WServeHTTP(a0, a1) }
// _net_http_Hijacker is an interface wrapper for Hijacker type
type _net_http_Hijacker struct {
IValue interface{}
WHijack func() (net.Conn, *bufio.ReadWriter, error)
}
func (W _net_http_Hijacker) Hijack() (net.Conn, *bufio.ReadWriter, error) { return W.WHijack() }
// _net_http_Pusher is an interface wrapper for Pusher type
type _net_http_Pusher struct {
IValue interface{}
WPush func(target string, opts *http.PushOptions) error
}
func (W _net_http_Pusher) Push(target string, opts *http.PushOptions) error {
return W.WPush(target, opts)
}
// _net_http_ResponseWriter is an interface wrapper for ResponseWriter type
type _net_http_ResponseWriter struct {
IValue interface{}
WHeader func() http.Header
WWrite func(a0 []byte) (int, error)
WWriteHeader func(statusCode int)
}
func (W _net_http_ResponseWriter) Header() http.Header { return W.WHeader() }
func (W _net_http_ResponseWriter) Write(a0 []byte) (int, error) { return W.WWrite(a0) }
func (W _net_http_ResponseWriter) WriteHeader(statusCode int) { W.WWriteHeader(statusCode) }
// _net_http_RoundTripper is an interface wrapper for RoundTripper type
type _net_http_RoundTripper struct {
IValue interface{}
WRoundTrip func(a0 *http.Request) (*http.Response, error)
}
func (W _net_http_RoundTripper) RoundTrip(a0 *http.Request) (*http.Response, error) {
return W.WRoundTrip(a0)
}
================================================
FILE: stdlib/go1_21_net_http_cgi.go
================================================
// Code generated by 'yaegi extract net/http/cgi'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"net/http/cgi"
"reflect"
)
func init() {
Symbols["net/http/cgi/cgi"] = map[string]reflect.Value{
// function, constant and variable definitions
"Request": reflect.ValueOf(cgi.Request),
"RequestFromMap": reflect.ValueOf(cgi.RequestFromMap),
"Serve": reflect.ValueOf(cgi.Serve),
// type definitions
"Handler": reflect.ValueOf((*cgi.Handler)(nil)),
}
}
================================================
FILE: stdlib/go1_21_net_http_cookiejar.go
================================================
// Code generated by 'yaegi extract net/http/cookiejar'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"net/http/cookiejar"
"reflect"
)
func init() {
Symbols["net/http/cookiejar/cookiejar"] = map[string]reflect.Value{
// function, constant and variable definitions
"New": reflect.ValueOf(cookiejar.New),
// type definitions
"Jar": reflect.ValueOf((*cookiejar.Jar)(nil)),
"Options": reflect.ValueOf((*cookiejar.Options)(nil)),
"PublicSuffixList": reflect.ValueOf((*cookiejar.PublicSuffixList)(nil)),
// interface wrapper definitions
"_PublicSuffixList": reflect.ValueOf((*_net_http_cookiejar_PublicSuffixList)(nil)),
}
}
// _net_http_cookiejar_PublicSuffixList is an interface wrapper for PublicSuffixList type
type _net_http_cookiejar_PublicSuffixList struct {
IValue interface{}
WPublicSuffix func(domain string) string
WString func() string
}
func (W _net_http_cookiejar_PublicSuffixList) PublicSuffix(domain string) string {
return W.WPublicSuffix(domain)
}
func (W _net_http_cookiejar_PublicSuffixList) String() string {
if W.WString == nil {
return ""
}
return W.WString()
}
================================================
FILE: stdlib/go1_21_net_http_fcgi.go
================================================
// Code generated by 'yaegi extract net/http/fcgi'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"net/http/fcgi"
"reflect"
)
func init() {
Symbols["net/http/fcgi/fcgi"] = map[string]reflect.Value{
// function, constant and variable definitions
"ErrConnClosed": reflect.ValueOf(&fcgi.ErrConnClosed).Elem(),
"ErrRequestAborted": reflect.ValueOf(&fcgi.ErrRequestAborted).Elem(),
"ProcessEnv": reflect.ValueOf(fcgi.ProcessEnv),
"Serve": reflect.ValueOf(fcgi.Serve),
}
}
================================================
FILE: stdlib/go1_21_net_http_httptest.go
================================================
// Code generated by 'yaegi extract net/http/httptest'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"go/constant"
"go/token"
"net/http/httptest"
"reflect"
)
func init() {
Symbols["net/http/httptest/httptest"] = map[string]reflect.Value{
// function, constant and variable definitions
"DefaultRemoteAddr": reflect.ValueOf(constant.MakeFromLiteral("\"1.2.3.4\"", token.STRING, 0)),
"NewRecorder": reflect.ValueOf(httptest.NewRecorder),
"NewRequest": reflect.ValueOf(httptest.NewRequest),
"NewServer": reflect.ValueOf(httptest.NewServer),
"NewTLSServer": reflect.ValueOf(httptest.NewTLSServer),
"NewUnstartedServer": reflect.ValueOf(httptest.NewUnstartedServer),
// type definitions
"ResponseRecorder": reflect.ValueOf((*httptest.ResponseRecorder)(nil)),
"Server": reflect.ValueOf((*httptest.Server)(nil)),
}
}
================================================
FILE: stdlib/go1_21_net_http_httptrace.go
================================================
// Code generated by 'yaegi extract net/http/httptrace'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"net/http/httptrace"
"reflect"
)
func init() {
Symbols["net/http/httptrace/httptrace"] = map[string]reflect.Value{
// function, constant and variable definitions
"ContextClientTrace": reflect.ValueOf(httptrace.ContextClientTrace),
"WithClientTrace": reflect.ValueOf(httptrace.WithClientTrace),
// type definitions
"ClientTrace": reflect.ValueOf((*httptrace.ClientTrace)(nil)),
"DNSDoneInfo": reflect.ValueOf((*httptrace.DNSDoneInfo)(nil)),
"DNSStartInfo": reflect.ValueOf((*httptrace.DNSStartInfo)(nil)),
"GotConnInfo": reflect.ValueOf((*httptrace.GotConnInfo)(nil)),
"WroteRequestInfo": reflect.ValueOf((*httptrace.WroteRequestInfo)(nil)),
}
}
================================================
FILE: stdlib/go1_21_net_http_httputil.go
================================================
// Code generated by 'yaegi extract net/http/httputil'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"net/http/httputil"
"reflect"
)
func init() {
Symbols["net/http/httputil/httputil"] = map[string]reflect.Value{
// function, constant and variable definitions
"DumpRequest": reflect.ValueOf(httputil.DumpRequest),
"DumpRequestOut": reflect.ValueOf(httputil.DumpRequestOut),
"DumpResponse": reflect.ValueOf(httputil.DumpResponse),
"ErrClosed": reflect.ValueOf(&httputil.ErrClosed).Elem(),
"ErrLineTooLong": reflect.ValueOf(&httputil.ErrLineTooLong).Elem(),
"ErrPersistEOF": reflect.ValueOf(&httputil.ErrPersistEOF).Elem(),
"ErrPipeline": reflect.ValueOf(&httputil.ErrPipeline).Elem(),
"NewChunkedReader": reflect.ValueOf(httputil.NewChunkedReader),
"NewChunkedWriter": reflect.ValueOf(httputil.NewChunkedWriter),
"NewClientConn": reflect.ValueOf(httputil.NewClientConn),
"NewProxyClientConn": reflect.ValueOf(httputil.NewProxyClientConn),
"NewServerConn": reflect.ValueOf(httputil.NewServerConn),
"NewSingleHostReverseProxy": reflect.ValueOf(httputil.NewSingleHostReverseProxy),
// type definitions
"BufferPool": reflect.ValueOf((*httputil.BufferPool)(nil)),
"ClientConn": reflect.ValueOf((*httputil.ClientConn)(nil)),
"ProxyRequest": reflect.ValueOf((*httputil.ProxyRequest)(nil)),
"ReverseProxy": reflect.ValueOf((*httputil.ReverseProxy)(nil)),
"ServerConn": reflect.ValueOf((*httputil.ServerConn)(nil)),
// interface wrapper definitions
"_BufferPool": reflect.ValueOf((*_net_http_httputil_BufferPool)(nil)),
}
}
// _net_http_httputil_BufferPool is an interface wrapper for BufferPool type
type _net_http_httputil_BufferPool struct {
IValue interface{}
WGet func() []byte
WPut func(a0 []byte)
}
func (W _net_http_httputil_BufferPool) Get() []byte { return W.WGet() }
func (W _net_http_httputil_BufferPool) Put(a0 []byte) { W.WPut(a0) }
================================================
FILE: stdlib/go1_21_net_http_pprof.go
================================================
// Code generated by 'yaegi extract net/http/pprof'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"net/http/pprof"
"reflect"
)
func init() {
Symbols["net/http/pprof/pprof"] = map[string]reflect.Value{
// function, constant and variable definitions
"Cmdline": reflect.ValueOf(pprof.Cmdline),
"Handler": reflect.ValueOf(pprof.Handler),
"Index": reflect.ValueOf(pprof.Index),
"Profile": reflect.ValueOf(pprof.Profile),
"Symbol": reflect.ValueOf(pprof.Symbol),
"Trace": reflect.ValueOf(pprof.Trace),
}
}
================================================
FILE: stdlib/go1_21_net_mail.go
================================================
// Code generated by 'yaegi extract net/mail'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"net/mail"
"reflect"
)
func init() {
Symbols["net/mail/mail"] = map[string]reflect.Value{
// function, constant and variable definitions
"ErrHeaderNotPresent": reflect.ValueOf(&mail.ErrHeaderNotPresent).Elem(),
"ParseAddress": reflect.ValueOf(mail.ParseAddress),
"ParseAddressList": reflect.ValueOf(mail.ParseAddressList),
"ParseDate": reflect.ValueOf(mail.ParseDate),
"ReadMessage": reflect.ValueOf(mail.ReadMessage),
// type definitions
"Address": reflect.ValueOf((*mail.Address)(nil)),
"AddressParser": reflect.ValueOf((*mail.AddressParser)(nil)),
"Header": reflect.ValueOf((*mail.Header)(nil)),
"Message": reflect.ValueOf((*mail.Message)(nil)),
}
}
================================================
FILE: stdlib/go1_21_net_netip.go
================================================
// Code generated by 'yaegi extract net/netip'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"net/netip"
"reflect"
)
func init() {
Symbols["net/netip/netip"] = map[string]reflect.Value{
// function, constant and variable definitions
"AddrFrom16": reflect.ValueOf(netip.AddrFrom16),
"AddrFrom4": reflect.ValueOf(netip.AddrFrom4),
"AddrFromSlice": reflect.ValueOf(netip.AddrFromSlice),
"AddrPortFrom": reflect.ValueOf(netip.AddrPortFrom),
"IPv4Unspecified": reflect.ValueOf(netip.IPv4Unspecified),
"IPv6LinkLocalAllNodes": reflect.ValueOf(netip.IPv6LinkLocalAllNodes),
"IPv6LinkLocalAllRouters": reflect.ValueOf(netip.IPv6LinkLocalAllRouters),
"IPv6Loopback": reflect.ValueOf(netip.IPv6Loopback),
"IPv6Unspecified": reflect.ValueOf(netip.IPv6Unspecified),
"MustParseAddr": reflect.ValueOf(netip.MustParseAddr),
"MustParseAddrPort": reflect.ValueOf(netip.MustParseAddrPort),
"MustParsePrefix": reflect.ValueOf(netip.MustParsePrefix),
"ParseAddr": reflect.ValueOf(netip.ParseAddr),
"ParseAddrPort": reflect.ValueOf(netip.ParseAddrPort),
"ParsePrefix": reflect.ValueOf(netip.ParsePrefix),
"PrefixFrom": reflect.ValueOf(netip.PrefixFrom),
// type definitions
"Addr": reflect.ValueOf((*netip.Addr)(nil)),
"AddrPort": reflect.ValueOf((*netip.AddrPort)(nil)),
"Prefix": reflect.ValueOf((*netip.Prefix)(nil)),
}
}
================================================
FILE: stdlib/go1_21_net_rpc.go
================================================
// Code generated by 'yaegi extract net/rpc'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"go/constant"
"go/token"
"net/rpc"
"reflect"
)
func init() {
Symbols["net/rpc/rpc"] = map[string]reflect.Value{
// function, constant and variable definitions
"Accept": reflect.ValueOf(rpc.Accept),
"DefaultDebugPath": reflect.ValueOf(constant.MakeFromLiteral("\"/debug/rpc\"", token.STRING, 0)),
"DefaultRPCPath": reflect.ValueOf(constant.MakeFromLiteral("\"/_goRPC_\"", token.STRING, 0)),
"DefaultServer": reflect.ValueOf(&rpc.DefaultServer).Elem(),
"Dial": reflect.ValueOf(rpc.Dial),
"DialHTTP": reflect.ValueOf(rpc.DialHTTP),
"DialHTTPPath": reflect.ValueOf(rpc.DialHTTPPath),
"ErrShutdown": reflect.ValueOf(&rpc.ErrShutdown).Elem(),
"HandleHTTP": reflect.ValueOf(rpc.HandleHTTP),
"NewClient": reflect.ValueOf(rpc.NewClient),
"NewClientWithCodec": reflect.ValueOf(rpc.NewClientWithCodec),
"NewServer": reflect.ValueOf(rpc.NewServer),
"Register": reflect.ValueOf(rpc.Register),
"RegisterName": reflect.ValueOf(rpc.RegisterName),
"ServeCodec": reflect.ValueOf(rpc.ServeCodec),
"ServeConn": reflect.ValueOf(rpc.ServeConn),
"ServeRequest": reflect.ValueOf(rpc.ServeRequest),
// type definitions
"Call": reflect.ValueOf((*rpc.Call)(nil)),
"Client": reflect.ValueOf((*rpc.Client)(nil)),
"ClientCodec": reflect.ValueOf((*rpc.ClientCodec)(nil)),
"Request": reflect.ValueOf((*rpc.Request)(nil)),
"Response": reflect.ValueOf((*rpc.Response)(nil)),
"Server": reflect.ValueOf((*rpc.Server)(nil)),
"ServerCodec": reflect.ValueOf((*rpc.ServerCodec)(nil)),
"ServerError": reflect.ValueOf((*rpc.ServerError)(nil)),
// interface wrapper definitions
"_ClientCodec": reflect.ValueOf((*_net_rpc_ClientCodec)(nil)),
"_ServerCodec": reflect.ValueOf((*_net_rpc_ServerCodec)(nil)),
}
}
// _net_rpc_ClientCodec is an interface wrapper for ClientCodec type
type _net_rpc_ClientCodec struct {
IValue interface{}
WClose func() error
WReadResponseBody func(a0 any) error
WReadResponseHeader func(a0 *rpc.Response) error
WWriteRequest func(a0 *rpc.Request, a1 any) error
}
func (W _net_rpc_ClientCodec) Close() error { return W.WClose() }
func (W _net_rpc_ClientCodec) ReadResponseBody(a0 any) error { return W.WReadResponseBody(a0) }
func (W _net_rpc_ClientCodec) ReadResponseHeader(a0 *rpc.Response) error {
return W.WReadResponseHeader(a0)
}
func (W _net_rpc_ClientCodec) WriteRequest(a0 *rpc.Request, a1 any) error {
return W.WWriteRequest(a0, a1)
}
// _net_rpc_ServerCodec is an interface wrapper for ServerCodec type
type _net_rpc_ServerCodec struct {
IValue interface{}
WClose func() error
WReadRequestBody func(a0 any) error
WReadRequestHeader func(a0 *rpc.Request) error
WWriteResponse func(a0 *rpc.Response, a1 any) error
}
func (W _net_rpc_ServerCodec) Close() error { return W.WClose() }
func (W _net_rpc_ServerCodec) ReadRequestBody(a0 any) error { return W.WReadRequestBody(a0) }
func (W _net_rpc_ServerCodec) ReadRequestHeader(a0 *rpc.Request) error {
return W.WReadRequestHeader(a0)
}
func (W _net_rpc_ServerCodec) WriteResponse(a0 *rpc.Response, a1 any) error {
return W.WWriteResponse(a0, a1)
}
================================================
FILE: stdlib/go1_21_net_rpc_jsonrpc.go
================================================
// Code generated by 'yaegi extract net/rpc/jsonrpc'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"net/rpc/jsonrpc"
"reflect"
)
func init() {
Symbols["net/rpc/jsonrpc/jsonrpc"] = map[string]reflect.Value{
// function, constant and variable definitions
"Dial": reflect.ValueOf(jsonrpc.Dial),
"NewClient": reflect.ValueOf(jsonrpc.NewClient),
"NewClientCodec": reflect.ValueOf(jsonrpc.NewClientCodec),
"NewServerCodec": reflect.ValueOf(jsonrpc.NewServerCodec),
"ServeConn": reflect.ValueOf(jsonrpc.ServeConn),
}
}
================================================
FILE: stdlib/go1_21_net_smtp.go
================================================
// Code generated by 'yaegi extract net/smtp'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"net/smtp"
"reflect"
)
func init() {
Symbols["net/smtp/smtp"] = map[string]reflect.Value{
// function, constant and variable definitions
"CRAMMD5Auth": reflect.ValueOf(smtp.CRAMMD5Auth),
"Dial": reflect.ValueOf(smtp.Dial),
"NewClient": reflect.ValueOf(smtp.NewClient),
"PlainAuth": reflect.ValueOf(smtp.PlainAuth),
"SendMail": reflect.ValueOf(smtp.SendMail),
// type definitions
"Auth": reflect.ValueOf((*smtp.Auth)(nil)),
"Client": reflect.ValueOf((*smtp.Client)(nil)),
"ServerInfo": reflect.ValueOf((*smtp.ServerInfo)(nil)),
// interface wrapper definitions
"_Auth": reflect.ValueOf((*_net_smtp_Auth)(nil)),
}
}
// _net_smtp_Auth is an interface wrapper for Auth type
type _net_smtp_Auth struct {
IValue interface{}
WNext func(fromServer []byte, more bool) (toServer []byte, err error)
WStart func(server *smtp.ServerInfo) (proto string, toServer []byte, err error)
}
func (W _net_smtp_Auth) Next(fromServer []byte, more bool) (toServer []byte, err error) {
return W.WNext(fromServer, more)
}
func (W _net_smtp_Auth) Start(server *smtp.ServerInfo) (proto string, toServer []byte, err error) {
return W.WStart(server)
}
================================================
FILE: stdlib/go1_21_net_textproto.go
================================================
// Code generated by 'yaegi extract net/textproto'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"net/textproto"
"reflect"
)
func init() {
Symbols["net/textproto/textproto"] = map[string]reflect.Value{
// function, constant and variable definitions
"CanonicalMIMEHeaderKey": reflect.ValueOf(textproto.CanonicalMIMEHeaderKey),
"Dial": reflect.ValueOf(textproto.Dial),
"NewConn": reflect.ValueOf(textproto.NewConn),
"NewReader": reflect.ValueOf(textproto.NewReader),
"NewWriter": reflect.ValueOf(textproto.NewWriter),
"TrimBytes": reflect.ValueOf(textproto.TrimBytes),
"TrimString": reflect.ValueOf(textproto.TrimString),
// type definitions
"Conn": reflect.ValueOf((*textproto.Conn)(nil)),
"Error": reflect.ValueOf((*textproto.Error)(nil)),
"MIMEHeader": reflect.ValueOf((*textproto.MIMEHeader)(nil)),
"Pipeline": reflect.ValueOf((*textproto.Pipeline)(nil)),
"ProtocolError": reflect.ValueOf((*textproto.ProtocolError)(nil)),
"Reader": reflect.ValueOf((*textproto.Reader)(nil)),
"Writer": reflect.ValueOf((*textproto.Writer)(nil)),
}
}
================================================
FILE: stdlib/go1_21_net_url.go
================================================
// Code generated by 'yaegi extract net/url'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"net/url"
"reflect"
)
func init() {
Symbols["net/url/url"] = map[string]reflect.Value{
// function, constant and variable definitions
"JoinPath": reflect.ValueOf(url.JoinPath),
"Parse": reflect.ValueOf(url.Parse),
"ParseQuery": reflect.ValueOf(url.ParseQuery),
"ParseRequestURI": reflect.ValueOf(url.ParseRequestURI),
"PathEscape": reflect.ValueOf(url.PathEscape),
"PathUnescape": reflect.ValueOf(url.PathUnescape),
"QueryEscape": reflect.ValueOf(url.QueryEscape),
"QueryUnescape": reflect.ValueOf(url.QueryUnescape),
"User": reflect.ValueOf(url.User),
"UserPassword": reflect.ValueOf(url.UserPassword),
// type definitions
"Error": reflect.ValueOf((*url.Error)(nil)),
"EscapeError": reflect.ValueOf((*url.EscapeError)(nil)),
"InvalidHostError": reflect.ValueOf((*url.InvalidHostError)(nil)),
"URL": reflect.ValueOf((*url.URL)(nil)),
"Userinfo": reflect.ValueOf((*url.Userinfo)(nil)),
"Values": reflect.ValueOf((*url.Values)(nil)),
}
}
================================================
FILE: stdlib/go1_21_os.go
================================================
// Code generated by 'yaegi extract os'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"go/constant"
"go/token"
"io/fs"
"os"
"reflect"
"time"
)
func init() {
Symbols["os/os"] = map[string]reflect.Value{
// function, constant and variable definitions
"Args": reflect.ValueOf(&os.Args).Elem(),
"Chdir": reflect.ValueOf(os.Chdir),
"Chmod": reflect.ValueOf(os.Chmod),
"Chown": reflect.ValueOf(os.Chown),
"Chtimes": reflect.ValueOf(os.Chtimes),
"Clearenv": reflect.ValueOf(os.Clearenv),
"Create": reflect.ValueOf(os.Create),
"CreateTemp": reflect.ValueOf(os.CreateTemp),
"DevNull": reflect.ValueOf(constant.MakeFromLiteral("\"/dev/null\"", token.STRING, 0)),
"DirFS": reflect.ValueOf(os.DirFS),
"Environ": reflect.ValueOf(os.Environ),
"ErrClosed": reflect.ValueOf(&os.ErrClosed).Elem(),
"ErrDeadlineExceeded": reflect.ValueOf(&os.ErrDeadlineExceeded).Elem(),
"ErrExist": reflect.ValueOf(&os.ErrExist).Elem(),
"ErrInvalid": reflect.ValueOf(&os.ErrInvalid).Elem(),
"ErrNoDeadline": reflect.ValueOf(&os.ErrNoDeadline).Elem(),
"ErrNotExist": reflect.ValueOf(&os.ErrNotExist).Elem(),
"ErrPermission": reflect.ValueOf(&os.ErrPermission).Elem(),
"ErrProcessDone": reflect.ValueOf(&os.ErrProcessDone).Elem(),
"Executable": reflect.ValueOf(os.Executable),
"Exit": reflect.ValueOf(osExit),
"Expand": reflect.ValueOf(os.Expand),
"ExpandEnv": reflect.ValueOf(os.ExpandEnv),
"FindProcess": reflect.ValueOf(osFindProcess),
"Getegid": reflect.ValueOf(os.Getegid),
"Getenv": reflect.ValueOf(os.Getenv),
"Geteuid": reflect.ValueOf(os.Geteuid),
"Getgid": reflect.ValueOf(os.Getgid),
"Getgroups": reflect.ValueOf(os.Getgroups),
"Getpagesize": reflect.ValueOf(os.Getpagesize),
"Getpid": reflect.ValueOf(os.Getpid),
"Getppid": reflect.ValueOf(os.Getppid),
"Getuid": reflect.ValueOf(os.Getuid),
"Getwd": reflect.ValueOf(os.Getwd),
"Hostname": reflect.ValueOf(os.Hostname),
"Interrupt": reflect.ValueOf(&os.Interrupt).Elem(),
"IsExist": reflect.ValueOf(os.IsExist),
"IsNotExist": reflect.ValueOf(os.IsNotExist),
"IsPathSeparator": reflect.ValueOf(os.IsPathSeparator),
"IsPermission": reflect.ValueOf(os.IsPermission),
"IsTimeout": reflect.ValueOf(os.IsTimeout),
"Kill": reflect.ValueOf(&os.Kill).Elem(),
"Lchown": reflect.ValueOf(os.Lchown),
"Link": reflect.ValueOf(os.Link),
"LookupEnv": reflect.ValueOf(os.LookupEnv),
"Lstat": reflect.ValueOf(os.Lstat),
"Mkdir": reflect.ValueOf(os.Mkdir),
"MkdirAll": reflect.ValueOf(os.MkdirAll),
"MkdirTemp": reflect.ValueOf(os.MkdirTemp),
"ModeAppend": reflect.ValueOf(os.ModeAppend),
"ModeCharDevice": reflect.ValueOf(os.ModeCharDevice),
"ModeDevice": reflect.ValueOf(os.ModeDevice),
"ModeDir": reflect.ValueOf(os.ModeDir),
"ModeExclusive": reflect.ValueOf(os.ModeExclusive),
"ModeIrregular": reflect.ValueOf(os.ModeIrregular),
"ModeNamedPipe": reflect.ValueOf(os.ModeNamedPipe),
"ModePerm": reflect.ValueOf(os.ModePerm),
"ModeSetgid": reflect.ValueOf(os.ModeSetgid),
"ModeSetuid": reflect.ValueOf(os.ModeSetuid),
"ModeSocket": reflect.ValueOf(os.ModeSocket),
"ModeSticky": reflect.ValueOf(os.ModeSticky),
"ModeSymlink": reflect.ValueOf(os.ModeSymlink),
"ModeTemporary": reflect.ValueOf(os.ModeTemporary),
"ModeType": reflect.ValueOf(os.ModeType),
"NewFile": reflect.ValueOf(os.NewFile),
"NewSyscallError": reflect.ValueOf(os.NewSyscallError),
"O_APPEND": reflect.ValueOf(os.O_APPEND),
"O_CREATE": reflect.ValueOf(os.O_CREATE),
"O_EXCL": reflect.ValueOf(os.O_EXCL),
"O_RDONLY": reflect.ValueOf(os.O_RDONLY),
"O_RDWR": reflect.ValueOf(os.O_RDWR),
"O_SYNC": reflect.ValueOf(os.O_SYNC),
"O_TRUNC": reflect.ValueOf(os.O_TRUNC),
"O_WRONLY": reflect.ValueOf(os.O_WRONLY),
"Open": reflect.ValueOf(os.Open),
"OpenFile": reflect.ValueOf(os.OpenFile),
"PathListSeparator": reflect.ValueOf(constant.MakeFromLiteral("58", token.INT, 0)),
"PathSeparator": reflect.ValueOf(constant.MakeFromLiteral("47", token.INT, 0)),
"Pipe": reflect.ValueOf(os.Pipe),
"ReadDir": reflect.ValueOf(os.ReadDir),
"ReadFile": reflect.ValueOf(os.ReadFile),
"Readlink": reflect.ValueOf(os.Readlink),
"Remove": reflect.ValueOf(os.Remove),
"RemoveAll": reflect.ValueOf(os.RemoveAll),
"Rename": reflect.ValueOf(os.Rename),
"SEEK_CUR": reflect.ValueOf(os.SEEK_CUR),
"SEEK_END": reflect.ValueOf(os.SEEK_END),
"SEEK_SET": reflect.ValueOf(os.SEEK_SET),
"SameFile": reflect.ValueOf(os.SameFile),
"Setenv": reflect.ValueOf(os.Setenv),
"StartProcess": reflect.ValueOf(os.StartProcess),
"Stat": reflect.ValueOf(os.Stat),
"Stderr": reflect.ValueOf(&os.Stderr).Elem(),
"Stdin": reflect.ValueOf(&os.Stdin).Elem(),
"Stdout": reflect.ValueOf(&os.Stdout).Elem(),
"Symlink": reflect.ValueOf(os.Symlink),
"TempDir": reflect.ValueOf(os.TempDir),
"Truncate": reflect.ValueOf(os.Truncate),
"Unsetenv": reflect.ValueOf(os.Unsetenv),
"UserCacheDir": reflect.ValueOf(os.UserCacheDir),
"UserConfigDir": reflect.ValueOf(os.UserConfigDir),
"UserHomeDir": reflect.ValueOf(os.UserHomeDir),
"WriteFile": reflect.ValueOf(os.WriteFile),
// type definitions
"DirEntry": reflect.ValueOf((*os.DirEntry)(nil)),
"File": reflect.ValueOf((*os.File)(nil)),
"FileInfo": reflect.ValueOf((*os.FileInfo)(nil)),
"FileMode": reflect.ValueOf((*os.FileMode)(nil)),
"LinkError": reflect.ValueOf((*os.LinkError)(nil)),
"PathError": reflect.ValueOf((*os.PathError)(nil)),
"ProcAttr": reflect.ValueOf((*os.ProcAttr)(nil)),
"Process": reflect.ValueOf((*os.Process)(nil)),
"ProcessState": reflect.ValueOf((*os.ProcessState)(nil)),
"Signal": reflect.ValueOf((*os.Signal)(nil)),
"SyscallError": reflect.ValueOf((*os.SyscallError)(nil)),
// interface wrapper definitions
"_DirEntry": reflect.ValueOf((*_os_DirEntry)(nil)),
"_FileInfo": reflect.ValueOf((*_os_FileInfo)(nil)),
"_Signal": reflect.ValueOf((*_os_Signal)(nil)),
}
}
// _os_DirEntry is an interface wrapper for DirEntry type
type _os_DirEntry struct {
IValue interface{}
WInfo func() (fs.FileInfo, error)
WIsDir func() bool
WName func() string
WType func() fs.FileMode
}
func (W _os_DirEntry) Info() (fs.FileInfo, error) { return W.WInfo() }
func (W _os_DirEntry) IsDir() bool { return W.WIsDir() }
func (W _os_DirEntry) Name() string { return W.WName() }
func (W _os_DirEntry) Type() fs.FileMode { return W.WType() }
// _os_FileInfo is an interface wrapper for FileInfo type
type _os_FileInfo struct {
IValue interface{}
WIsDir func() bool
WModTime func() time.Time
WMode func() fs.FileMode
WName func() string
WSize func() int64
WSys func() any
}
func (W _os_FileInfo) IsDir() bool { return W.WIsDir() }
func (W _os_FileInfo) ModTime() time.Time { return W.WModTime() }
func (W _os_FileInfo) Mode() fs.FileMode { return W.WMode() }
func (W _os_FileInfo) Name() string { return W.WName() }
func (W _os_FileInfo) Size() int64 { return W.WSize() }
func (W _os_FileInfo) Sys() any { return W.WSys() }
// _os_Signal is an interface wrapper for Signal type
type _os_Signal struct {
IValue interface{}
WSignal func()
WString func() string
}
func (W _os_Signal) Signal() { W.WSignal() }
func (W _os_Signal) String() string {
if W.WString == nil {
return ""
}
return W.WString()
}
================================================
FILE: stdlib/go1_21_os_signal.go
================================================
// Code generated by 'yaegi extract os/signal'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"os/signal"
"reflect"
)
func init() {
Symbols["os/signal/signal"] = map[string]reflect.Value{
// function, constant and variable definitions
"Ignore": reflect.ValueOf(signal.Ignore),
"Ignored": reflect.ValueOf(signal.Ignored),
"Notify": reflect.ValueOf(signal.Notify),
"NotifyContext": reflect.ValueOf(signal.NotifyContext),
"Reset": reflect.ValueOf(signal.Reset),
"Stop": reflect.ValueOf(signal.Stop),
}
}
================================================
FILE: stdlib/go1_21_os_user.go
================================================
// Code generated by 'yaegi extract os/user'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"os/user"
"reflect"
)
func init() {
Symbols["os/user/user"] = map[string]reflect.Value{
// function, constant and variable definitions
"Current": reflect.ValueOf(user.Current),
"Lookup": reflect.ValueOf(user.Lookup),
"LookupGroup": reflect.ValueOf(user.LookupGroup),
"LookupGroupId": reflect.ValueOf(user.LookupGroupId),
"LookupId": reflect.ValueOf(user.LookupId),
// type definitions
"Group": reflect.ValueOf((*user.Group)(nil)),
"UnknownGroupError": reflect.ValueOf((*user.UnknownGroupError)(nil)),
"UnknownGroupIdError": reflect.ValueOf((*user.UnknownGroupIdError)(nil)),
"UnknownUserError": reflect.ValueOf((*user.UnknownUserError)(nil)),
"UnknownUserIdError": reflect.ValueOf((*user.UnknownUserIdError)(nil)),
"User": reflect.ValueOf((*user.User)(nil)),
}
}
================================================
FILE: stdlib/go1_21_path.go
================================================
// Code generated by 'yaegi extract path'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"path"
"reflect"
)
func init() {
Symbols["path/path"] = map[string]reflect.Value{
// function, constant and variable definitions
"Base": reflect.ValueOf(path.Base),
"Clean": reflect.ValueOf(path.Clean),
"Dir": reflect.ValueOf(path.Dir),
"ErrBadPattern": reflect.ValueOf(&path.ErrBadPattern).Elem(),
"Ext": reflect.ValueOf(path.Ext),
"IsAbs": reflect.ValueOf(path.IsAbs),
"Join": reflect.ValueOf(path.Join),
"Match": reflect.ValueOf(path.Match),
"Split": reflect.ValueOf(path.Split),
}
}
================================================
FILE: stdlib/go1_21_path_filepath.go
================================================
// Code generated by 'yaegi extract path/filepath'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"go/constant"
"go/token"
"path/filepath"
"reflect"
)
func init() {
Symbols["path/filepath/filepath"] = map[string]reflect.Value{
// function, constant and variable definitions
"Abs": reflect.ValueOf(filepath.Abs),
"Base": reflect.ValueOf(filepath.Base),
"Clean": reflect.ValueOf(filepath.Clean),
"Dir": reflect.ValueOf(filepath.Dir),
"ErrBadPattern": reflect.ValueOf(&filepath.ErrBadPattern).Elem(),
"EvalSymlinks": reflect.ValueOf(filepath.EvalSymlinks),
"Ext": reflect.ValueOf(filepath.Ext),
"FromSlash": reflect.ValueOf(filepath.FromSlash),
"Glob": reflect.ValueOf(filepath.Glob),
"HasPrefix": reflect.ValueOf(filepath.HasPrefix),
"IsAbs": reflect.ValueOf(filepath.IsAbs),
"IsLocal": reflect.ValueOf(filepath.IsLocal),
"Join": reflect.ValueOf(filepath.Join),
"ListSeparator": reflect.ValueOf(constant.MakeFromLiteral("58", token.INT, 0)),
"Match": reflect.ValueOf(filepath.Match),
"Rel": reflect.ValueOf(filepath.Rel),
"Separator": reflect.ValueOf(constant.MakeFromLiteral("47", token.INT, 0)),
"SkipAll": reflect.ValueOf(&filepath.SkipAll).Elem(),
"SkipDir": reflect.ValueOf(&filepath.SkipDir).Elem(),
"Split": reflect.ValueOf(filepath.Split),
"SplitList": reflect.ValueOf(filepath.SplitList),
"ToSlash": reflect.ValueOf(filepath.ToSlash),
"VolumeName": reflect.ValueOf(filepath.VolumeName),
"Walk": reflect.ValueOf(filepath.Walk),
"WalkDir": reflect.ValueOf(filepath.WalkDir),
// type definitions
"WalkFunc": reflect.ValueOf((*filepath.WalkFunc)(nil)),
}
}
================================================
FILE: stdlib/go1_21_reflect.go
================================================
// Code generated by 'yaegi extract reflect'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"reflect"
)
func init() {
Symbols["reflect/reflect"] = map[string]reflect.Value{
// function, constant and variable definitions
"Append": reflect.ValueOf(reflect.Append),
"AppendSlice": reflect.ValueOf(reflect.AppendSlice),
"Array": reflect.ValueOf(reflect.Array),
"ArrayOf": reflect.ValueOf(reflect.ArrayOf),
"Bool": reflect.ValueOf(reflect.Bool),
"BothDir": reflect.ValueOf(reflect.BothDir),
"Chan": reflect.ValueOf(reflect.Chan),
"ChanOf": reflect.ValueOf(reflect.ChanOf),
"Complex128": reflect.ValueOf(reflect.Complex128),
"Complex64": reflect.ValueOf(reflect.Complex64),
"Copy": reflect.ValueOf(reflect.Copy),
"DeepEqual": reflect.ValueOf(reflect.DeepEqual),
"Float32": reflect.ValueOf(reflect.Float32),
"Float64": reflect.ValueOf(reflect.Float64),
"Func": reflect.ValueOf(reflect.Func),
"FuncOf": reflect.ValueOf(reflect.FuncOf),
"Indirect": reflect.ValueOf(reflect.Indirect),
"Int": reflect.ValueOf(reflect.Int),
"Int16": reflect.ValueOf(reflect.Int16),
"Int32": reflect.ValueOf(reflect.Int32),
"Int64": reflect.ValueOf(reflect.Int64),
"Int8": reflect.ValueOf(reflect.Int8),
"Interface": reflect.ValueOf(reflect.Interface),
"Invalid": reflect.ValueOf(reflect.Invalid),
"MakeChan": reflect.ValueOf(reflect.MakeChan),
"MakeFunc": reflect.ValueOf(reflect.MakeFunc),
"MakeMap": reflect.ValueOf(reflect.MakeMap),
"MakeMapWithSize": reflect.ValueOf(reflect.MakeMapWithSize),
"MakeSlice": reflect.ValueOf(reflect.MakeSlice),
"Map": reflect.ValueOf(reflect.Map),
"MapOf": reflect.ValueOf(reflect.MapOf),
"New": reflect.ValueOf(reflect.New),
"NewAt": reflect.ValueOf(reflect.NewAt),
"Pointer": reflect.ValueOf(reflect.Pointer),
"PointerTo": reflect.ValueOf(reflect.PointerTo),
"Ptr": reflect.ValueOf(reflect.Ptr),
"PtrTo": reflect.ValueOf(reflect.PtrTo),
"RecvDir": reflect.ValueOf(reflect.RecvDir),
"Select": reflect.ValueOf(reflect.Select),
"SelectDefault": reflect.ValueOf(reflect.SelectDefault),
"SelectRecv": reflect.ValueOf(reflect.SelectRecv),
"SelectSend": reflect.ValueOf(reflect.SelectSend),
"SendDir": reflect.ValueOf(reflect.SendDir),
"Slice": reflect.ValueOf(reflect.Slice),
"SliceOf": reflect.ValueOf(reflect.SliceOf),
"String": reflect.ValueOf(reflect.String),
"Struct": reflect.ValueOf(reflect.Struct),
"StructOf": reflect.ValueOf(reflect.StructOf),
"Swapper": reflect.ValueOf(reflect.Swapper),
"TypeOf": reflect.ValueOf(reflect.TypeOf),
"Uint": reflect.ValueOf(reflect.Uint),
"Uint16": reflect.ValueOf(reflect.Uint16),
"Uint32": reflect.ValueOf(reflect.Uint32),
"Uint64": reflect.ValueOf(reflect.Uint64),
"Uint8": reflect.ValueOf(reflect.Uint8),
"Uintptr": reflect.ValueOf(reflect.Uintptr),
"UnsafePointer": reflect.ValueOf(reflect.UnsafePointer),
"ValueOf": reflect.ValueOf(reflect.ValueOf),
"VisibleFields": reflect.ValueOf(reflect.VisibleFields),
"Zero": reflect.ValueOf(reflect.Zero),
// type definitions
"ChanDir": reflect.ValueOf((*reflect.ChanDir)(nil)),
"Kind": reflect.ValueOf((*reflect.Kind)(nil)),
"MapIter": reflect.ValueOf((*reflect.MapIter)(nil)),
"Method": reflect.ValueOf((*reflect.Method)(nil)),
"SelectCase": reflect.ValueOf((*reflect.SelectCase)(nil)),
"SelectDir": reflect.ValueOf((*reflect.SelectDir)(nil)),
"SliceHeader": reflect.ValueOf((*reflect.SliceHeader)(nil)),
"StringHeader": reflect.ValueOf((*reflect.StringHeader)(nil)),
"StructField": reflect.ValueOf((*reflect.StructField)(nil)),
"StructTag": reflect.ValueOf((*reflect.StructTag)(nil)),
"Type": reflect.ValueOf((*reflect.Type)(nil)),
"Value": reflect.ValueOf((*reflect.Value)(nil)),
"ValueError": reflect.ValueOf((*reflect.ValueError)(nil)),
// interface wrapper definitions
"_Type": reflect.ValueOf((*_reflect_Type)(nil)),
}
}
// _reflect_Type is an interface wrapper for Type type
type _reflect_Type struct {
IValue interface{}
WAlign func() int
WAssignableTo func(u reflect.Type) bool
WBits func() int
WChanDir func() reflect.ChanDir
WComparable func() bool
WConvertibleTo func(u reflect.Type) bool
WElem func() reflect.Type
WField func(i int) reflect.StructField
WFieldAlign func() int
WFieldByIndex func(index []int) reflect.StructField
WFieldByName func(name string) (reflect.StructField, bool)
WFieldByNameFunc func(match func(string) bool) (reflect.StructField, bool)
WImplements func(u reflect.Type) bool
WIn func(i int) reflect.Type
WIsVariadic func() bool
WKey func() reflect.Type
WKind func() reflect.Kind
WLen func() int
WMethod func(a0 int) reflect.Method
WMethodByName func(a0 string) (reflect.Method, bool)
WName func() string
WNumField func() int
WNumIn func() int
WNumMethod func() int
WNumOut func() int
WOut func(i int) reflect.Type
WPkgPath func() string
WSize func() uintptr
WString func() string
}
func (W _reflect_Type) Align() int { return W.WAlign() }
func (W _reflect_Type) AssignableTo(u reflect.Type) bool { return W.WAssignableTo(u) }
func (W _reflect_Type) Bits() int { return W.WBits() }
func (W _reflect_Type) ChanDir() reflect.ChanDir { return W.WChanDir() }
func (W _reflect_Type) Comparable() bool { return W.WComparable() }
func (W _reflect_Type) ConvertibleTo(u reflect.Type) bool { return W.WConvertibleTo(u) }
func (W _reflect_Type) Elem() reflect.Type { return W.WElem() }
func (W _reflect_Type) Field(i int) reflect.StructField { return W.WField(i) }
func (W _reflect_Type) FieldAlign() int { return W.WFieldAlign() }
func (W _reflect_Type) FieldByIndex(index []int) reflect.StructField { return W.WFieldByIndex(index) }
func (W _reflect_Type) FieldByName(name string) (reflect.StructField, bool) {
return W.WFieldByName(name)
}
func (W _reflect_Type) FieldByNameFunc(match func(string) bool) (reflect.StructField, bool) {
return W.WFieldByNameFunc(match)
}
func (W _reflect_Type) Implements(u reflect.Type) bool { return W.WImplements(u) }
func (W _reflect_Type) In(i int) reflect.Type { return W.WIn(i) }
func (W _reflect_Type) IsVariadic() bool { return W.WIsVariadic() }
func (W _reflect_Type) Key() reflect.Type { return W.WKey() }
func (W _reflect_Type) Kind() reflect.Kind { return W.WKind() }
func (W _reflect_Type) Len() int { return W.WLen() }
func (W _reflect_Type) Method(a0 int) reflect.Method { return W.WMethod(a0) }
func (W _reflect_Type) MethodByName(a0 string) (reflect.Method, bool) { return W.WMethodByName(a0) }
func (W _reflect_Type) Name() string { return W.WName() }
func (W _reflect_Type) NumField() int { return W.WNumField() }
func (W _reflect_Type) NumIn() int { return W.WNumIn() }
func (W _reflect_Type) NumMethod() int { return W.WNumMethod() }
func (W _reflect_Type) NumOut() int { return W.WNumOut() }
func (W _reflect_Type) Out(i int) reflect.Type { return W.WOut(i) }
func (W _reflect_Type) PkgPath() string { return W.WPkgPath() }
func (W _reflect_Type) Size() uintptr { return W.WSize() }
func (W _reflect_Type) String() string {
if W.WString == nil {
return ""
}
return W.WString()
}
================================================
FILE: stdlib/go1_21_regexp.go
================================================
// Code generated by 'yaegi extract regexp'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"reflect"
"regexp"
)
func init() {
Symbols["regexp/regexp"] = map[string]reflect.Value{
// function, constant and variable definitions
"Compile": reflect.ValueOf(regexp.Compile),
"CompilePOSIX": reflect.ValueOf(regexp.CompilePOSIX),
"Match": reflect.ValueOf(regexp.Match),
"MatchReader": reflect.ValueOf(regexp.MatchReader),
"MatchString": reflect.ValueOf(regexp.MatchString),
"MustCompile": reflect.ValueOf(regexp.MustCompile),
"MustCompilePOSIX": reflect.ValueOf(regexp.MustCompilePOSIX),
"QuoteMeta": reflect.ValueOf(regexp.QuoteMeta),
// type definitions
"Regexp": reflect.ValueOf((*regexp.Regexp)(nil)),
}
}
================================================
FILE: stdlib/go1_21_regexp_syntax.go
================================================
// Code generated by 'yaegi extract regexp/syntax'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"reflect"
"regexp/syntax"
)
func init() {
Symbols["regexp/syntax/syntax"] = map[string]reflect.Value{
// function, constant and variable definitions
"ClassNL": reflect.ValueOf(syntax.ClassNL),
"Compile": reflect.ValueOf(syntax.Compile),
"DotNL": reflect.ValueOf(syntax.DotNL),
"EmptyBeginLine": reflect.ValueOf(syntax.EmptyBeginLine),
"EmptyBeginText": reflect.ValueOf(syntax.EmptyBeginText),
"EmptyEndLine": reflect.ValueOf(syntax.EmptyEndLine),
"EmptyEndText": reflect.ValueOf(syntax.EmptyEndText),
"EmptyNoWordBoundary": reflect.ValueOf(syntax.EmptyNoWordBoundary),
"EmptyOpContext": reflect.ValueOf(syntax.EmptyOpContext),
"EmptyWordBoundary": reflect.ValueOf(syntax.EmptyWordBoundary),
"ErrInternalError": reflect.ValueOf(syntax.ErrInternalError),
"ErrInvalidCharClass": reflect.ValueOf(syntax.ErrInvalidCharClass),
"ErrInvalidCharRange": reflect.ValueOf(syntax.ErrInvalidCharRange),
"ErrInvalidEscape": reflect.ValueOf(syntax.ErrInvalidEscape),
"ErrInvalidNamedCapture": reflect.ValueOf(syntax.ErrInvalidNamedCapture),
"ErrInvalidPerlOp": reflect.ValueOf(syntax.ErrInvalidPerlOp),
"ErrInvalidRepeatOp": reflect.ValueOf(syntax.ErrInvalidRepeatOp),
"ErrInvalidRepeatSize": reflect.ValueOf(syntax.ErrInvalidRepeatSize),
"ErrInvalidUTF8": reflect.ValueOf(syntax.ErrInvalidUTF8),
"ErrLarge": reflect.ValueOf(syntax.ErrLarge),
"ErrMissingBracket": reflect.ValueOf(syntax.ErrMissingBracket),
"ErrMissingParen": reflect.ValueOf(syntax.ErrMissingParen),
"ErrMissingRepeatArgument": reflect.ValueOf(syntax.ErrMissingRepeatArgument),
"ErrNestingDepth": reflect.ValueOf(syntax.ErrNestingDepth),
"ErrTrailingBackslash": reflect.ValueOf(syntax.ErrTrailingBackslash),
"ErrUnexpectedParen": reflect.ValueOf(syntax.ErrUnexpectedParen),
"FoldCase": reflect.ValueOf(syntax.FoldCase),
"InstAlt": reflect.ValueOf(syntax.InstAlt),
"InstAltMatch": reflect.ValueOf(syntax.InstAltMatch),
"InstCapture": reflect.ValueOf(syntax.InstCapture),
"InstEmptyWidth": reflect.ValueOf(syntax.InstEmptyWidth),
"InstFail": reflect.ValueOf(syntax.InstFail),
"InstMatch": reflect.ValueOf(syntax.InstMatch),
"InstNop": reflect.ValueOf(syntax.InstNop),
"InstRune": reflect.ValueOf(syntax.InstRune),
"InstRune1": reflect.ValueOf(syntax.InstRune1),
"InstRuneAny": reflect.ValueOf(syntax.InstRuneAny),
"InstRuneAnyNotNL": reflect.ValueOf(syntax.InstRuneAnyNotNL),
"IsWordChar": reflect.ValueOf(syntax.IsWordChar),
"Literal": reflect.ValueOf(syntax.Literal),
"MatchNL": reflect.ValueOf(syntax.MatchNL),
"NonGreedy": reflect.ValueOf(syntax.NonGreedy),
"OneLine": reflect.ValueOf(syntax.OneLine),
"OpAlternate": reflect.ValueOf(syntax.OpAlternate),
"OpAnyChar": reflect.ValueOf(syntax.OpAnyChar),
"OpAnyCharNotNL": reflect.ValueOf(syntax.OpAnyCharNotNL),
"OpBeginLine": reflect.ValueOf(syntax.OpBeginLine),
"OpBeginText": reflect.ValueOf(syntax.OpBeginText),
"OpCapture": reflect.ValueOf(syntax.OpCapture),
"OpCharClass": reflect.ValueOf(syntax.OpCharClass),
"OpConcat": reflect.ValueOf(syntax.OpConcat),
"OpEmptyMatch": reflect.ValueOf(syntax.OpEmptyMatch),
"OpEndLine": reflect.ValueOf(syntax.OpEndLine),
"OpEndText": reflect.ValueOf(syntax.OpEndText),
"OpLiteral": reflect.ValueOf(syntax.OpLiteral),
"OpNoMatch": reflect.ValueOf(syntax.OpNoMatch),
"OpNoWordBoundary": reflect.ValueOf(syntax.OpNoWordBoundary),
"OpPlus": reflect.ValueOf(syntax.OpPlus),
"OpQuest": reflect.ValueOf(syntax.OpQuest),
"OpRepeat": reflect.ValueOf(syntax.OpRepeat),
"OpStar": reflect.ValueOf(syntax.OpStar),
"OpWordBoundary": reflect.ValueOf(syntax.OpWordBoundary),
"POSIX": reflect.ValueOf(syntax.POSIX),
"Parse": reflect.ValueOf(syntax.Parse),
"Perl": reflect.ValueOf(syntax.Perl),
"PerlX": reflect.ValueOf(syntax.PerlX),
"Simple": reflect.ValueOf(syntax.Simple),
"UnicodeGroups": reflect.ValueOf(syntax.UnicodeGroups),
"WasDollar": reflect.ValueOf(syntax.WasDollar),
// type definitions
"EmptyOp": reflect.ValueOf((*syntax.EmptyOp)(nil)),
"Error": reflect.ValueOf((*syntax.Error)(nil)),
"ErrorCode": reflect.ValueOf((*syntax.ErrorCode)(nil)),
"Flags": reflect.ValueOf((*syntax.Flags)(nil)),
"Inst": reflect.ValueOf((*syntax.Inst)(nil)),
"InstOp": reflect.ValueOf((*syntax.InstOp)(nil)),
"Op": reflect.ValueOf((*syntax.Op)(nil)),
"Prog": reflect.ValueOf((*syntax.Prog)(nil)),
"Regexp": reflect.ValueOf((*syntax.Regexp)(nil)),
}
}
================================================
FILE: stdlib/go1_21_runtime.go
================================================
// Code generated by 'yaegi extract runtime'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"go/constant"
"go/token"
"reflect"
"runtime"
)
func init() {
Symbols["runtime/runtime"] = map[string]reflect.Value{
// function, constant and variable definitions
"BlockProfile": reflect.ValueOf(runtime.BlockProfile),
"Breakpoint": reflect.ValueOf(runtime.Breakpoint),
"CPUProfile": reflect.ValueOf(runtime.CPUProfile),
"Caller": reflect.ValueOf(runtime.Caller),
"Callers": reflect.ValueOf(runtime.Callers),
"CallersFrames": reflect.ValueOf(runtime.CallersFrames),
"Compiler": reflect.ValueOf(constant.MakeFromLiteral("\"gc\"", token.STRING, 0)),
"FuncForPC": reflect.ValueOf(runtime.FuncForPC),
"GC": reflect.ValueOf(runtime.GC),
"GOARCH": reflect.ValueOf(runtime.GOARCH),
"GOMAXPROCS": reflect.ValueOf(runtime.GOMAXPROCS),
"GOOS": reflect.ValueOf(runtime.GOOS),
"GOROOT": reflect.ValueOf(runtime.GOROOT),
"Goexit": reflect.ValueOf(runtime.Goexit),
"GoroutineProfile": reflect.ValueOf(runtime.GoroutineProfile),
"Gosched": reflect.ValueOf(runtime.Gosched),
"KeepAlive": reflect.ValueOf(runtime.KeepAlive),
"LockOSThread": reflect.ValueOf(runtime.LockOSThread),
"MemProfile": reflect.ValueOf(runtime.MemProfile),
"MemProfileRate": reflect.ValueOf(&runtime.MemProfileRate).Elem(),
"MutexProfile": reflect.ValueOf(runtime.MutexProfile),
"NumCPU": reflect.ValueOf(runtime.NumCPU),
"NumCgoCall": reflect.ValueOf(runtime.NumCgoCall),
"NumGoroutine": reflect.ValueOf(runtime.NumGoroutine),
"ReadMemStats": reflect.ValueOf(runtime.ReadMemStats),
"ReadTrace": reflect.ValueOf(runtime.ReadTrace),
"SetBlockProfileRate": reflect.ValueOf(runtime.SetBlockProfileRate),
"SetCPUProfileRate": reflect.ValueOf(runtime.SetCPUProfileRate),
"SetCgoTraceback": reflect.ValueOf(runtime.SetCgoTraceback),
"SetFinalizer": reflect.ValueOf(runtime.SetFinalizer),
"SetMutexProfileFraction": reflect.ValueOf(runtime.SetMutexProfileFraction),
"Stack": reflect.ValueOf(runtime.Stack),
"StartTrace": reflect.ValueOf(runtime.StartTrace),
"StopTrace": reflect.ValueOf(runtime.StopTrace),
"ThreadCreateProfile": reflect.ValueOf(runtime.ThreadCreateProfile),
"UnlockOSThread": reflect.ValueOf(runtime.UnlockOSThread),
"Version": reflect.ValueOf(runtime.Version),
// type definitions
"BlockProfileRecord": reflect.ValueOf((*runtime.BlockProfileRecord)(nil)),
"Error": reflect.ValueOf((*runtime.Error)(nil)),
"Frame": reflect.ValueOf((*runtime.Frame)(nil)),
"Frames": reflect.ValueOf((*runtime.Frames)(nil)),
"Func": reflect.ValueOf((*runtime.Func)(nil)),
"MemProfileRecord": reflect.ValueOf((*runtime.MemProfileRecord)(nil)),
"MemStats": reflect.ValueOf((*runtime.MemStats)(nil)),
"PanicNilError": reflect.ValueOf((*runtime.PanicNilError)(nil)),
"Pinner": reflect.ValueOf((*runtime.Pinner)(nil)),
"StackRecord": reflect.ValueOf((*runtime.StackRecord)(nil)),
"TypeAssertionError": reflect.ValueOf((*runtime.TypeAssertionError)(nil)),
// interface wrapper definitions
"_Error": reflect.ValueOf((*_runtime_Error)(nil)),
}
}
// _runtime_Error is an interface wrapper for Error type
type _runtime_Error struct {
IValue interface{}
WError func() string
WRuntimeError func()
}
func (W _runtime_Error) Error() string { return W.WError() }
func (W _runtime_Error) RuntimeError() { W.WRuntimeError() }
================================================
FILE: stdlib/go1_21_runtime_debug.go
================================================
// Code generated by 'yaegi extract runtime/debug'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"reflect"
"runtime/debug"
)
func init() {
Symbols["runtime/debug/debug"] = map[string]reflect.Value{
// function, constant and variable definitions
"FreeOSMemory": reflect.ValueOf(debug.FreeOSMemory),
"ParseBuildInfo": reflect.ValueOf(debug.ParseBuildInfo),
"PrintStack": reflect.ValueOf(debug.PrintStack),
"ReadBuildInfo": reflect.ValueOf(debug.ReadBuildInfo),
"ReadGCStats": reflect.ValueOf(debug.ReadGCStats),
"SetGCPercent": reflect.ValueOf(debug.SetGCPercent),
"SetMaxStack": reflect.ValueOf(debug.SetMaxStack),
"SetMaxThreads": reflect.ValueOf(debug.SetMaxThreads),
"SetMemoryLimit": reflect.ValueOf(debug.SetMemoryLimit),
"SetPanicOnFault": reflect.ValueOf(debug.SetPanicOnFault),
"SetTraceback": reflect.ValueOf(debug.SetTraceback),
"Stack": reflect.ValueOf(debug.Stack),
"WriteHeapDump": reflect.ValueOf(debug.WriteHeapDump),
// type definitions
"BuildInfo": reflect.ValueOf((*debug.BuildInfo)(nil)),
"BuildSetting": reflect.ValueOf((*debug.BuildSetting)(nil)),
"GCStats": reflect.ValueOf((*debug.GCStats)(nil)),
"Module": reflect.ValueOf((*debug.Module)(nil)),
}
}
================================================
FILE: stdlib/go1_21_runtime_metrics.go
================================================
// Code generated by 'yaegi extract runtime/metrics'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"reflect"
"runtime/metrics"
)
func init() {
Symbols["runtime/metrics/metrics"] = map[string]reflect.Value{
// function, constant and variable definitions
"All": reflect.ValueOf(metrics.All),
"KindBad": reflect.ValueOf(metrics.KindBad),
"KindFloat64": reflect.ValueOf(metrics.KindFloat64),
"KindFloat64Histogram": reflect.ValueOf(metrics.KindFloat64Histogram),
"KindUint64": reflect.ValueOf(metrics.KindUint64),
"Read": reflect.ValueOf(metrics.Read),
// type definitions
"Description": reflect.ValueOf((*metrics.Description)(nil)),
"Float64Histogram": reflect.ValueOf((*metrics.Float64Histogram)(nil)),
"Sample": reflect.ValueOf((*metrics.Sample)(nil)),
"Value": reflect.ValueOf((*metrics.Value)(nil)),
"ValueKind": reflect.ValueOf((*metrics.ValueKind)(nil)),
}
}
================================================
FILE: stdlib/go1_21_runtime_pprof.go
================================================
// Code generated by 'yaegi extract runtime/pprof'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"reflect"
"runtime/pprof"
)
func init() {
Symbols["runtime/pprof/pprof"] = map[string]reflect.Value{
// function, constant and variable definitions
"Do": reflect.ValueOf(pprof.Do),
"ForLabels": reflect.ValueOf(pprof.ForLabels),
"Label": reflect.ValueOf(pprof.Label),
"Labels": reflect.ValueOf(pprof.Labels),
"Lookup": reflect.ValueOf(pprof.Lookup),
"NewProfile": reflect.ValueOf(pprof.NewProfile),
"Profiles": reflect.ValueOf(pprof.Profiles),
"SetGoroutineLabels": reflect.ValueOf(pprof.SetGoroutineLabels),
"StartCPUProfile": reflect.ValueOf(pprof.StartCPUProfile),
"StopCPUProfile": reflect.ValueOf(pprof.StopCPUProfile),
"WithLabels": reflect.ValueOf(pprof.WithLabels),
"WriteHeapProfile": reflect.ValueOf(pprof.WriteHeapProfile),
// type definitions
"LabelSet": reflect.ValueOf((*pprof.LabelSet)(nil)),
"Profile": reflect.ValueOf((*pprof.Profile)(nil)),
}
}
================================================
FILE: stdlib/go1_21_runtime_trace.go
================================================
// Code generated by 'yaegi extract runtime/trace'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"reflect"
"runtime/trace"
)
func init() {
Symbols["runtime/trace/trace"] = map[string]reflect.Value{
// function, constant and variable definitions
"IsEnabled": reflect.ValueOf(trace.IsEnabled),
"Log": reflect.ValueOf(trace.Log),
"Logf": reflect.ValueOf(trace.Logf),
"NewTask": reflect.ValueOf(trace.NewTask),
"Start": reflect.ValueOf(trace.Start),
"StartRegion": reflect.ValueOf(trace.StartRegion),
"Stop": reflect.ValueOf(trace.Stop),
"WithRegion": reflect.ValueOf(trace.WithRegion),
// type definitions
"Region": reflect.ValueOf((*trace.Region)(nil)),
"Task": reflect.ValueOf((*trace.Task)(nil)),
}
}
================================================
FILE: stdlib/go1_21_slices.go
================================================
// Code generated by 'yaegi extract slices'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"reflect"
)
func init() {
Symbols["slices/slices"] = map[string]reflect.Value{}
}
================================================
FILE: stdlib/go1_21_sort.go
================================================
// Code generated by 'yaegi extract sort'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"reflect"
"sort"
)
func init() {
Symbols["sort/sort"] = map[string]reflect.Value{
// function, constant and variable definitions
"Find": reflect.ValueOf(sort.Find),
"Float64s": reflect.ValueOf(sort.Float64s),
"Float64sAreSorted": reflect.ValueOf(sort.Float64sAreSorted),
"Ints": reflect.ValueOf(sort.Ints),
"IntsAreSorted": reflect.ValueOf(sort.IntsAreSorted),
"IsSorted": reflect.ValueOf(sort.IsSorted),
"Reverse": reflect.ValueOf(sort.Reverse),
"Search": reflect.ValueOf(sort.Search),
"SearchFloat64s": reflect.ValueOf(sort.SearchFloat64s),
"SearchInts": reflect.ValueOf(sort.SearchInts),
"SearchStrings": reflect.ValueOf(sort.SearchStrings),
"Slice": reflect.ValueOf(sort.Slice),
"SliceIsSorted": reflect.ValueOf(sort.SliceIsSorted),
"SliceStable": reflect.ValueOf(sort.SliceStable),
"Sort": reflect.ValueOf(sort.Sort),
"Stable": reflect.ValueOf(sort.Stable),
"Strings": reflect.ValueOf(sort.Strings),
"StringsAreSorted": reflect.ValueOf(sort.StringsAreSorted),
// type definitions
"Float64Slice": reflect.ValueOf((*sort.Float64Slice)(nil)),
"IntSlice": reflect.ValueOf((*sort.IntSlice)(nil)),
"Interface": reflect.ValueOf((*sort.Interface)(nil)),
"StringSlice": reflect.ValueOf((*sort.StringSlice)(nil)),
// interface wrapper definitions
"_Interface": reflect.ValueOf((*_sort_Interface)(nil)),
}
}
// _sort_Interface is an interface wrapper for Interface type
type _sort_Interface struct {
IValue interface{}
WLen func() int
WLess func(i int, j int) bool
WSwap func(i int, j int)
}
func (W _sort_Interface) Len() int { return W.WLen() }
func (W _sort_Interface) Less(i int, j int) bool { return W.WLess(i, j) }
func (W _sort_Interface) Swap(i int, j int) { W.WSwap(i, j) }
================================================
FILE: stdlib/go1_21_strconv.go
================================================
// Code generated by 'yaegi extract strconv'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"go/constant"
"go/token"
"reflect"
"strconv"
)
func init() {
Symbols["strconv/strconv"] = map[string]reflect.Value{
// function, constant and variable definitions
"AppendBool": reflect.ValueOf(strconv.AppendBool),
"AppendFloat": reflect.ValueOf(strconv.AppendFloat),
"AppendInt": reflect.ValueOf(strconv.AppendInt),
"AppendQuote": reflect.ValueOf(strconv.AppendQuote),
"AppendQuoteRune": reflect.ValueOf(strconv.AppendQuoteRune),
"AppendQuoteRuneToASCII": reflect.ValueOf(strconv.AppendQuoteRuneToASCII),
"AppendQuoteRuneToGraphic": reflect.ValueOf(strconv.AppendQuoteRuneToGraphic),
"AppendQuoteToASCII": reflect.ValueOf(strconv.AppendQuoteToASCII),
"AppendQuoteToGraphic": reflect.ValueOf(strconv.AppendQuoteToGraphic),
"AppendUint": reflect.ValueOf(strconv.AppendUint),
"Atoi": reflect.ValueOf(strconv.Atoi),
"CanBackquote": reflect.ValueOf(strconv.CanBackquote),
"ErrRange": reflect.ValueOf(&strconv.ErrRange).Elem(),
"ErrSyntax": reflect.ValueOf(&strconv.ErrSyntax).Elem(),
"FormatBool": reflect.ValueOf(strconv.FormatBool),
"FormatComplex": reflect.ValueOf(strconv.FormatComplex),
"FormatFloat": reflect.ValueOf(strconv.FormatFloat),
"FormatInt": reflect.ValueOf(strconv.FormatInt),
"FormatUint": reflect.ValueOf(strconv.FormatUint),
"IntSize": reflect.ValueOf(constant.MakeFromLiteral("64", token.INT, 0)),
"IsGraphic": reflect.ValueOf(strconv.IsGraphic),
"IsPrint": reflect.ValueOf(strconv.IsPrint),
"Itoa": reflect.ValueOf(strconv.Itoa),
"ParseBool": reflect.ValueOf(strconv.ParseBool),
"ParseComplex": reflect.ValueOf(strconv.ParseComplex),
"ParseFloat": reflect.ValueOf(strconv.ParseFloat),
"ParseInt": reflect.ValueOf(strconv.ParseInt),
"ParseUint": reflect.ValueOf(strconv.ParseUint),
"Quote": reflect.ValueOf(strconv.Quote),
"QuoteRune": reflect.ValueOf(strconv.QuoteRune),
"QuoteRuneToASCII": reflect.ValueOf(strconv.QuoteRuneToASCII),
"QuoteRuneToGraphic": reflect.ValueOf(strconv.QuoteRuneToGraphic),
"QuoteToASCII": reflect.ValueOf(strconv.QuoteToASCII),
"QuoteToGraphic": reflect.ValueOf(strconv.QuoteToGraphic),
"QuotedPrefix": reflect.ValueOf(strconv.QuotedPrefix),
"Unquote": reflect.ValueOf(strconv.Unquote),
"UnquoteChar": reflect.ValueOf(strconv.UnquoteChar),
// type definitions
"NumError": reflect.ValueOf((*strconv.NumError)(nil)),
}
}
================================================
FILE: stdlib/go1_21_strings.go
================================================
// Code generated by 'yaegi extract strings'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"reflect"
"strings"
)
func init() {
Symbols["strings/strings"] = map[string]reflect.Value{
// function, constant and variable definitions
"Clone": reflect.ValueOf(strings.Clone),
"Compare": reflect.ValueOf(strings.Compare),
"Contains": reflect.ValueOf(strings.Contains),
"ContainsAny": reflect.ValueOf(strings.ContainsAny),
"ContainsFunc": reflect.ValueOf(strings.ContainsFunc),
"ContainsRune": reflect.ValueOf(strings.ContainsRune),
"Count": reflect.ValueOf(strings.Count),
"Cut": reflect.ValueOf(strings.Cut),
"CutPrefix": reflect.ValueOf(strings.CutPrefix),
"CutSuffix": reflect.ValueOf(strings.CutSuffix),
"EqualFold": reflect.ValueOf(strings.EqualFold),
"Fields": reflect.ValueOf(strings.Fields),
"FieldsFunc": reflect.ValueOf(strings.FieldsFunc),
"HasPrefix": reflect.ValueOf(strings.HasPrefix),
"HasSuffix": reflect.ValueOf(strings.HasSuffix),
"Index": reflect.ValueOf(strings.Index),
"IndexAny": reflect.ValueOf(strings.IndexAny),
"IndexByte": reflect.ValueOf(strings.IndexByte),
"IndexFunc": reflect.ValueOf(strings.IndexFunc),
"IndexRune": reflect.ValueOf(strings.IndexRune),
"Join": reflect.ValueOf(strings.Join),
"LastIndex": reflect.ValueOf(strings.LastIndex),
"LastIndexAny": reflect.ValueOf(strings.LastIndexAny),
"LastIndexByte": reflect.ValueOf(strings.LastIndexByte),
"LastIndexFunc": reflect.ValueOf(strings.LastIndexFunc),
"Map": reflect.ValueOf(strings.Map),
"NewReader": reflect.ValueOf(strings.NewReader),
"NewReplacer": reflect.ValueOf(strings.NewReplacer),
"Repeat": reflect.ValueOf(strings.Repeat),
"Replace": reflect.ValueOf(strings.Replace),
"ReplaceAll": reflect.ValueOf(strings.ReplaceAll),
"Split": reflect.ValueOf(strings.Split),
"SplitAfter": reflect.ValueOf(strings.SplitAfter),
"SplitAfterN": reflect.ValueOf(strings.SplitAfterN),
"SplitN": reflect.ValueOf(strings.SplitN),
"Title": reflect.ValueOf(strings.Title),
"ToLower": reflect.ValueOf(strings.ToLower),
"ToLowerSpecial": reflect.ValueOf(strings.ToLowerSpecial),
"ToTitle": reflect.ValueOf(strings.ToTitle),
"ToTitleSpecial": reflect.ValueOf(strings.ToTitleSpecial),
"ToUpper": reflect.ValueOf(strings.ToUpper),
"ToUpperSpecial": reflect.ValueOf(strings.ToUpperSpecial),
"ToValidUTF8": reflect.ValueOf(strings.ToValidUTF8),
"Trim": reflect.ValueOf(strings.Trim),
"TrimFunc": reflect.ValueOf(strings.TrimFunc),
"TrimLeft": reflect.ValueOf(strings.TrimLeft),
"TrimLeftFunc": reflect.ValueOf(strings.TrimLeftFunc),
"TrimPrefix": reflect.ValueOf(strings.TrimPrefix),
"TrimRight": reflect.ValueOf(strings.TrimRight),
"TrimRightFunc": reflect.ValueOf(strings.TrimRightFunc),
"TrimSpace": reflect.ValueOf(strings.TrimSpace),
"TrimSuffix": reflect.ValueOf(strings.TrimSuffix),
// type definitions
"Builder": reflect.ValueOf((*strings.Builder)(nil)),
"Reader": reflect.ValueOf((*strings.Reader)(nil)),
"Replacer": reflect.ValueOf((*strings.Replacer)(nil)),
}
}
================================================
FILE: stdlib/go1_21_sync.go
================================================
// Code generated by 'yaegi extract sync'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"reflect"
"sync"
)
func init() {
Symbols["sync/sync"] = map[string]reflect.Value{
// function, constant and variable definitions
"NewCond": reflect.ValueOf(sync.NewCond),
"OnceFunc": reflect.ValueOf(sync.OnceFunc),
// type definitions
"Cond": reflect.ValueOf((*sync.Cond)(nil)),
"Locker": reflect.ValueOf((*sync.Locker)(nil)),
"Map": reflect.ValueOf((*sync.Map)(nil)),
"Mutex": reflect.ValueOf((*sync.Mutex)(nil)),
"Once": reflect.ValueOf((*sync.Once)(nil)),
"Pool": reflect.ValueOf((*sync.Pool)(nil)),
"RWMutex": reflect.ValueOf((*sync.RWMutex)(nil)),
"WaitGroup": reflect.ValueOf((*sync.WaitGroup)(nil)),
// interface wrapper definitions
"_Locker": reflect.ValueOf((*_sync_Locker)(nil)),
}
}
// _sync_Locker is an interface wrapper for Locker type
type _sync_Locker struct {
IValue interface{}
WLock func()
WUnlock func()
}
func (W _sync_Locker) Lock() { W.WLock() }
func (W _sync_Locker) Unlock() { W.WUnlock() }
================================================
FILE: stdlib/go1_21_sync_atomic.go
================================================
// Code generated by 'yaegi extract sync/atomic'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"reflect"
"sync/atomic"
)
func init() {
Symbols["sync/atomic/atomic"] = map[string]reflect.Value{
// function, constant and variable definitions
"AddInt32": reflect.ValueOf(atomic.AddInt32),
"AddInt64": reflect.ValueOf(atomic.AddInt64),
"AddUint32": reflect.ValueOf(atomic.AddUint32),
"AddUint64": reflect.ValueOf(atomic.AddUint64),
"AddUintptr": reflect.ValueOf(atomic.AddUintptr),
"CompareAndSwapInt32": reflect.ValueOf(atomic.CompareAndSwapInt32),
"CompareAndSwapInt64": reflect.ValueOf(atomic.CompareAndSwapInt64),
"CompareAndSwapPointer": reflect.ValueOf(atomic.CompareAndSwapPointer),
"CompareAndSwapUint32": reflect.ValueOf(atomic.CompareAndSwapUint32),
"CompareAndSwapUint64": reflect.ValueOf(atomic.CompareAndSwapUint64),
"CompareAndSwapUintptr": reflect.ValueOf(atomic.CompareAndSwapUintptr),
"LoadInt32": reflect.ValueOf(atomic.LoadInt32),
"LoadInt64": reflect.ValueOf(atomic.LoadInt64),
"LoadPointer": reflect.ValueOf(atomic.LoadPointer),
"LoadUint32": reflect.ValueOf(atomic.LoadUint32),
"LoadUint64": reflect.ValueOf(atomic.LoadUint64),
"LoadUintptr": reflect.ValueOf(atomic.LoadUintptr),
"StoreInt32": reflect.ValueOf(atomic.StoreInt32),
"StoreInt64": reflect.ValueOf(atomic.StoreInt64),
"StorePointer": reflect.ValueOf(atomic.StorePointer),
"StoreUint32": reflect.ValueOf(atomic.StoreUint32),
"StoreUint64": reflect.ValueOf(atomic.StoreUint64),
"StoreUintptr": reflect.ValueOf(atomic.StoreUintptr),
"SwapInt32": reflect.ValueOf(atomic.SwapInt32),
"SwapInt64": reflect.ValueOf(atomic.SwapInt64),
"SwapPointer": reflect.ValueOf(atomic.SwapPointer),
"SwapUint32": reflect.ValueOf(atomic.SwapUint32),
"SwapUint64": reflect.ValueOf(atomic.SwapUint64),
"SwapUintptr": reflect.ValueOf(atomic.SwapUintptr),
// type definitions
"Bool": reflect.ValueOf((*atomic.Bool)(nil)),
"Int32": reflect.ValueOf((*atomic.Int32)(nil)),
"Int64": reflect.ValueOf((*atomic.Int64)(nil)),
"Uint32": reflect.ValueOf((*atomic.Uint32)(nil)),
"Uint64": reflect.ValueOf((*atomic.Uint64)(nil)),
"Uintptr": reflect.ValueOf((*atomic.Uintptr)(nil)),
"Value": reflect.ValueOf((*atomic.Value)(nil)),
}
}
================================================
FILE: stdlib/go1_21_testing.go
================================================
// Code generated by 'yaegi extract testing'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"reflect"
"testing"
)
func init() {
Symbols["testing/testing"] = map[string]reflect.Value{
// function, constant and variable definitions
"AllocsPerRun": reflect.ValueOf(testing.AllocsPerRun),
"Benchmark": reflect.ValueOf(testing.Benchmark),
"CoverMode": reflect.ValueOf(testing.CoverMode),
"Coverage": reflect.ValueOf(testing.Coverage),
"Init": reflect.ValueOf(testing.Init),
"Main": reflect.ValueOf(testing.Main),
"MainStart": reflect.ValueOf(testing.MainStart),
"RegisterCover": reflect.ValueOf(testing.RegisterCover),
"RunBenchmarks": reflect.ValueOf(testing.RunBenchmarks),
"RunExamples": reflect.ValueOf(testing.RunExamples),
"RunTests": reflect.ValueOf(testing.RunTests),
"Short": reflect.ValueOf(testing.Short),
"Testing": reflect.ValueOf(testing.Testing),
"Verbose": reflect.ValueOf(testing.Verbose),
// type definitions
"B": reflect.ValueOf((*testing.B)(nil)),
"BenchmarkResult": reflect.ValueOf((*testing.BenchmarkResult)(nil)),
"Cover": reflect.ValueOf((*testing.Cover)(nil)),
"CoverBlock": reflect.ValueOf((*testing.CoverBlock)(nil)),
"F": reflect.ValueOf((*testing.F)(nil)),
"InternalBenchmark": reflect.ValueOf((*testing.InternalBenchmark)(nil)),
"InternalExample": reflect.ValueOf((*testing.InternalExample)(nil)),
"InternalFuzzTarget": reflect.ValueOf((*testing.InternalFuzzTarget)(nil)),
"InternalTest": reflect.ValueOf((*testing.InternalTest)(nil)),
"M": reflect.ValueOf((*testing.M)(nil)),
"PB": reflect.ValueOf((*testing.PB)(nil)),
"T": reflect.ValueOf((*testing.T)(nil)),
"TB": reflect.ValueOf((*testing.TB)(nil)),
// interface wrapper definitions
"_TB": reflect.ValueOf((*_testing_TB)(nil)),
}
}
// _testing_TB is an interface wrapper for TB type
type _testing_TB struct {
IValue interface{}
WCleanup func(a0 func())
WError func(args ...any)
WErrorf func(format string, args ...any)
WFail func()
WFailNow func()
WFailed func() bool
WFatal func(args ...any)
WFatalf func(format string, args ...any)
WHelper func()
WLog func(args ...any)
WLogf func(format string, args ...any)
WName func() string
WSetenv func(key string, value string)
WSkip func(args ...any)
WSkipNow func()
WSkipf func(format string, args ...any)
WSkipped func() bool
WTempDir func() string
}
func (W _testing_TB) Cleanup(a0 func()) { W.WCleanup(a0) }
func (W _testing_TB) Error(args ...any) { W.WError(args...) }
func (W _testing_TB) Errorf(format string, args ...any) { W.WErrorf(format, args...) }
func (W _testing_TB) Fail() { W.WFail() }
func (W _testing_TB) FailNow() { W.WFailNow() }
func (W _testing_TB) Failed() bool { return W.WFailed() }
func (W _testing_TB) Fatal(args ...any) { W.WFatal(args...) }
func (W _testing_TB) Fatalf(format string, args ...any) { W.WFatalf(format, args...) }
func (W _testing_TB) Helper() { W.WHelper() }
func (W _testing_TB) Log(args ...any) { W.WLog(args...) }
func (W _testing_TB) Logf(format string, args ...any) { W.WLogf(format, args...) }
func (W _testing_TB) Name() string { return W.WName() }
func (W _testing_TB) Setenv(key string, value string) { W.WSetenv(key, value) }
func (W _testing_TB) Skip(args ...any) { W.WSkip(args...) }
func (W _testing_TB) SkipNow() { W.WSkipNow() }
func (W _testing_TB) Skipf(format string, args ...any) { W.WSkipf(format, args...) }
func (W _testing_TB) Skipped() bool { return W.WSkipped() }
func (W _testing_TB) TempDir() string { return W.WTempDir() }
================================================
FILE: stdlib/go1_21_testing_fstest.go
================================================
// Code generated by 'yaegi extract testing/fstest'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"reflect"
"testing/fstest"
)
func init() {
Symbols["testing/fstest/fstest"] = map[string]reflect.Value{
// function, constant and variable definitions
"TestFS": reflect.ValueOf(fstest.TestFS),
// type definitions
"MapFS": reflect.ValueOf((*fstest.MapFS)(nil)),
"MapFile": reflect.ValueOf((*fstest.MapFile)(nil)),
}
}
================================================
FILE: stdlib/go1_21_testing_iotest.go
================================================
// Code generated by 'yaegi extract testing/iotest'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"reflect"
"testing/iotest"
)
func init() {
Symbols["testing/iotest/iotest"] = map[string]reflect.Value{
// function, constant and variable definitions
"DataErrReader": reflect.ValueOf(iotest.DataErrReader),
"ErrReader": reflect.ValueOf(iotest.ErrReader),
"ErrTimeout": reflect.ValueOf(&iotest.ErrTimeout).Elem(),
"HalfReader": reflect.ValueOf(iotest.HalfReader),
"NewReadLogger": reflect.ValueOf(iotest.NewReadLogger),
"NewWriteLogger": reflect.ValueOf(iotest.NewWriteLogger),
"OneByteReader": reflect.ValueOf(iotest.OneByteReader),
"TestReader": reflect.ValueOf(iotest.TestReader),
"TimeoutReader": reflect.ValueOf(iotest.TimeoutReader),
"TruncateWriter": reflect.ValueOf(iotest.TruncateWriter),
}
}
================================================
FILE: stdlib/go1_21_testing_quick.go
================================================
// Code generated by 'yaegi extract testing/quick'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"math/rand"
"reflect"
"testing/quick"
)
func init() {
Symbols["testing/quick/quick"] = map[string]reflect.Value{
// function, constant and variable definitions
"Check": reflect.ValueOf(quick.Check),
"CheckEqual": reflect.ValueOf(quick.CheckEqual),
"Value": reflect.ValueOf(quick.Value),
// type definitions
"CheckEqualError": reflect.ValueOf((*quick.CheckEqualError)(nil)),
"CheckError": reflect.ValueOf((*quick.CheckError)(nil)),
"Config": reflect.ValueOf((*quick.Config)(nil)),
"Generator": reflect.ValueOf((*quick.Generator)(nil)),
"SetupError": reflect.ValueOf((*quick.SetupError)(nil)),
// interface wrapper definitions
"_Generator": reflect.ValueOf((*_testing_quick_Generator)(nil)),
}
}
// _testing_quick_Generator is an interface wrapper for Generator type
type _testing_quick_Generator struct {
IValue interface{}
WGenerate func(rand *rand.Rand, size int) reflect.Value
}
func (W _testing_quick_Generator) Generate(rand *rand.Rand, size int) reflect.Value {
return W.WGenerate(rand, size)
}
================================================
FILE: stdlib/go1_21_testing_slogtest.go
================================================
// Code generated by 'yaegi extract testing/slogtest'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"reflect"
"testing/slogtest"
)
func init() {
Symbols["testing/slogtest/slogtest"] = map[string]reflect.Value{
// function, constant and variable definitions
"TestHandler": reflect.ValueOf(slogtest.TestHandler),
}
}
================================================
FILE: stdlib/go1_21_text_scanner.go
================================================
// Code generated by 'yaegi extract text/scanner'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"go/constant"
"go/token"
"reflect"
"text/scanner"
)
func init() {
Symbols["text/scanner/scanner"] = map[string]reflect.Value{
// function, constant and variable definitions
"Char": reflect.ValueOf(constant.MakeFromLiteral("-5", token.INT, 0)),
"Comment": reflect.ValueOf(constant.MakeFromLiteral("-8", token.INT, 0)),
"EOF": reflect.ValueOf(constant.MakeFromLiteral("-1", token.INT, 0)),
"Float": reflect.ValueOf(constant.MakeFromLiteral("-4", token.INT, 0)),
"GoTokens": reflect.ValueOf(constant.MakeFromLiteral("1012", token.INT, 0)),
"GoWhitespace": reflect.ValueOf(constant.MakeFromLiteral("4294977024", token.INT, 0)),
"Ident": reflect.ValueOf(constant.MakeFromLiteral("-2", token.INT, 0)),
"Int": reflect.ValueOf(constant.MakeFromLiteral("-3", token.INT, 0)),
"RawString": reflect.ValueOf(constant.MakeFromLiteral("-7", token.INT, 0)),
"ScanChars": reflect.ValueOf(constant.MakeFromLiteral("32", token.INT, 0)),
"ScanComments": reflect.ValueOf(constant.MakeFromLiteral("256", token.INT, 0)),
"ScanFloats": reflect.ValueOf(constant.MakeFromLiteral("16", token.INT, 0)),
"ScanIdents": reflect.ValueOf(constant.MakeFromLiteral("4", token.INT, 0)),
"ScanInts": reflect.ValueOf(constant.MakeFromLiteral("8", token.INT, 0)),
"ScanRawStrings": reflect.ValueOf(constant.MakeFromLiteral("128", token.INT, 0)),
"ScanStrings": reflect.ValueOf(constant.MakeFromLiteral("64", token.INT, 0)),
"SkipComments": reflect.ValueOf(constant.MakeFromLiteral("512", token.INT, 0)),
"String": reflect.ValueOf(constant.MakeFromLiteral("-6", token.INT, 0)),
"TokenString": reflect.ValueOf(scanner.TokenString),
// type definitions
"Position": reflect.ValueOf((*scanner.Position)(nil)),
"Scanner": reflect.ValueOf((*scanner.Scanner)(nil)),
}
}
================================================
FILE: stdlib/go1_21_text_tabwriter.go
================================================
// Code generated by 'yaegi extract text/tabwriter'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"go/constant"
"go/token"
"reflect"
"text/tabwriter"
)
func init() {
Symbols["text/tabwriter/tabwriter"] = map[string]reflect.Value{
// function, constant and variable definitions
"AlignRight": reflect.ValueOf(tabwriter.AlignRight),
"Debug": reflect.ValueOf(tabwriter.Debug),
"DiscardEmptyColumns": reflect.ValueOf(tabwriter.DiscardEmptyColumns),
"Escape": reflect.ValueOf(constant.MakeFromLiteral("255", token.INT, 0)),
"FilterHTML": reflect.ValueOf(tabwriter.FilterHTML),
"NewWriter": reflect.ValueOf(tabwriter.NewWriter),
"StripEscape": reflect.ValueOf(tabwriter.StripEscape),
"TabIndent": reflect.ValueOf(tabwriter.TabIndent),
// type definitions
"Writer": reflect.ValueOf((*tabwriter.Writer)(nil)),
}
}
================================================
FILE: stdlib/go1_21_text_template.go
================================================
// Code generated by 'yaegi extract text/template'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"reflect"
"text/template"
)
func init() {
Symbols["text/template/template"] = map[string]reflect.Value{
// function, constant and variable definitions
"HTMLEscape": reflect.ValueOf(template.HTMLEscape),
"HTMLEscapeString": reflect.ValueOf(template.HTMLEscapeString),
"HTMLEscaper": reflect.ValueOf(template.HTMLEscaper),
"IsTrue": reflect.ValueOf(template.IsTrue),
"JSEscape": reflect.ValueOf(template.JSEscape),
"JSEscapeString": reflect.ValueOf(template.JSEscapeString),
"JSEscaper": reflect.ValueOf(template.JSEscaper),
"Must": reflect.ValueOf(template.Must),
"New": reflect.ValueOf(template.New),
"ParseFS": reflect.ValueOf(template.ParseFS),
"ParseFiles": reflect.ValueOf(template.ParseFiles),
"ParseGlob": reflect.ValueOf(template.ParseGlob),
"URLQueryEscaper": reflect.ValueOf(template.URLQueryEscaper),
// type definitions
"ExecError": reflect.ValueOf((*template.ExecError)(nil)),
"FuncMap": reflect.ValueOf((*template.FuncMap)(nil)),
"Template": reflect.ValueOf((*template.Template)(nil)),
}
}
================================================
FILE: stdlib/go1_21_text_template_parse.go
================================================
// Code generated by 'yaegi extract text/template/parse'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"reflect"
"text/template/parse"
)
func init() {
Symbols["text/template/parse/parse"] = map[string]reflect.Value{
// function, constant and variable definitions
"IsEmptyTree": reflect.ValueOf(parse.IsEmptyTree),
"New": reflect.ValueOf(parse.New),
"NewIdentifier": reflect.ValueOf(parse.NewIdentifier),
"NodeAction": reflect.ValueOf(parse.NodeAction),
"NodeBool": reflect.ValueOf(parse.NodeBool),
"NodeBreak": reflect.ValueOf(parse.NodeBreak),
"NodeChain": reflect.ValueOf(parse.NodeChain),
"NodeCommand": reflect.ValueOf(parse.NodeCommand),
"NodeComment": reflect.ValueOf(parse.NodeComment),
"NodeContinue": reflect.ValueOf(parse.NodeContinue),
"NodeDot": reflect.ValueOf(parse.NodeDot),
"NodeField": reflect.ValueOf(parse.NodeField),
"NodeIdentifier": reflect.ValueOf(parse.NodeIdentifier),
"NodeIf": reflect.ValueOf(parse.NodeIf),
"NodeList": reflect.ValueOf(parse.NodeList),
"NodeNil": reflect.ValueOf(parse.NodeNil),
"NodeNumber": reflect.ValueOf(parse.NodeNumber),
"NodePipe": reflect.ValueOf(parse.NodePipe),
"NodeRange": reflect.ValueOf(parse.NodeRange),
"NodeString": reflect.ValueOf(parse.NodeString),
"NodeTemplate": reflect.ValueOf(parse.NodeTemplate),
"NodeText": reflect.ValueOf(parse.NodeText),
"NodeVariable": reflect.ValueOf(parse.NodeVariable),
"NodeWith": reflect.ValueOf(parse.NodeWith),
"Parse": reflect.ValueOf(parse.Parse),
"ParseComments": reflect.ValueOf(parse.ParseComments),
"SkipFuncCheck": reflect.ValueOf(parse.SkipFuncCheck),
// type definitions
"ActionNode": reflect.ValueOf((*parse.ActionNode)(nil)),
"BoolNode": reflect.ValueOf((*parse.BoolNode)(nil)),
"BranchNode": reflect.ValueOf((*parse.BranchNode)(nil)),
"BreakNode": reflect.ValueOf((*parse.BreakNode)(nil)),
"ChainNode": reflect.ValueOf((*parse.ChainNode)(nil)),
"CommandNode": reflect.ValueOf((*parse.CommandNode)(nil)),
"CommentNode": reflect.ValueOf((*parse.CommentNode)(nil)),
"ContinueNode": reflect.ValueOf((*parse.ContinueNode)(nil)),
"DotNode": reflect.ValueOf((*parse.DotNode)(nil)),
"FieldNode": reflect.ValueOf((*parse.FieldNode)(nil)),
"IdentifierNode": reflect.ValueOf((*parse.IdentifierNode)(nil)),
"IfNode": reflect.ValueOf((*parse.IfNode)(nil)),
"ListNode": reflect.ValueOf((*parse.ListNode)(nil)),
"Mode": reflect.ValueOf((*parse.Mode)(nil)),
"NilNode": reflect.ValueOf((*parse.NilNode)(nil)),
"Node": reflect.ValueOf((*parse.Node)(nil)),
"NodeType": reflect.ValueOf((*parse.NodeType)(nil)),
"NumberNode": reflect.ValueOf((*parse.NumberNode)(nil)),
"PipeNode": reflect.ValueOf((*parse.PipeNode)(nil)),
"Pos": reflect.ValueOf((*parse.Pos)(nil)),
"RangeNode": reflect.ValueOf((*parse.RangeNode)(nil)),
"StringNode": reflect.ValueOf((*parse.StringNode)(nil)),
"TemplateNode": reflect.ValueOf((*parse.TemplateNode)(nil)),
"TextNode": reflect.ValueOf((*parse.TextNode)(nil)),
"Tree": reflect.ValueOf((*parse.Tree)(nil)),
"VariableNode": reflect.ValueOf((*parse.VariableNode)(nil)),
"WithNode": reflect.ValueOf((*parse.WithNode)(nil)),
// interface wrapper definitions
"_Node": reflect.ValueOf((*_text_template_parse_Node)(nil)),
}
}
// _text_template_parse_Node is an interface wrapper for Node type
type _text_template_parse_Node struct {
IValue interface{}
WCopy func() parse.Node
WPosition func() parse.Pos
WString func() string
WType func() parse.NodeType
}
func (W _text_template_parse_Node) Copy() parse.Node { return W.WCopy() }
func (W _text_template_parse_Node) Position() parse.Pos { return W.WPosition() }
func (W _text_template_parse_Node) String() string {
if W.WString == nil {
return ""
}
return W.WString()
}
func (W _text_template_parse_Node) Type() parse.NodeType { return W.WType() }
================================================
FILE: stdlib/go1_21_time.go
================================================
// Code generated by 'yaegi extract time'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"go/constant"
"go/token"
"reflect"
"time"
)
func init() {
Symbols["time/time"] = map[string]reflect.Value{
// function, constant and variable definitions
"ANSIC": reflect.ValueOf(constant.MakeFromLiteral("\"Mon Jan _2 15:04:05 2006\"", token.STRING, 0)),
"After": reflect.ValueOf(time.After),
"AfterFunc": reflect.ValueOf(time.AfterFunc),
"April": reflect.ValueOf(time.April),
"August": reflect.ValueOf(time.August),
"Date": reflect.ValueOf(time.Date),
"DateOnly": reflect.ValueOf(constant.MakeFromLiteral("\"2006-01-02\"", token.STRING, 0)),
"DateTime": reflect.ValueOf(constant.MakeFromLiteral("\"2006-01-02 15:04:05\"", token.STRING, 0)),
"December": reflect.ValueOf(time.December),
"February": reflect.ValueOf(time.February),
"FixedZone": reflect.ValueOf(time.FixedZone),
"Friday": reflect.ValueOf(time.Friday),
"Hour": reflect.ValueOf(time.Hour),
"January": reflect.ValueOf(time.January),
"July": reflect.ValueOf(time.July),
"June": reflect.ValueOf(time.June),
"Kitchen": reflect.ValueOf(constant.MakeFromLiteral("\"3:04PM\"", token.STRING, 0)),
"Layout": reflect.ValueOf(constant.MakeFromLiteral("\"01/02 03:04:05PM '06 -0700\"", token.STRING, 0)),
"LoadLocation": reflect.ValueOf(time.LoadLocation),
"LoadLocationFromTZData": reflect.ValueOf(time.LoadLocationFromTZData),
"Local": reflect.ValueOf(&time.Local).Elem(),
"March": reflect.ValueOf(time.March),
"May": reflect.ValueOf(time.May),
"Microsecond": reflect.ValueOf(time.Microsecond),
"Millisecond": reflect.ValueOf(time.Millisecond),
"Minute": reflect.ValueOf(time.Minute),
"Monday": reflect.ValueOf(time.Monday),
"Nanosecond": reflect.ValueOf(time.Nanosecond),
"NewTicker": reflect.ValueOf(time.NewTicker),
"NewTimer": reflect.ValueOf(time.NewTimer),
"November": reflect.ValueOf(time.November),
"Now": reflect.ValueOf(time.Now),
"October": reflect.ValueOf(time.October),
"Parse": reflect.ValueOf(time.Parse),
"ParseDuration": reflect.ValueOf(time.ParseDuration),
"ParseInLocation": reflect.ValueOf(time.ParseInLocation),
"RFC1123": reflect.ValueOf(constant.MakeFromLiteral("\"Mon, 02 Jan 2006 15:04:05 MST\"", token.STRING, 0)),
"RFC1123Z": reflect.ValueOf(constant.MakeFromLiteral("\"Mon, 02 Jan 2006 15:04:05 -0700\"", token.STRING, 0)),
"RFC3339": reflect.ValueOf(constant.MakeFromLiteral("\"2006-01-02T15:04:05Z07:00\"", token.STRING, 0)),
"RFC3339Nano": reflect.ValueOf(constant.MakeFromLiteral("\"2006-01-02T15:04:05.999999999Z07:00\"", token.STRING, 0)),
"RFC822": reflect.ValueOf(constant.MakeFromLiteral("\"02 Jan 06 15:04 MST\"", token.STRING, 0)),
"RFC822Z": reflect.ValueOf(constant.MakeFromLiteral("\"02 Jan 06 15:04 -0700\"", token.STRING, 0)),
"RFC850": reflect.ValueOf(constant.MakeFromLiteral("\"Monday, 02-Jan-06 15:04:05 MST\"", token.STRING, 0)),
"RubyDate": reflect.ValueOf(constant.MakeFromLiteral("\"Mon Jan 02 15:04:05 -0700 2006\"", token.STRING, 0)),
"Saturday": reflect.ValueOf(time.Saturday),
"Second": reflect.ValueOf(time.Second),
"September": reflect.ValueOf(time.September),
"Since": reflect.ValueOf(time.Since),
"Sleep": reflect.ValueOf(time.Sleep),
"Stamp": reflect.ValueOf(constant.MakeFromLiteral("\"Jan _2 15:04:05\"", token.STRING, 0)),
"StampMicro": reflect.ValueOf(constant.MakeFromLiteral("\"Jan _2 15:04:05.000000\"", token.STRING, 0)),
"StampMilli": reflect.ValueOf(constant.MakeFromLiteral("\"Jan _2 15:04:05.000\"", token.STRING, 0)),
"StampNano": reflect.ValueOf(constant.MakeFromLiteral("\"Jan _2 15:04:05.000000000\"", token.STRING, 0)),
"Sunday": reflect.ValueOf(time.Sunday),
"Thursday": reflect.ValueOf(time.Thursday),
"Tick": reflect.ValueOf(time.Tick),
"TimeOnly": reflect.ValueOf(constant.MakeFromLiteral("\"15:04:05\"", token.STRING, 0)),
"Tuesday": reflect.ValueOf(time.Tuesday),
"UTC": reflect.ValueOf(&time.UTC).Elem(),
"Unix": reflect.ValueOf(time.Unix),
"UnixDate": reflect.ValueOf(constant.MakeFromLiteral("\"Mon Jan _2 15:04:05 MST 2006\"", token.STRING, 0)),
"UnixMicro": reflect.ValueOf(time.UnixMicro),
"UnixMilli": reflect.ValueOf(time.UnixMilli),
"Until": reflect.ValueOf(time.Until),
"Wednesday": reflect.ValueOf(time.Wednesday),
// type definitions
"Duration": reflect.ValueOf((*time.Duration)(nil)),
"Location": reflect.ValueOf((*time.Location)(nil)),
"Month": reflect.ValueOf((*time.Month)(nil)),
"ParseError": reflect.ValueOf((*time.ParseError)(nil)),
"Ticker": reflect.ValueOf((*time.Ticker)(nil)),
"Time": reflect.ValueOf((*time.Time)(nil)),
"Timer": reflect.ValueOf((*time.Timer)(nil)),
"Weekday": reflect.ValueOf((*time.Weekday)(nil)),
}
}
================================================
FILE: stdlib/go1_21_unicode.go
================================================
// Code generated by 'yaegi extract unicode'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"go/constant"
"go/token"
"reflect"
"unicode"
)
func init() {
Symbols["unicode/unicode"] = map[string]reflect.Value{
// function, constant and variable definitions
"ASCII_Hex_Digit": reflect.ValueOf(&unicode.ASCII_Hex_Digit).Elem(),
"Adlam": reflect.ValueOf(&unicode.Adlam).Elem(),
"Ahom": reflect.ValueOf(&unicode.Ahom).Elem(),
"Anatolian_Hieroglyphs": reflect.ValueOf(&unicode.Anatolian_Hieroglyphs).Elem(),
"Arabic": reflect.ValueOf(&unicode.Arabic).Elem(),
"Armenian": reflect.ValueOf(&unicode.Armenian).Elem(),
"Avestan": reflect.ValueOf(&unicode.Avestan).Elem(),
"AzeriCase": reflect.ValueOf(&unicode.AzeriCase).Elem(),
"Balinese": reflect.ValueOf(&unicode.Balinese).Elem(),
"Bamum": reflect.ValueOf(&unicode.Bamum).Elem(),
"Bassa_Vah": reflect.ValueOf(&unicode.Bassa_Vah).Elem(),
"Batak": reflect.ValueOf(&unicode.Batak).Elem(),
"Bengali": reflect.ValueOf(&unicode.Bengali).Elem(),
"Bhaiksuki": reflect.ValueOf(&unicode.Bhaiksuki).Elem(),
"Bidi_Control": reflect.ValueOf(&unicode.Bidi_Control).Elem(),
"Bopomofo": reflect.ValueOf(&unicode.Bopomofo).Elem(),
"Brahmi": reflect.ValueOf(&unicode.Brahmi).Elem(),
"Braille": reflect.ValueOf(&unicode.Braille).Elem(),
"Buginese": reflect.ValueOf(&unicode.Buginese).Elem(),
"Buhid": reflect.ValueOf(&unicode.Buhid).Elem(),
"C": reflect.ValueOf(&unicode.C).Elem(),
"Canadian_Aboriginal": reflect.ValueOf(&unicode.Canadian_Aboriginal).Elem(),
"Carian": reflect.ValueOf(&unicode.Carian).Elem(),
"CaseRanges": reflect.ValueOf(&unicode.CaseRanges).Elem(),
"Categories": reflect.ValueOf(&unicode.Categories).Elem(),
"Caucasian_Albanian": reflect.ValueOf(&unicode.Caucasian_Albanian).Elem(),
"Cc": reflect.ValueOf(&unicode.Cc).Elem(),
"Cf": reflect.ValueOf(&unicode.Cf).Elem(),
"Chakma": reflect.ValueOf(&unicode.Chakma).Elem(),
"Cham": reflect.ValueOf(&unicode.Cham).Elem(),
"Cherokee": reflect.ValueOf(&unicode.Cherokee).Elem(),
"Chorasmian": reflect.ValueOf(&unicode.Chorasmian).Elem(),
"Co": reflect.ValueOf(&unicode.Co).Elem(),
"Common": reflect.ValueOf(&unicode.Common).Elem(),
"Coptic": reflect.ValueOf(&unicode.Coptic).Elem(),
"Cs": reflect.ValueOf(&unicode.Cs).Elem(),
"Cuneiform": reflect.ValueOf(&unicode.Cuneiform).Elem(),
"Cypriot": reflect.ValueOf(&unicode.Cypriot).Elem(),
"Cypro_Minoan": reflect.ValueOf(&unicode.Cypro_Minoan).Elem(),
"Cyrillic": reflect.ValueOf(&unicode.Cyrillic).Elem(),
"Dash": reflect.ValueOf(&unicode.Dash).Elem(),
"Deprecated": reflect.ValueOf(&unicode.Deprecated).Elem(),
"Deseret": reflect.ValueOf(&unicode.Deseret).Elem(),
"Devanagari": reflect.ValueOf(&unicode.Devanagari).Elem(),
"Diacritic": reflect.ValueOf(&unicode.Diacritic).Elem(),
"Digit": reflect.ValueOf(&unicode.Digit).Elem(),
"Dives_Akuru": reflect.ValueOf(&unicode.Dives_Akuru).Elem(),
"Dogra": reflect.ValueOf(&unicode.Dogra).Elem(),
"Duployan": reflect.ValueOf(&unicode.Duployan).Elem(),
"Egyptian_Hieroglyphs": reflect.ValueOf(&unicode.Egyptian_Hieroglyphs).Elem(),
"Elbasan": reflect.ValueOf(&unicode.Elbasan).Elem(),
"Elymaic": reflect.ValueOf(&unicode.Elymaic).Elem(),
"Ethiopic": reflect.ValueOf(&unicode.Ethiopic).Elem(),
"Extender": reflect.ValueOf(&unicode.Extender).Elem(),
"FoldCategory": reflect.ValueOf(&unicode.FoldCategory).Elem(),
"FoldScript": reflect.ValueOf(&unicode.FoldScript).Elem(),
"Georgian": reflect.ValueOf(&unicode.Georgian).Elem(),
"Glagolitic": reflect.ValueOf(&unicode.Glagolitic).Elem(),
"Gothic": reflect.ValueOf(&unicode.Gothic).Elem(),
"Grantha": reflect.ValueOf(&unicode.Grantha).Elem(),
"GraphicRanges": reflect.ValueOf(&unicode.GraphicRanges).Elem(),
"Greek": reflect.ValueOf(&unicode.Greek).Elem(),
"Gujarati": reflect.ValueOf(&unicode.Gujarati).Elem(),
"Gunjala_Gondi": reflect.ValueOf(&unicode.Gunjala_Gondi).Elem(),
"Gurmukhi": reflect.ValueOf(&unicode.Gurmukhi).Elem(),
"Han": reflect.ValueOf(&unicode.Han).Elem(),
"Hangul": reflect.ValueOf(&unicode.Hangul).Elem(),
"Hanifi_Rohingya": reflect.ValueOf(&unicode.Hanifi_Rohingya).Elem(),
"Hanunoo": reflect.ValueOf(&unicode.Hanunoo).Elem(),
"Hatran": reflect.ValueOf(&unicode.Hatran).Elem(),
"Hebrew": reflect.ValueOf(&unicode.Hebrew).Elem(),
"Hex_Digit": reflect.ValueOf(&unicode.Hex_Digit).Elem(),
"Hiragana": reflect.ValueOf(&unicode.Hiragana).Elem(),
"Hyphen": reflect.ValueOf(&unicode.Hyphen).Elem(),
"IDS_Binary_Operator": reflect.ValueOf(&unicode.IDS_Binary_Operator).Elem(),
"IDS_Trinary_Operator": reflect.ValueOf(&unicode.IDS_Trinary_Operator).Elem(),
"Ideographic": reflect.ValueOf(&unicode.Ideographic).Elem(),
"Imperial_Aramaic": reflect.ValueOf(&unicode.Imperial_Aramaic).Elem(),
"In": reflect.ValueOf(unicode.In),
"Inherited": reflect.ValueOf(&unicode.Inherited).Elem(),
"Inscriptional_Pahlavi": reflect.ValueOf(&unicode.Inscriptional_Pahlavi).Elem(),
"Inscriptional_Parthian": reflect.ValueOf(&unicode.Inscriptional_Parthian).Elem(),
"Is": reflect.ValueOf(unicode.Is),
"IsControl": reflect.ValueOf(unicode.IsControl),
"IsDigit": reflect.ValueOf(unicode.IsDigit),
"IsGraphic": reflect.ValueOf(unicode.IsGraphic),
"IsLetter": reflect.ValueOf(unicode.IsLetter),
"IsLower": reflect.ValueOf(unicode.IsLower),
"IsMark": reflect.ValueOf(unicode.IsMark),
"IsNumber": reflect.ValueOf(unicode.IsNumber),
"IsOneOf": reflect.ValueOf(unicode.IsOneOf),
"IsPrint": reflect.ValueOf(unicode.IsPrint),
"IsPunct": reflect.ValueOf(unicode.IsPunct),
"IsSpace": reflect.ValueOf(unicode.IsSpace),
"IsSymbol": reflect.ValueOf(unicode.IsSymbol),
"IsTitle": reflect.ValueOf(unicode.IsTitle),
"IsUpper": reflect.ValueOf(unicode.IsUpper),
"Javanese": reflect.ValueOf(&unicode.Javanese).Elem(),
"Join_Control": reflect.ValueOf(&unicode.Join_Control).Elem(),
"Kaithi": reflect.ValueOf(&unicode.Kaithi).Elem(),
"Kannada": reflect.ValueOf(&unicode.Kannada).Elem(),
"Katakana": reflect.ValueOf(&unicode.Katakana).Elem(),
"Kawi": reflect.ValueOf(&unicode.Kawi).Elem(),
"Kayah_Li": reflect.ValueOf(&unicode.Kayah_Li).Elem(),
"Kharoshthi": reflect.ValueOf(&unicode.Kharoshthi).Elem(),
"Khitan_Small_Script": reflect.ValueOf(&unicode.Khitan_Small_Script).Elem(),
"Khmer": reflect.ValueOf(&unicode.Khmer).Elem(),
"Khojki": reflect.ValueOf(&unicode.Khojki).Elem(),
"Khudawadi": reflect.ValueOf(&unicode.Khudawadi).Elem(),
"L": reflect.ValueOf(&unicode.L).Elem(),
"Lao": reflect.ValueOf(&unicode.Lao).Elem(),
"Latin": reflect.ValueOf(&unicode.Latin).Elem(),
"Lepcha": reflect.ValueOf(&unicode.Lepcha).Elem(),
"Letter": reflect.ValueOf(&unicode.Letter).Elem(),
"Limbu": reflect.ValueOf(&unicode.Limbu).Elem(),
"Linear_A": reflect.ValueOf(&unicode.Linear_A).Elem(),
"Linear_B": reflect.ValueOf(&unicode.Linear_B).Elem(),
"Lisu": reflect.ValueOf(&unicode.Lisu).Elem(),
"Ll": reflect.ValueOf(&unicode.Ll).Elem(),
"Lm": reflect.ValueOf(&unicode.Lm).Elem(),
"Lo": reflect.ValueOf(&unicode.Lo).Elem(),
"Logical_Order_Exception": reflect.ValueOf(&unicode.Logical_Order_Exception).Elem(),
"Lower": reflect.ValueOf(&unicode.Lower).Elem(),
"LowerCase": reflect.ValueOf(constant.MakeFromLiteral("1", token.INT, 0)),
"Lt": reflect.ValueOf(&unicode.Lt).Elem(),
"Lu": reflect.ValueOf(&unicode.Lu).Elem(),
"Lycian": reflect.ValueOf(&unicode.Lycian).Elem(),
"Lydian": reflect.ValueOf(&unicode.Lydian).Elem(),
"M": reflect.ValueOf(&unicode.M).Elem(),
"Mahajani": reflect.ValueOf(&unicode.Mahajani).Elem(),
"Makasar": reflect.ValueOf(&unicode.Makasar).Elem(),
"Malayalam": reflect.ValueOf(&unicode.Malayalam).Elem(),
"Mandaic": reflect.ValueOf(&unicode.Mandaic).Elem(),
"Manichaean": reflect.ValueOf(&unicode.Manichaean).Elem(),
"Marchen": reflect.ValueOf(&unicode.Marchen).Elem(),
"Mark": reflect.ValueOf(&unicode.Mark).Elem(),
"Masaram_Gondi": reflect.ValueOf(&unicode.Masaram_Gondi).Elem(),
"MaxASCII": reflect.ValueOf(constant.MakeFromLiteral("127", token.INT, 0)),
"MaxCase": reflect.ValueOf(constant.MakeFromLiteral("3", token.INT, 0)),
"MaxLatin1": reflect.ValueOf(constant.MakeFromLiteral("255", token.INT, 0)),
"MaxRune": reflect.ValueOf(constant.MakeFromLiteral("1114111", token.INT, 0)),
"Mc": reflect.ValueOf(&unicode.Mc).Elem(),
"Me": reflect.ValueOf(&unicode.Me).Elem(),
"Medefaidrin": reflect.ValueOf(&unicode.Medefaidrin).Elem(),
"Meetei_Mayek": reflect.ValueOf(&unicode.Meetei_Mayek).Elem(),
"Mende_Kikakui": reflect.ValueOf(&unicode.Mende_Kikakui).Elem(),
"Meroitic_Cursive": reflect.ValueOf(&unicode.Meroitic_Cursive).Elem(),
"Meroitic_Hieroglyphs": reflect.ValueOf(&unicode.Meroitic_Hieroglyphs).Elem(),
"Miao": reflect.ValueOf(&unicode.Miao).Elem(),
"Mn": reflect.ValueOf(&unicode.Mn).Elem(),
"Modi": reflect.ValueOf(&unicode.Modi).Elem(),
"Mongolian": reflect.ValueOf(&unicode.Mongolian).Elem(),
"Mro": reflect.ValueOf(&unicode.Mro).Elem(),
"Multani": reflect.ValueOf(&unicode.Multani).Elem(),
"Myanmar": reflect.ValueOf(&unicode.Myanmar).Elem(),
"N": reflect.ValueOf(&unicode.N).Elem(),
"Nabataean": reflect.ValueOf(&unicode.Nabataean).Elem(),
"Nag_Mundari": reflect.ValueOf(&unicode.Nag_Mundari).Elem(),
"Nandinagari": reflect.ValueOf(&unicode.Nandinagari).Elem(),
"Nd": reflect.ValueOf(&unicode.Nd).Elem(),
"New_Tai_Lue": reflect.ValueOf(&unicode.New_Tai_Lue).Elem(),
"Newa": reflect.ValueOf(&unicode.Newa).Elem(),
"Nko": reflect.ValueOf(&unicode.Nko).Elem(),
"Nl": reflect.ValueOf(&unicode.Nl).Elem(),
"No": reflect.ValueOf(&unicode.No).Elem(),
"Noncharacter_Code_Point": reflect.ValueOf(&unicode.Noncharacter_Code_Point).Elem(),
"Number": reflect.ValueOf(&unicode.Number).Elem(),
"Nushu": reflect.ValueOf(&unicode.Nushu).Elem(),
"Nyiakeng_Puachue_Hmong": reflect.ValueOf(&unicode.Nyiakeng_Puachue_Hmong).Elem(),
"Ogham": reflect.ValueOf(&unicode.Ogham).Elem(),
"Ol_Chiki": reflect.ValueOf(&unicode.Ol_Chiki).Elem(),
"Old_Hungarian": reflect.ValueOf(&unicode.Old_Hungarian).Elem(),
"Old_Italic": reflect.ValueOf(&unicode.Old_Italic).Elem(),
"Old_North_Arabian": reflect.ValueOf(&unicode.Old_North_Arabian).Elem(),
"Old_Permic": reflect.ValueOf(&unicode.Old_Permic).Elem(),
"Old_Persian": reflect.ValueOf(&unicode.Old_Persian).Elem(),
"Old_Sogdian": reflect.ValueOf(&unicode.Old_Sogdian).Elem(),
"Old_South_Arabian": reflect.ValueOf(&unicode.Old_South_Arabian).Elem(),
"Old_Turkic": reflect.ValueOf(&unicode.Old_Turkic).Elem(),
"Old_Uyghur": reflect.ValueOf(&unicode.Old_Uyghur).Elem(),
"Oriya": reflect.ValueOf(&unicode.Oriya).Elem(),
"Osage": reflect.ValueOf(&unicode.Osage).Elem(),
"Osmanya": reflect.ValueOf(&unicode.Osmanya).Elem(),
"Other": reflect.ValueOf(&unicode.Other).Elem(),
"Other_Alphabetic": reflect.ValueOf(&unicode.Other_Alphabetic).Elem(),
"Other_Default_Ignorable_Code_Point": reflect.ValueOf(&unicode.Other_Default_Ignorable_Code_Point).Elem(),
"Other_Grapheme_Extend": reflect.ValueOf(&unicode.Other_Grapheme_Extend).Elem(),
"Other_ID_Continue": reflect.ValueOf(&unicode.Other_ID_Continue).Elem(),
"Other_ID_Start": reflect.ValueOf(&unicode.Other_ID_Start).Elem(),
"Other_Lowercase": reflect.ValueOf(&unicode.Other_Lowercase).Elem(),
"Other_Math": reflect.ValueOf(&unicode.Other_Math).Elem(),
"Other_Uppercase": reflect.ValueOf(&unicode.Other_Uppercase).Elem(),
"P": reflect.ValueOf(&unicode.P).Elem(),
"Pahawh_Hmong": reflect.ValueOf(&unicode.Pahawh_Hmong).Elem(),
"Palmyrene": reflect.ValueOf(&unicode.Palmyrene).Elem(),
"Pattern_Syntax": reflect.ValueOf(&unicode.Pattern_Syntax).Elem(),
"Pattern_White_Space": reflect.ValueOf(&unicode.Pattern_White_Space).Elem(),
"Pau_Cin_Hau": reflect.ValueOf(&unicode.Pau_Cin_Hau).Elem(),
"Pc": reflect.ValueOf(&unicode.Pc).Elem(),
"Pd": reflect.ValueOf(&unicode.Pd).Elem(),
"Pe": reflect.ValueOf(&unicode.Pe).Elem(),
"Pf": reflect.ValueOf(&unicode.Pf).Elem(),
"Phags_Pa": reflect.ValueOf(&unicode.Phags_Pa).Elem(),
"Phoenician": reflect.ValueOf(&unicode.Phoenician).Elem(),
"Pi": reflect.ValueOf(&unicode.Pi).Elem(),
"Po": reflect.ValueOf(&unicode.Po).Elem(),
"Prepended_Concatenation_Mark": reflect.ValueOf(&unicode.Prepended_Concatenation_Mark).Elem(),
"PrintRanges": reflect.ValueOf(&unicode.PrintRanges).Elem(),
"Properties": reflect.ValueOf(&unicode.Properties).Elem(),
"Ps": reflect.ValueOf(&unicode.Ps).Elem(),
"Psalter_Pahlavi": reflect.ValueOf(&unicode.Psalter_Pahlavi).Elem(),
"Punct": reflect.ValueOf(&unicode.Punct).Elem(),
"Quotation_Mark": reflect.ValueOf(&unicode.Quotation_Mark).Elem(),
"Radical": reflect.ValueOf(&unicode.Radical).Elem(),
"Regional_Indicator": reflect.ValueOf(&unicode.Regional_Indicator).Elem(),
"Rejang": reflect.ValueOf(&unicode.Rejang).Elem(),
"ReplacementChar": reflect.ValueOf(constant.MakeFromLiteral("65533", token.INT, 0)),
"Runic": reflect.ValueOf(&unicode.Runic).Elem(),
"S": reflect.ValueOf(&unicode.S).Elem(),
"STerm": reflect.ValueOf(&unicode.STerm).Elem(),
"Samaritan": reflect.ValueOf(&unicode.Samaritan).Elem(),
"Saurashtra": reflect.ValueOf(&unicode.Saurashtra).Elem(),
"Sc": reflect.ValueOf(&unicode.Sc).Elem(),
"Scripts": reflect.ValueOf(&unicode.Scripts).Elem(),
"Sentence_Terminal": reflect.ValueOf(&unicode.Sentence_Terminal).Elem(),
"Sharada": reflect.ValueOf(&unicode.Sharada).Elem(),
"Shavian": reflect.ValueOf(&unicode.Shavian).Elem(),
"Siddham": reflect.ValueOf(&unicode.Siddham).Elem(),
"SignWriting": reflect.ValueOf(&unicode.SignWriting).Elem(),
"SimpleFold": reflect.ValueOf(unicode.SimpleFold),
"Sinhala": reflect.ValueOf(&unicode.Sinhala).Elem(),
"Sk": reflect.ValueOf(&unicode.Sk).Elem(),
"Sm": reflect.ValueOf(&unicode.Sm).Elem(),
"So": reflect.ValueOf(&unicode.So).Elem(),
"Soft_Dotted": reflect.ValueOf(&unicode.Soft_Dotted).Elem(),
"Sogdian": reflect.ValueOf(&unicode.Sogdian).Elem(),
"Sora_Sompeng": reflect.ValueOf(&unicode.Sora_Sompeng).Elem(),
"Soyombo": reflect.ValueOf(&unicode.Soyombo).Elem(),
"Space": reflect.ValueOf(&unicode.Space).Elem(),
"Sundanese": reflect.ValueOf(&unicode.Sundanese).Elem(),
"Syloti_Nagri": reflect.ValueOf(&unicode.Syloti_Nagri).Elem(),
"Symbol": reflect.ValueOf(&unicode.Symbol).Elem(),
"Syriac": reflect.ValueOf(&unicode.Syriac).Elem(),
"Tagalog": reflect.ValueOf(&unicode.Tagalog).Elem(),
"Tagbanwa": reflect.ValueOf(&unicode.Tagbanwa).Elem(),
"Tai_Le": reflect.ValueOf(&unicode.Tai_Le).Elem(),
"Tai_Tham": reflect.ValueOf(&unicode.Tai_Tham).Elem(),
"Tai_Viet": reflect.ValueOf(&unicode.Tai_Viet).Elem(),
"Takri": reflect.ValueOf(&unicode.Takri).Elem(),
"Tamil": reflect.ValueOf(&unicode.Tamil).Elem(),
"Tangsa": reflect.ValueOf(&unicode.Tangsa).Elem(),
"Tangut": reflect.ValueOf(&unicode.Tangut).Elem(),
"Telugu": reflect.ValueOf(&unicode.Telugu).Elem(),
"Terminal_Punctuation": reflect.ValueOf(&unicode.Terminal_Punctuation).Elem(),
"Thaana": reflect.ValueOf(&unicode.Thaana).Elem(),
"Thai": reflect.ValueOf(&unicode.Thai).Elem(),
"Tibetan": reflect.ValueOf(&unicode.Tibetan).Elem(),
"Tifinagh": reflect.ValueOf(&unicode.Tifinagh).Elem(),
"Tirhuta": reflect.ValueOf(&unicode.Tirhuta).Elem(),
"Title": reflect.ValueOf(&unicode.Title).Elem(),
"TitleCase": reflect.ValueOf(constant.MakeFromLiteral("2", token.INT, 0)),
"To": reflect.ValueOf(unicode.To),
"ToLower": reflect.ValueOf(unicode.ToLower),
"ToTitle": reflect.ValueOf(unicode.ToTitle),
"ToUpper": reflect.ValueOf(unicode.ToUpper),
"Toto": reflect.ValueOf(&unicode.Toto).Elem(),
"TurkishCase": reflect.ValueOf(&unicode.TurkishCase).Elem(),
"Ugaritic": reflect.ValueOf(&unicode.Ugaritic).Elem(),
"Unified_Ideograph": reflect.ValueOf(&unicode.Unified_Ideograph).Elem(),
"Upper": reflect.ValueOf(&unicode.Upper).Elem(),
"UpperCase": reflect.ValueOf(constant.MakeFromLiteral("0", token.INT, 0)),
"UpperLower": reflect.ValueOf(constant.MakeFromLiteral("1114112", token.INT, 0)),
"Vai": reflect.ValueOf(&unicode.Vai).Elem(),
"Variation_Selector": reflect.ValueOf(&unicode.Variation_Selector).Elem(),
"Version": reflect.ValueOf(constant.MakeFromLiteral("\"15.0.0\"", token.STRING, 0)),
"Vithkuqi": reflect.ValueOf(&unicode.Vithkuqi).Elem(),
"Wancho": reflect.ValueOf(&unicode.Wancho).Elem(),
"Warang_Citi": reflect.ValueOf(&unicode.Warang_Citi).Elem(),
"White_Space": reflect.ValueOf(&unicode.White_Space).Elem(),
"Yezidi": reflect.ValueOf(&unicode.Yezidi).Elem(),
"Yi": reflect.ValueOf(&unicode.Yi).Elem(),
"Z": reflect.ValueOf(&unicode.Z).Elem(),
"Zanabazar_Square": reflect.ValueOf(&unicode.Zanabazar_Square).Elem(),
"Zl": reflect.ValueOf(&unicode.Zl).Elem(),
"Zp": reflect.ValueOf(&unicode.Zp).Elem(),
"Zs": reflect.ValueOf(&unicode.Zs).Elem(),
// type definitions
"CaseRange": reflect.ValueOf((*unicode.CaseRange)(nil)),
"Range16": reflect.ValueOf((*unicode.Range16)(nil)),
"Range32": reflect.ValueOf((*unicode.Range32)(nil)),
"RangeTable": reflect.ValueOf((*unicode.RangeTable)(nil)),
"SpecialCase": reflect.ValueOf((*unicode.SpecialCase)(nil)),
}
}
================================================
FILE: stdlib/go1_21_unicode_utf16.go
================================================
// Code generated by 'yaegi extract unicode/utf16'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"reflect"
"unicode/utf16"
)
func init() {
Symbols["unicode/utf16/utf16"] = map[string]reflect.Value{
// function, constant and variable definitions
"AppendRune": reflect.ValueOf(utf16.AppendRune),
"Decode": reflect.ValueOf(utf16.Decode),
"DecodeRune": reflect.ValueOf(utf16.DecodeRune),
"Encode": reflect.ValueOf(utf16.Encode),
"EncodeRune": reflect.ValueOf(utf16.EncodeRune),
"IsSurrogate": reflect.ValueOf(utf16.IsSurrogate),
}
}
================================================
FILE: stdlib/go1_21_unicode_utf8.go
================================================
// Code generated by 'yaegi extract unicode/utf8'. DO NOT EDIT.
//go:build go1.21 && !go1.22
// +build go1.21,!go1.22
package stdlib
import (
"go/constant"
"go/token"
"reflect"
"unicode/utf8"
)
func init() {
Symbols["unicode/utf8/utf8"] = map[string]reflect.Value{
// function, constant and variable definitions
"AppendRune": reflect.ValueOf(utf8.AppendRune),
"DecodeLastRune": reflect.ValueOf(utf8.DecodeLastRune),
"DecodeLastRuneInString": reflect.ValueOf(utf8.DecodeLastRuneInString),
"DecodeRune": reflect.ValueOf(utf8.DecodeRune),
"DecodeRuneInString": reflect.ValueOf(utf8.DecodeRuneInString),
"EncodeRune": reflect.ValueOf(utf8.EncodeRune),
"FullRune": reflect.ValueOf(utf8.FullRune),
"FullRuneInString": reflect.ValueOf(utf8.FullRuneInString),
"MaxRune": reflect.ValueOf(constant.MakeFromLiteral("1114111", token.INT, 0)),
"RuneCount": reflect.ValueOf(utf8.RuneCount),
"RuneCountInString": reflect.ValueOf(utf8.RuneCountInString),
"RuneError": reflect.ValueOf(constant.MakeFromLiteral("65533", token.INT, 0)),
"RuneLen": reflect.ValueOf(utf8.RuneLen),
"RuneSelf": reflect.ValueOf(constant.MakeFromLiteral("128", token.INT, 0)),
"RuneStart": reflect.ValueOf(utf8.RuneStart),
"UTFMax": reflect.ValueOf(constant.MakeFromLiteral("4", token.INT, 0)),
"Valid": reflect.ValueOf(utf8.Valid),
"ValidRune": reflect.ValueOf(utf8.ValidRune),
"ValidString": reflect.ValueOf(utf8.ValidString),
}
}
================================================
FILE: stdlib/go1_22_archive_tar.go
================================================
// Code generated by 'yaegi extract archive/tar'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"archive/tar"
"go/constant"
"go/token"
"reflect"
)
func init() {
Symbols["archive/tar/tar"] = map[string]reflect.Value{
// function, constant and variable definitions
"ErrFieldTooLong": reflect.ValueOf(&tar.ErrFieldTooLong).Elem(),
"ErrHeader": reflect.ValueOf(&tar.ErrHeader).Elem(),
"ErrInsecurePath": reflect.ValueOf(&tar.ErrInsecurePath).Elem(),
"ErrWriteAfterClose": reflect.ValueOf(&tar.ErrWriteAfterClose).Elem(),
"ErrWriteTooLong": reflect.ValueOf(&tar.ErrWriteTooLong).Elem(),
"FileInfoHeader": reflect.ValueOf(tar.FileInfoHeader),
"FormatGNU": reflect.ValueOf(tar.FormatGNU),
"FormatPAX": reflect.ValueOf(tar.FormatPAX),
"FormatUSTAR": reflect.ValueOf(tar.FormatUSTAR),
"FormatUnknown": reflect.ValueOf(tar.FormatUnknown),
"NewReader": reflect.ValueOf(tar.NewReader),
"NewWriter": reflect.ValueOf(tar.NewWriter),
"TypeBlock": reflect.ValueOf(constant.MakeFromLiteral("52", token.INT, 0)),
"TypeChar": reflect.ValueOf(constant.MakeFromLiteral("51", token.INT, 0)),
"TypeCont": reflect.ValueOf(constant.MakeFromLiteral("55", token.INT, 0)),
"TypeDir": reflect.ValueOf(constant.MakeFromLiteral("53", token.INT, 0)),
"TypeFifo": reflect.ValueOf(constant.MakeFromLiteral("54", token.INT, 0)),
"TypeGNULongLink": reflect.ValueOf(constant.MakeFromLiteral("75", token.INT, 0)),
"TypeGNULongName": reflect.ValueOf(constant.MakeFromLiteral("76", token.INT, 0)),
"TypeGNUSparse": reflect.ValueOf(constant.MakeFromLiteral("83", token.INT, 0)),
"TypeLink": reflect.ValueOf(constant.MakeFromLiteral("49", token.INT, 0)),
"TypeReg": reflect.ValueOf(constant.MakeFromLiteral("48", token.INT, 0)),
"TypeRegA": reflect.ValueOf(constant.MakeFromLiteral("0", token.INT, 0)),
"TypeSymlink": reflect.ValueOf(constant.MakeFromLiteral("50", token.INT, 0)),
"TypeXGlobalHeader": reflect.ValueOf(constant.MakeFromLiteral("103", token.INT, 0)),
"TypeXHeader": reflect.ValueOf(constant.MakeFromLiteral("120", token.INT, 0)),
// type definitions
"Format": reflect.ValueOf((*tar.Format)(nil)),
"Header": reflect.ValueOf((*tar.Header)(nil)),
"Reader": reflect.ValueOf((*tar.Reader)(nil)),
"Writer": reflect.ValueOf((*tar.Writer)(nil)),
}
}
================================================
FILE: stdlib/go1_22_archive_zip.go
================================================
// Code generated by 'yaegi extract archive/zip'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"archive/zip"
"reflect"
)
func init() {
Symbols["archive/zip/zip"] = map[string]reflect.Value{
// function, constant and variable definitions
"Deflate": reflect.ValueOf(zip.Deflate),
"ErrAlgorithm": reflect.ValueOf(&zip.ErrAlgorithm).Elem(),
"ErrChecksum": reflect.ValueOf(&zip.ErrChecksum).Elem(),
"ErrFormat": reflect.ValueOf(&zip.ErrFormat).Elem(),
"ErrInsecurePath": reflect.ValueOf(&zip.ErrInsecurePath).Elem(),
"FileInfoHeader": reflect.ValueOf(zip.FileInfoHeader),
"NewReader": reflect.ValueOf(zip.NewReader),
"NewWriter": reflect.ValueOf(zip.NewWriter),
"OpenReader": reflect.ValueOf(zip.OpenReader),
"RegisterCompressor": reflect.ValueOf(zip.RegisterCompressor),
"RegisterDecompressor": reflect.ValueOf(zip.RegisterDecompressor),
"Store": reflect.ValueOf(zip.Store),
// type definitions
"Compressor": reflect.ValueOf((*zip.Compressor)(nil)),
"Decompressor": reflect.ValueOf((*zip.Decompressor)(nil)),
"File": reflect.ValueOf((*zip.File)(nil)),
"FileHeader": reflect.ValueOf((*zip.FileHeader)(nil)),
"ReadCloser": reflect.ValueOf((*zip.ReadCloser)(nil)),
"Reader": reflect.ValueOf((*zip.Reader)(nil)),
"Writer": reflect.ValueOf((*zip.Writer)(nil)),
}
}
================================================
FILE: stdlib/go1_22_bufio.go
================================================
// Code generated by 'yaegi extract bufio'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"bufio"
"go/constant"
"go/token"
"reflect"
)
func init() {
Symbols["bufio/bufio"] = map[string]reflect.Value{
// function, constant and variable definitions
"ErrAdvanceTooFar": reflect.ValueOf(&bufio.ErrAdvanceTooFar).Elem(),
"ErrBadReadCount": reflect.ValueOf(&bufio.ErrBadReadCount).Elem(),
"ErrBufferFull": reflect.ValueOf(&bufio.ErrBufferFull).Elem(),
"ErrFinalToken": reflect.ValueOf(&bufio.ErrFinalToken).Elem(),
"ErrInvalidUnreadByte": reflect.ValueOf(&bufio.ErrInvalidUnreadByte).Elem(),
"ErrInvalidUnreadRune": reflect.ValueOf(&bufio.ErrInvalidUnreadRune).Elem(),
"ErrNegativeAdvance": reflect.ValueOf(&bufio.ErrNegativeAdvance).Elem(),
"ErrNegativeCount": reflect.ValueOf(&bufio.ErrNegativeCount).Elem(),
"ErrTooLong": reflect.ValueOf(&bufio.ErrTooLong).Elem(),
"MaxScanTokenSize": reflect.ValueOf(constant.MakeFromLiteral("65536", token.INT, 0)),
"NewReadWriter": reflect.ValueOf(bufio.NewReadWriter),
"NewReader": reflect.ValueOf(bufio.NewReader),
"NewReaderSize": reflect.ValueOf(bufio.NewReaderSize),
"NewScanner": reflect.ValueOf(bufio.NewScanner),
"NewWriter": reflect.ValueOf(bufio.NewWriter),
"NewWriterSize": reflect.ValueOf(bufio.NewWriterSize),
"ScanBytes": reflect.ValueOf(bufio.ScanBytes),
"ScanLines": reflect.ValueOf(bufio.ScanLines),
"ScanRunes": reflect.ValueOf(bufio.ScanRunes),
"ScanWords": reflect.ValueOf(bufio.ScanWords),
// type definitions
"ReadWriter": reflect.ValueOf((*bufio.ReadWriter)(nil)),
"Reader": reflect.ValueOf((*bufio.Reader)(nil)),
"Scanner": reflect.ValueOf((*bufio.Scanner)(nil)),
"SplitFunc": reflect.ValueOf((*bufio.SplitFunc)(nil)),
"Writer": reflect.ValueOf((*bufio.Writer)(nil)),
}
}
================================================
FILE: stdlib/go1_22_bytes.go
================================================
// Code generated by 'yaegi extract bytes'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"bytes"
"go/constant"
"go/token"
"reflect"
)
func init() {
Symbols["bytes/bytes"] = map[string]reflect.Value{
// function, constant and variable definitions
"Clone": reflect.ValueOf(bytes.Clone),
"Compare": reflect.ValueOf(bytes.Compare),
"Contains": reflect.ValueOf(bytes.Contains),
"ContainsAny": reflect.ValueOf(bytes.ContainsAny),
"ContainsFunc": reflect.ValueOf(bytes.ContainsFunc),
"ContainsRune": reflect.ValueOf(bytes.ContainsRune),
"Count": reflect.ValueOf(bytes.Count),
"Cut": reflect.ValueOf(bytes.Cut),
"CutPrefix": reflect.ValueOf(bytes.CutPrefix),
"CutSuffix": reflect.ValueOf(bytes.CutSuffix),
"Equal": reflect.ValueOf(bytes.Equal),
"EqualFold": reflect.ValueOf(bytes.EqualFold),
"ErrTooLarge": reflect.ValueOf(&bytes.ErrTooLarge).Elem(),
"Fields": reflect.ValueOf(bytes.Fields),
"FieldsFunc": reflect.ValueOf(bytes.FieldsFunc),
"HasPrefix": reflect.ValueOf(bytes.HasPrefix),
"HasSuffix": reflect.ValueOf(bytes.HasSuffix),
"Index": reflect.ValueOf(bytes.Index),
"IndexAny": reflect.ValueOf(bytes.IndexAny),
"IndexByte": reflect.ValueOf(bytes.IndexByte),
"IndexFunc": reflect.ValueOf(bytes.IndexFunc),
"IndexRune": reflect.ValueOf(bytes.IndexRune),
"Join": reflect.ValueOf(bytes.Join),
"LastIndex": reflect.ValueOf(bytes.LastIndex),
"LastIndexAny": reflect.ValueOf(bytes.LastIndexAny),
"LastIndexByte": reflect.ValueOf(bytes.LastIndexByte),
"LastIndexFunc": reflect.ValueOf(bytes.LastIndexFunc),
"Map": reflect.ValueOf(bytes.Map),
"MinRead": reflect.ValueOf(constant.MakeFromLiteral("512", token.INT, 0)),
"NewBuffer": reflect.ValueOf(bytes.NewBuffer),
"NewBufferString": reflect.ValueOf(bytes.NewBufferString),
"NewReader": reflect.ValueOf(bytes.NewReader),
"Repeat": reflect.ValueOf(bytes.Repeat),
"Replace": reflect.ValueOf(bytes.Replace),
"ReplaceAll": reflect.ValueOf(bytes.ReplaceAll),
"Runes": reflect.ValueOf(bytes.Runes),
"Split": reflect.ValueOf(bytes.Split),
"SplitAfter": reflect.ValueOf(bytes.SplitAfter),
"SplitAfterN": reflect.ValueOf(bytes.SplitAfterN),
"SplitN": reflect.ValueOf(bytes.SplitN),
"Title": reflect.ValueOf(bytes.Title),
"ToLower": reflect.ValueOf(bytes.ToLower),
"ToLowerSpecial": reflect.ValueOf(bytes.ToLowerSpecial),
"ToTitle": reflect.ValueOf(bytes.ToTitle),
"ToTitleSpecial": reflect.ValueOf(bytes.ToTitleSpecial),
"ToUpper": reflect.ValueOf(bytes.ToUpper),
"ToUpperSpecial": reflect.ValueOf(bytes.ToUpperSpecial),
"ToValidUTF8": reflect.ValueOf(bytes.ToValidUTF8),
"Trim": reflect.ValueOf(bytes.Trim),
"TrimFunc": reflect.ValueOf(bytes.TrimFunc),
"TrimLeft": reflect.ValueOf(bytes.TrimLeft),
"TrimLeftFunc": reflect.ValueOf(bytes.TrimLeftFunc),
"TrimPrefix": reflect.ValueOf(bytes.TrimPrefix),
"TrimRight": reflect.ValueOf(bytes.TrimRight),
"TrimRightFunc": reflect.ValueOf(bytes.TrimRightFunc),
"TrimSpace": reflect.ValueOf(bytes.TrimSpace),
"TrimSuffix": reflect.ValueOf(bytes.TrimSuffix),
// type definitions
"Buffer": reflect.ValueOf((*bytes.Buffer)(nil)),
"Reader": reflect.ValueOf((*bytes.Reader)(nil)),
}
}
================================================
FILE: stdlib/go1_22_cmp.go
================================================
// Code generated by 'yaegi extract cmp'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"reflect"
)
func init() {
Symbols["cmp/cmp"] = map[string]reflect.Value{}
}
================================================
FILE: stdlib/go1_22_compress_bzip2.go
================================================
// Code generated by 'yaegi extract compress/bzip2'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"compress/bzip2"
"reflect"
)
func init() {
Symbols["compress/bzip2/bzip2"] = map[string]reflect.Value{
// function, constant and variable definitions
"NewReader": reflect.ValueOf(bzip2.NewReader),
// type definitions
"StructuralError": reflect.ValueOf((*bzip2.StructuralError)(nil)),
}
}
================================================
FILE: stdlib/go1_22_compress_flate.go
================================================
// Code generated by 'yaegi extract compress/flate'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"compress/flate"
"go/constant"
"go/token"
"io"
"reflect"
)
func init() {
Symbols["compress/flate/flate"] = map[string]reflect.Value{
// function, constant and variable definitions
"BestCompression": reflect.ValueOf(constant.MakeFromLiteral("9", token.INT, 0)),
"BestSpeed": reflect.ValueOf(constant.MakeFromLiteral("1", token.INT, 0)),
"DefaultCompression": reflect.ValueOf(constant.MakeFromLiteral("-1", token.INT, 0)),
"HuffmanOnly": reflect.ValueOf(constant.MakeFromLiteral("-2", token.INT, 0)),
"NewReader": reflect.ValueOf(flate.NewReader),
"NewReaderDict": reflect.ValueOf(flate.NewReaderDict),
"NewWriter": reflect.ValueOf(flate.NewWriter),
"NewWriterDict": reflect.ValueOf(flate.NewWriterDict),
"NoCompression": reflect.ValueOf(constant.MakeFromLiteral("0", token.INT, 0)),
// type definitions
"CorruptInputError": reflect.ValueOf((*flate.CorruptInputError)(nil)),
"InternalError": reflect.ValueOf((*flate.InternalError)(nil)),
"ReadError": reflect.ValueOf((*flate.ReadError)(nil)),
"Reader": reflect.ValueOf((*flate.Reader)(nil)),
"Resetter": reflect.ValueOf((*flate.Resetter)(nil)),
"WriteError": reflect.ValueOf((*flate.WriteError)(nil)),
"Writer": reflect.ValueOf((*flate.Writer)(nil)),
// interface wrapper definitions
"_Reader": reflect.ValueOf((*_compress_flate_Reader)(nil)),
"_Resetter": reflect.ValueOf((*_compress_flate_Resetter)(nil)),
}
}
// _compress_flate_Reader is an interface wrapper for Reader type
type _compress_flate_Reader struct {
IValue interface{}
WRead func(p []byte) (n int, err error)
WReadByte func() (byte, error)
}
func (W _compress_flate_Reader) Read(p []byte) (n int, err error) { return W.WRead(p) }
func (W _compress_flate_Reader) ReadByte() (byte, error) { return W.WReadByte() }
// _compress_flate_Resetter is an interface wrapper for Resetter type
type _compress_flate_Resetter struct {
IValue interface{}
WReset func(r io.Reader, dict []byte) error
}
func (W _compress_flate_Resetter) Reset(r io.Reader, dict []byte) error { return W.WReset(r, dict) }
================================================
FILE: stdlib/go1_22_compress_gzip.go
================================================
// Code generated by 'yaegi extract compress/gzip'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"compress/gzip"
"go/constant"
"go/token"
"reflect"
)
func init() {
Symbols["compress/gzip/gzip"] = map[string]reflect.Value{
// function, constant and variable definitions
"BestCompression": reflect.ValueOf(constant.MakeFromLiteral("9", token.INT, 0)),
"BestSpeed": reflect.ValueOf(constant.MakeFromLiteral("1", token.INT, 0)),
"DefaultCompression": reflect.ValueOf(constant.MakeFromLiteral("-1", token.INT, 0)),
"ErrChecksum": reflect.ValueOf(&gzip.ErrChecksum).Elem(),
"ErrHeader": reflect.ValueOf(&gzip.ErrHeader).Elem(),
"HuffmanOnly": reflect.ValueOf(constant.MakeFromLiteral("-2", token.INT, 0)),
"NewReader": reflect.ValueOf(gzip.NewReader),
"NewWriter": reflect.ValueOf(gzip.NewWriter),
"NewWriterLevel": reflect.ValueOf(gzip.NewWriterLevel),
"NoCompression": reflect.ValueOf(constant.MakeFromLiteral("0", token.INT, 0)),
// type definitions
"Header": reflect.ValueOf((*gzip.Header)(nil)),
"Reader": reflect.ValueOf((*gzip.Reader)(nil)),
"Writer": reflect.ValueOf((*gzip.Writer)(nil)),
}
}
================================================
FILE: stdlib/go1_22_compress_lzw.go
================================================
// Code generated by 'yaegi extract compress/lzw'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"compress/lzw"
"reflect"
)
func init() {
Symbols["compress/lzw/lzw"] = map[string]reflect.Value{
// function, constant and variable definitions
"LSB": reflect.ValueOf(lzw.LSB),
"MSB": reflect.ValueOf(lzw.MSB),
"NewReader": reflect.ValueOf(lzw.NewReader),
"NewWriter": reflect.ValueOf(lzw.NewWriter),
// type definitions
"Order": reflect.ValueOf((*lzw.Order)(nil)),
"Reader": reflect.ValueOf((*lzw.Reader)(nil)),
"Writer": reflect.ValueOf((*lzw.Writer)(nil)),
}
}
================================================
FILE: stdlib/go1_22_compress_zlib.go
================================================
// Code generated by 'yaegi extract compress/zlib'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"compress/zlib"
"go/constant"
"go/token"
"io"
"reflect"
)
func init() {
Symbols["compress/zlib/zlib"] = map[string]reflect.Value{
// function, constant and variable definitions
"BestCompression": reflect.ValueOf(constant.MakeFromLiteral("9", token.INT, 0)),
"BestSpeed": reflect.ValueOf(constant.MakeFromLiteral("1", token.INT, 0)),
"DefaultCompression": reflect.ValueOf(constant.MakeFromLiteral("-1", token.INT, 0)),
"ErrChecksum": reflect.ValueOf(&zlib.ErrChecksum).Elem(),
"ErrDictionary": reflect.ValueOf(&zlib.ErrDictionary).Elem(),
"ErrHeader": reflect.ValueOf(&zlib.ErrHeader).Elem(),
"HuffmanOnly": reflect.ValueOf(constant.MakeFromLiteral("-2", token.INT, 0)),
"NewReader": reflect.ValueOf(zlib.NewReader),
"NewReaderDict": reflect.ValueOf(zlib.NewReaderDict),
"NewWriter": reflect.ValueOf(zlib.NewWriter),
"NewWriterLevel": reflect.ValueOf(zlib.NewWriterLevel),
"NewWriterLevelDict": reflect.ValueOf(zlib.NewWriterLevelDict),
"NoCompression": reflect.ValueOf(constant.MakeFromLiteral("0", token.INT, 0)),
// type definitions
"Resetter": reflect.ValueOf((*zlib.Resetter)(nil)),
"Writer": reflect.ValueOf((*zlib.Writer)(nil)),
// interface wrapper definitions
"_Resetter": reflect.ValueOf((*_compress_zlib_Resetter)(nil)),
}
}
// _compress_zlib_Resetter is an interface wrapper for Resetter type
type _compress_zlib_Resetter struct {
IValue interface{}
WReset func(r io.Reader, dict []byte) error
}
func (W _compress_zlib_Resetter) Reset(r io.Reader, dict []byte) error { return W.WReset(r, dict) }
================================================
FILE: stdlib/go1_22_container_heap.go
================================================
// Code generated by 'yaegi extract container/heap'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"container/heap"
"reflect"
)
func init() {
Symbols["container/heap/heap"] = map[string]reflect.Value{
// function, constant and variable definitions
"Fix": reflect.ValueOf(heap.Fix),
"Init": reflect.ValueOf(heap.Init),
"Pop": reflect.ValueOf(heap.Pop),
"Push": reflect.ValueOf(heap.Push),
"Remove": reflect.ValueOf(heap.Remove),
// type definitions
"Interface": reflect.ValueOf((*heap.Interface)(nil)),
// interface wrapper definitions
"_Interface": reflect.ValueOf((*_container_heap_Interface)(nil)),
}
}
// _container_heap_Interface is an interface wrapper for Interface type
type _container_heap_Interface struct {
IValue interface{}
WLen func() int
WLess func(i int, j int) bool
WPop func() any
WPush func(x any)
WSwap func(i int, j int)
}
func (W _container_heap_Interface) Len() int { return W.WLen() }
func (W _container_heap_Interface) Less(i int, j int) bool { return W.WLess(i, j) }
func (W _container_heap_Interface) Pop() any { return W.WPop() }
func (W _container_heap_Interface) Push(x any) { W.WPush(x) }
func (W _container_heap_Interface) Swap(i int, j int) { W.WSwap(i, j) }
================================================
FILE: stdlib/go1_22_container_list.go
================================================
// Code generated by 'yaegi extract container/list'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"container/list"
"reflect"
)
func init() {
Symbols["container/list/list"] = map[string]reflect.Value{
// function, constant and variable definitions
"New": reflect.ValueOf(list.New),
// type definitions
"Element": reflect.ValueOf((*list.Element)(nil)),
"List": reflect.ValueOf((*list.List)(nil)),
}
}
================================================
FILE: stdlib/go1_22_container_ring.go
================================================
// Code generated by 'yaegi extract container/ring'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"container/ring"
"reflect"
)
func init() {
Symbols["container/ring/ring"] = map[string]reflect.Value{
// function, constant and variable definitions
"New": reflect.ValueOf(ring.New),
// type definitions
"Ring": reflect.ValueOf((*ring.Ring)(nil)),
}
}
================================================
FILE: stdlib/go1_22_context.go
================================================
// Code generated by 'yaegi extract context'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"context"
"reflect"
"time"
)
func init() {
Symbols["context/context"] = map[string]reflect.Value{
// function, constant and variable definitions
"AfterFunc": reflect.ValueOf(context.AfterFunc),
"Background": reflect.ValueOf(context.Background),
"Canceled": reflect.ValueOf(&context.Canceled).Elem(),
"Cause": reflect.ValueOf(context.Cause),
"DeadlineExceeded": reflect.ValueOf(&context.DeadlineExceeded).Elem(),
"TODO": reflect.ValueOf(context.TODO),
"WithCancel": reflect.ValueOf(context.WithCancel),
"WithCancelCause": reflect.ValueOf(context.WithCancelCause),
"WithDeadline": reflect.ValueOf(context.WithDeadline),
"WithDeadlineCause": reflect.ValueOf(context.WithDeadlineCause),
"WithTimeout": reflect.ValueOf(context.WithTimeout),
"WithTimeoutCause": reflect.ValueOf(context.WithTimeoutCause),
"WithValue": reflect.ValueOf(context.WithValue),
"WithoutCancel": reflect.ValueOf(context.WithoutCancel),
// type definitions
"CancelCauseFunc": reflect.ValueOf((*context.CancelCauseFunc)(nil)),
"CancelFunc": reflect.ValueOf((*context.CancelFunc)(nil)),
"Context": reflect.ValueOf((*context.Context)(nil)),
// interface wrapper definitions
"_Context": reflect.ValueOf((*_context_Context)(nil)),
}
}
// _context_Context is an interface wrapper for Context type
type _context_Context struct {
IValue interface{}
WDeadline func() (deadline time.Time, ok bool)
WDone func() <-chan struct{}
WErr func() error
WValue func(key any) any
}
func (W _context_Context) Deadline() (deadline time.Time, ok bool) { return W.WDeadline() }
func (W _context_Context) Done() <-chan struct{} { return W.WDone() }
func (W _context_Context) Err() error { return W.WErr() }
func (W _context_Context) Value(key any) any { return W.WValue(key) }
================================================
FILE: stdlib/go1_22_crypto.go
================================================
// Code generated by 'yaegi extract crypto'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"crypto"
"io"
"reflect"
)
func init() {
Symbols["crypto/crypto"] = map[string]reflect.Value{
// function, constant and variable definitions
"BLAKE2b_256": reflect.ValueOf(crypto.BLAKE2b_256),
"BLAKE2b_384": reflect.ValueOf(crypto.BLAKE2b_384),
"BLAKE2b_512": reflect.ValueOf(crypto.BLAKE2b_512),
"BLAKE2s_256": reflect.ValueOf(crypto.BLAKE2s_256),
"MD4": reflect.ValueOf(crypto.MD4),
"MD5": reflect.ValueOf(crypto.MD5),
"MD5SHA1": reflect.ValueOf(crypto.MD5SHA1),
"RIPEMD160": reflect.ValueOf(crypto.RIPEMD160),
"RegisterHash": reflect.ValueOf(crypto.RegisterHash),
"SHA1": reflect.ValueOf(crypto.SHA1),
"SHA224": reflect.ValueOf(crypto.SHA224),
"SHA256": reflect.ValueOf(crypto.SHA256),
"SHA384": reflect.ValueOf(crypto.SHA384),
"SHA3_224": reflect.ValueOf(crypto.SHA3_224),
"SHA3_256": reflect.ValueOf(crypto.SHA3_256),
"SHA3_384": reflect.ValueOf(crypto.SHA3_384),
"SHA3_512": reflect.ValueOf(crypto.SHA3_512),
"SHA512": reflect.ValueOf(crypto.SHA512),
"SHA512_224": reflect.ValueOf(crypto.SHA512_224),
"SHA512_256": reflect.ValueOf(crypto.SHA512_256),
// type definitions
"Decrypter": reflect.ValueOf((*crypto.Decrypter)(nil)),
"DecrypterOpts": reflect.ValueOf((*crypto.DecrypterOpts)(nil)),
"Hash": reflect.ValueOf((*crypto.Hash)(nil)),
"PrivateKey": reflect.ValueOf((*crypto.PrivateKey)(nil)),
"PublicKey": reflect.ValueOf((*crypto.PublicKey)(nil)),
"Signer": reflect.ValueOf((*crypto.Signer)(nil)),
"SignerOpts": reflect.ValueOf((*crypto.SignerOpts)(nil)),
// interface wrapper definitions
"_Decrypter": reflect.ValueOf((*_crypto_Decrypter)(nil)),
"_DecrypterOpts": reflect.ValueOf((*_crypto_DecrypterOpts)(nil)),
"_PrivateKey": reflect.ValueOf((*_crypto_PrivateKey)(nil)),
"_PublicKey": reflect.ValueOf((*_crypto_PublicKey)(nil)),
"_Signer": reflect.ValueOf((*_crypto_Signer)(nil)),
"_SignerOpts": reflect.ValueOf((*_crypto_SignerOpts)(nil)),
}
}
// _crypto_Decrypter is an interface wrapper for Decrypter type
type _crypto_Decrypter struct {
IValue interface{}
WDecrypt func(rand io.Reader, msg []byte, opts crypto.DecrypterOpts) (plaintext []byte, err error)
WPublic func() crypto.PublicKey
}
func (W _crypto_Decrypter) Decrypt(rand io.Reader, msg []byte, opts crypto.DecrypterOpts) (plaintext []byte, err error) {
return W.WDecrypt(rand, msg, opts)
}
func (W _crypto_Decrypter) Public() crypto.PublicKey { return W.WPublic() }
// _crypto_DecrypterOpts is an interface wrapper for DecrypterOpts type
type _crypto_DecrypterOpts struct {
IValue interface{}
}
// _crypto_PrivateKey is an interface wrapper for PrivateKey type
type _crypto_PrivateKey struct {
IValue interface{}
}
// _crypto_PublicKey is an interface wrapper for PublicKey type
type _crypto_PublicKey struct {
IValue interface{}
}
// _crypto_Signer is an interface wrapper for Signer type
type _crypto_Signer struct {
IValue interface{}
WPublic func() crypto.PublicKey
WSign func(rand io.Reader, digest []byte, opts crypto.SignerOpts) (signature []byte, err error)
}
func (W _crypto_Signer) Public() crypto.PublicKey { return W.WPublic() }
func (W _crypto_Signer) Sign(rand io.Reader, digest []byte, opts crypto.SignerOpts) (signature []byte, err error) {
return W.WSign(rand, digest, opts)
}
// _crypto_SignerOpts is an interface wrapper for SignerOpts type
type _crypto_SignerOpts struct {
IValue interface{}
WHashFunc func() crypto.Hash
}
func (W _crypto_SignerOpts) HashFunc() crypto.Hash { return W.WHashFunc() }
================================================
FILE: stdlib/go1_22_crypto_aes.go
================================================
// Code generated by 'yaegi extract crypto/aes'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"crypto/aes"
"go/constant"
"go/token"
"reflect"
)
func init() {
Symbols["crypto/aes/aes"] = map[string]reflect.Value{
// function, constant and variable definitions
"BlockSize": reflect.ValueOf(constant.MakeFromLiteral("16", token.INT, 0)),
"NewCipher": reflect.ValueOf(aes.NewCipher),
// type definitions
"KeySizeError": reflect.ValueOf((*aes.KeySizeError)(nil)),
}
}
================================================
FILE: stdlib/go1_22_crypto_cipher.go
================================================
// Code generated by 'yaegi extract crypto/cipher'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"crypto/cipher"
"reflect"
)
func init() {
Symbols["crypto/cipher/cipher"] = map[string]reflect.Value{
// function, constant and variable definitions
"NewCBCDecrypter": reflect.ValueOf(cipher.NewCBCDecrypter),
"NewCBCEncrypter": reflect.ValueOf(cipher.NewCBCEncrypter),
"NewCFBDecrypter": reflect.ValueOf(cipher.NewCFBDecrypter),
"NewCFBEncrypter": reflect.ValueOf(cipher.NewCFBEncrypter),
"NewCTR": reflect.ValueOf(cipher.NewCTR),
"NewGCM": reflect.ValueOf(cipher.NewGCM),
"NewGCMWithNonceSize": reflect.ValueOf(cipher.NewGCMWithNonceSize),
"NewGCMWithTagSize": reflect.ValueOf(cipher.NewGCMWithTagSize),
"NewOFB": reflect.ValueOf(cipher.NewOFB),
// type definitions
"AEAD": reflect.ValueOf((*cipher.AEAD)(nil)),
"Block": reflect.ValueOf((*cipher.Block)(nil)),
"BlockMode": reflect.ValueOf((*cipher.BlockMode)(nil)),
"Stream": reflect.ValueOf((*cipher.Stream)(nil)),
"StreamReader": reflect.ValueOf((*cipher.StreamReader)(nil)),
"StreamWriter": reflect.ValueOf((*cipher.StreamWriter)(nil)),
// interface wrapper definitions
"_AEAD": reflect.ValueOf((*_crypto_cipher_AEAD)(nil)),
"_Block": reflect.ValueOf((*_crypto_cipher_Block)(nil)),
"_BlockMode": reflect.ValueOf((*_crypto_cipher_BlockMode)(nil)),
"_Stream": reflect.ValueOf((*_crypto_cipher_Stream)(nil)),
}
}
// _crypto_cipher_AEAD is an interface wrapper for AEAD type
type _crypto_cipher_AEAD struct {
IValue interface{}
WNonceSize func() int
WOpen func(dst []byte, nonce []byte, ciphertext []byte, additionalData []byte) ([]byte, error)
WOverhead func() int
WSeal func(dst []byte, nonce []byte, plaintext []byte, additionalData []byte) []byte
}
func (W _crypto_cipher_AEAD) NonceSize() int { return W.WNonceSize() }
func (W _crypto_cipher_AEAD) Open(dst []byte, nonce []byte, ciphertext []byte, additionalData []byte) ([]byte, error) {
return W.WOpen(dst, nonce, ciphertext, additionalData)
}
func (W _crypto_cipher_AEAD) Overhead() int { return W.WOverhead() }
func (W _crypto_cipher_AEAD) Seal(dst []byte, nonce []byte, plaintext []byte, additionalData []byte) []byte {
return W.WSeal(dst, nonce, plaintext, additionalData)
}
// _crypto_cipher_Block is an interface wrapper for Block type
type _crypto_cipher_Block struct {
IValue interface{}
WBlockSize func() int
WDecrypt func(dst []byte, src []byte)
WEncrypt func(dst []byte, src []byte)
}
func (W _crypto_cipher_Block) BlockSize() int { return W.WBlockSize() }
func (W _crypto_cipher_Block) Decrypt(dst []byte, src []byte) { W.WDecrypt(dst, src) }
func (W _crypto_cipher_Block) Encrypt(dst []byte, src []byte) { W.WEncrypt(dst, src) }
// _crypto_cipher_BlockMode is an interface wrapper for BlockMode type
type _crypto_cipher_BlockMode struct {
IValue interface{}
WBlockSize func() int
WCryptBlocks func(dst []byte, src []byte)
}
func (W _crypto_cipher_BlockMode) BlockSize() int { return W.WBlockSize() }
func (W _crypto_cipher_BlockMode) CryptBlocks(dst []byte, src []byte) { W.WCryptBlocks(dst, src) }
// _crypto_cipher_Stream is an interface wrapper for Stream type
type _crypto_cipher_Stream struct {
IValue interface{}
WXORKeyStream func(dst []byte, src []byte)
}
func (W _crypto_cipher_Stream) XORKeyStream(dst []byte, src []byte) { W.WXORKeyStream(dst, src) }
================================================
FILE: stdlib/go1_22_crypto_des.go
================================================
// Code generated by 'yaegi extract crypto/des'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"crypto/des"
"go/constant"
"go/token"
"reflect"
)
func init() {
Symbols["crypto/des/des"] = map[string]reflect.Value{
// function, constant and variable definitions
"BlockSize": reflect.ValueOf(constant.MakeFromLiteral("8", token.INT, 0)),
"NewCipher": reflect.ValueOf(des.NewCipher),
"NewTripleDESCipher": reflect.ValueOf(des.NewTripleDESCipher),
// type definitions
"KeySizeError": reflect.ValueOf((*des.KeySizeError)(nil)),
}
}
================================================
FILE: stdlib/go1_22_crypto_dsa.go
================================================
// Code generated by 'yaegi extract crypto/dsa'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"crypto/dsa"
"reflect"
)
func init() {
Symbols["crypto/dsa/dsa"] = map[string]reflect.Value{
// function, constant and variable definitions
"ErrInvalidPublicKey": reflect.ValueOf(&dsa.ErrInvalidPublicKey).Elem(),
"GenerateKey": reflect.ValueOf(dsa.GenerateKey),
"GenerateParameters": reflect.ValueOf(dsa.GenerateParameters),
"L1024N160": reflect.ValueOf(dsa.L1024N160),
"L2048N224": reflect.ValueOf(dsa.L2048N224),
"L2048N256": reflect.ValueOf(dsa.L2048N256),
"L3072N256": reflect.ValueOf(dsa.L3072N256),
"Sign": reflect.ValueOf(dsa.Sign),
"Verify": reflect.ValueOf(dsa.Verify),
// type definitions
"ParameterSizes": reflect.ValueOf((*dsa.ParameterSizes)(nil)),
"Parameters": reflect.ValueOf((*dsa.Parameters)(nil)),
"PrivateKey": reflect.ValueOf((*dsa.PrivateKey)(nil)),
"PublicKey": reflect.ValueOf((*dsa.PublicKey)(nil)),
}
}
================================================
FILE: stdlib/go1_22_crypto_ecdh.go
================================================
// Code generated by 'yaegi extract crypto/ecdh'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"crypto/ecdh"
"io"
"reflect"
)
func init() {
Symbols["crypto/ecdh/ecdh"] = map[string]reflect.Value{
// function, constant and variable definitions
"P256": reflect.ValueOf(ecdh.P256),
"P384": reflect.ValueOf(ecdh.P384),
"P521": reflect.ValueOf(ecdh.P521),
"X25519": reflect.ValueOf(ecdh.X25519),
// type definitions
"Curve": reflect.ValueOf((*ecdh.Curve)(nil)),
"PrivateKey": reflect.ValueOf((*ecdh.PrivateKey)(nil)),
"PublicKey": reflect.ValueOf((*ecdh.PublicKey)(nil)),
// interface wrapper definitions
"_Curve": reflect.ValueOf((*_crypto_ecdh_Curve)(nil)),
}
}
// _crypto_ecdh_Curve is an interface wrapper for Curve type
type _crypto_ecdh_Curve struct {
IValue interface{}
WGenerateKey func(rand io.Reader) (*ecdh.PrivateKey, error)
WNewPrivateKey func(key []byte) (*ecdh.PrivateKey, error)
WNewPublicKey func(key []byte) (*ecdh.PublicKey, error)
}
func (W _crypto_ecdh_Curve) GenerateKey(rand io.Reader) (*ecdh.PrivateKey, error) {
return W.WGenerateKey(rand)
}
func (W _crypto_ecdh_Curve) NewPrivateKey(key []byte) (*ecdh.PrivateKey, error) {
return W.WNewPrivateKey(key)
}
func (W _crypto_ecdh_Curve) NewPublicKey(key []byte) (*ecdh.PublicKey, error) {
return W.WNewPublicKey(key)
}
================================================
FILE: stdlib/go1_22_crypto_ecdsa.go
================================================
// Code generated by 'yaegi extract crypto/ecdsa'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"crypto/ecdsa"
"reflect"
)
func init() {
Symbols["crypto/ecdsa/ecdsa"] = map[string]reflect.Value{
// function, constant and variable definitions
"GenerateKey": reflect.ValueOf(ecdsa.GenerateKey),
"Sign": reflect.ValueOf(ecdsa.Sign),
"SignASN1": reflect.ValueOf(ecdsa.SignASN1),
"Verify": reflect.ValueOf(ecdsa.Verify),
"VerifyASN1": reflect.ValueOf(ecdsa.VerifyASN1),
// type definitions
"PrivateKey": reflect.ValueOf((*ecdsa.PrivateKey)(nil)),
"PublicKey": reflect.ValueOf((*ecdsa.PublicKey)(nil)),
}
}
================================================
FILE: stdlib/go1_22_crypto_ed25519.go
================================================
// Code generated by 'yaegi extract crypto/ed25519'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"crypto/ed25519"
"go/constant"
"go/token"
"reflect"
)
func init() {
Symbols["crypto/ed25519/ed25519"] = map[string]reflect.Value{
// function, constant and variable definitions
"GenerateKey": reflect.ValueOf(ed25519.GenerateKey),
"NewKeyFromSeed": reflect.ValueOf(ed25519.NewKeyFromSeed),
"PrivateKeySize": reflect.ValueOf(constant.MakeFromLiteral("64", token.INT, 0)),
"PublicKeySize": reflect.ValueOf(constant.MakeFromLiteral("32", token.INT, 0)),
"SeedSize": reflect.ValueOf(constant.MakeFromLiteral("32", token.INT, 0)),
"Sign": reflect.ValueOf(ed25519.Sign),
"SignatureSize": reflect.ValueOf(constant.MakeFromLiteral("64", token.INT, 0)),
"Verify": reflect.ValueOf(ed25519.Verify),
"VerifyWithOptions": reflect.ValueOf(ed25519.VerifyWithOptions),
// type definitions
"Options": reflect.ValueOf((*ed25519.Options)(nil)),
"PrivateKey": reflect.ValueOf((*ed25519.PrivateKey)(nil)),
"PublicKey": reflect.ValueOf((*ed25519.PublicKey)(nil)),
}
}
================================================
FILE: stdlib/go1_22_crypto_elliptic.go
================================================
// Code generated by 'yaegi extract crypto/elliptic'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"crypto/elliptic"
"math/big"
"reflect"
)
func init() {
Symbols["crypto/elliptic/elliptic"] = map[string]reflect.Value{
// function, constant and variable definitions
"GenerateKey": reflect.ValueOf(elliptic.GenerateKey),
"Marshal": reflect.ValueOf(elliptic.Marshal),
"MarshalCompressed": reflect.ValueOf(elliptic.MarshalCompressed),
"P224": reflect.ValueOf(elliptic.P224),
"P256": reflect.ValueOf(elliptic.P256),
"P384": reflect.ValueOf(elliptic.P384),
"P521": reflect.ValueOf(elliptic.P521),
"Unmarshal": reflect.ValueOf(elliptic.Unmarshal),
"UnmarshalCompressed": reflect.ValueOf(elliptic.UnmarshalCompressed),
// type definitions
"Curve": reflect.ValueOf((*elliptic.Curve)(nil)),
"CurveParams": reflect.ValueOf((*elliptic.CurveParams)(nil)),
// interface wrapper definitions
"_Curve": reflect.ValueOf((*_crypto_elliptic_Curve)(nil)),
}
}
// _crypto_elliptic_Curve is an interface wrapper for Curve type
type _crypto_elliptic_Curve struct {
IValue interface{}
WAdd func(x1 *big.Int, y1 *big.Int, x2 *big.Int, y2 *big.Int) (x *big.Int, y *big.Int)
WDouble func(x1 *big.Int, y1 *big.Int) (x *big.Int, y *big.Int)
WIsOnCurve func(x *big.Int, y *big.Int) bool
WParams func() *elliptic.CurveParams
WScalarBaseMult func(k []byte) (x *big.Int, y *big.Int)
WScalarMult func(x1 *big.Int, y1 *big.Int, k []byte) (x *big.Int, y *big.Int)
}
func (W _crypto_elliptic_Curve) Add(x1 *big.Int, y1 *big.Int, x2 *big.Int, y2 *big.Int) (x *big.Int, y *big.Int) {
return W.WAdd(x1, y1, x2, y2)
}
func (W _crypto_elliptic_Curve) Double(x1 *big.Int, y1 *big.Int) (x *big.Int, y *big.Int) {
return W.WDouble(x1, y1)
}
func (W _crypto_elliptic_Curve) IsOnCurve(x *big.Int, y *big.Int) bool { return W.WIsOnCurve(x, y) }
func (W _crypto_elliptic_Curve) Params() *elliptic.CurveParams { return W.WParams() }
func (W _crypto_elliptic_Curve) ScalarBaseMult(k []byte) (x *big.Int, y *big.Int) {
return W.WScalarBaseMult(k)
}
func (W _crypto_elliptic_Curve) ScalarMult(x1 *big.Int, y1 *big.Int, k []byte) (x *big.Int, y *big.Int) {
return W.WScalarMult(x1, y1, k)
}
================================================
FILE: stdlib/go1_22_crypto_hmac.go
================================================
// Code generated by 'yaegi extract crypto/hmac'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"crypto/hmac"
"reflect"
)
func init() {
Symbols["crypto/hmac/hmac"] = map[string]reflect.Value{
// function, constant and variable definitions
"Equal": reflect.ValueOf(hmac.Equal),
"New": reflect.ValueOf(hmac.New),
}
}
================================================
FILE: stdlib/go1_22_crypto_md5.go
================================================
// Code generated by 'yaegi extract crypto/md5'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"crypto/md5"
"go/constant"
"go/token"
"reflect"
)
func init() {
Symbols["crypto/md5/md5"] = map[string]reflect.Value{
// function, constant and variable definitions
"BlockSize": reflect.ValueOf(constant.MakeFromLiteral("64", token.INT, 0)),
"New": reflect.ValueOf(md5.New),
"Size": reflect.ValueOf(constant.MakeFromLiteral("16", token.INT, 0)),
"Sum": reflect.ValueOf(md5.Sum),
}
}
================================================
FILE: stdlib/go1_22_crypto_rand.go
================================================
// Code generated by 'yaegi extract crypto/rand'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"crypto/rand"
"reflect"
)
func init() {
Symbols["crypto/rand/rand"] = map[string]reflect.Value{
// function, constant and variable definitions
"Int": reflect.ValueOf(rand.Int),
"Prime": reflect.ValueOf(rand.Prime),
"Read": reflect.ValueOf(rand.Read),
"Reader": reflect.ValueOf(&rand.Reader).Elem(),
}
}
================================================
FILE: stdlib/go1_22_crypto_rc4.go
================================================
// Code generated by 'yaegi extract crypto/rc4'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"crypto/rc4"
"reflect"
)
func init() {
Symbols["crypto/rc4/rc4"] = map[string]reflect.Value{
// function, constant and variable definitions
"NewCipher": reflect.ValueOf(rc4.NewCipher),
// type definitions
"Cipher": reflect.ValueOf((*rc4.Cipher)(nil)),
"KeySizeError": reflect.ValueOf((*rc4.KeySizeError)(nil)),
}
}
================================================
FILE: stdlib/go1_22_crypto_rsa.go
================================================
// Code generated by 'yaegi extract crypto/rsa'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"crypto/rsa"
"go/constant"
"go/token"
"reflect"
)
func init() {
Symbols["crypto/rsa/rsa"] = map[string]reflect.Value{
// function, constant and variable definitions
"DecryptOAEP": reflect.ValueOf(rsa.DecryptOAEP),
"DecryptPKCS1v15": reflect.ValueOf(rsa.DecryptPKCS1v15),
"DecryptPKCS1v15SessionKey": reflect.ValueOf(rsa.DecryptPKCS1v15SessionKey),
"EncryptOAEP": reflect.ValueOf(rsa.EncryptOAEP),
"EncryptPKCS1v15": reflect.ValueOf(rsa.EncryptPKCS1v15),
"ErrDecryption": reflect.ValueOf(&rsa.ErrDecryption).Elem(),
"ErrMessageTooLong": reflect.ValueOf(&rsa.ErrMessageTooLong).Elem(),
"ErrVerification": reflect.ValueOf(&rsa.ErrVerification).Elem(),
"GenerateKey": reflect.ValueOf(rsa.GenerateKey),
"GenerateMultiPrimeKey": reflect.ValueOf(rsa.GenerateMultiPrimeKey),
"PSSSaltLengthAuto": reflect.ValueOf(constant.MakeFromLiteral("0", token.INT, 0)),
"PSSSaltLengthEqualsHash": reflect.ValueOf(constant.MakeFromLiteral("-1", token.INT, 0)),
"SignPKCS1v15": reflect.ValueOf(rsa.SignPKCS1v15),
"SignPSS": reflect.ValueOf(rsa.SignPSS),
"VerifyPKCS1v15": reflect.ValueOf(rsa.VerifyPKCS1v15),
"VerifyPSS": reflect.ValueOf(rsa.VerifyPSS),
// type definitions
"CRTValue": reflect.ValueOf((*rsa.CRTValue)(nil)),
"OAEPOptions": reflect.ValueOf((*rsa.OAEPOptions)(nil)),
"PKCS1v15DecryptOptions": reflect.ValueOf((*rsa.PKCS1v15DecryptOptions)(nil)),
"PSSOptions": reflect.ValueOf((*rsa.PSSOptions)(nil)),
"PrecomputedValues": reflect.ValueOf((*rsa.PrecomputedValues)(nil)),
"PrivateKey": reflect.ValueOf((*rsa.PrivateKey)(nil)),
"PublicKey": reflect.ValueOf((*rsa.PublicKey)(nil)),
}
}
================================================
FILE: stdlib/go1_22_crypto_sha1.go
================================================
// Code generated by 'yaegi extract crypto/sha1'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"crypto/sha1"
"go/constant"
"go/token"
"reflect"
)
func init() {
Symbols["crypto/sha1/sha1"] = map[string]reflect.Value{
// function, constant and variable definitions
"BlockSize": reflect.ValueOf(constant.MakeFromLiteral("64", token.INT, 0)),
"New": reflect.ValueOf(sha1.New),
"Size": reflect.ValueOf(constant.MakeFromLiteral("20", token.INT, 0)),
"Sum": reflect.ValueOf(sha1.Sum),
}
}
================================================
FILE: stdlib/go1_22_crypto_sha256.go
================================================
// Code generated by 'yaegi extract crypto/sha256'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"crypto/sha256"
"go/constant"
"go/token"
"reflect"
)
func init() {
Symbols["crypto/sha256/sha256"] = map[string]reflect.Value{
// function, constant and variable definitions
"BlockSize": reflect.ValueOf(constant.MakeFromLiteral("64", token.INT, 0)),
"New": reflect.ValueOf(sha256.New),
"New224": reflect.ValueOf(sha256.New224),
"Size": reflect.ValueOf(constant.MakeFromLiteral("32", token.INT, 0)),
"Size224": reflect.ValueOf(constant.MakeFromLiteral("28", token.INT, 0)),
"Sum224": reflect.ValueOf(sha256.Sum224),
"Sum256": reflect.ValueOf(sha256.Sum256),
}
}
================================================
FILE: stdlib/go1_22_crypto_sha512.go
================================================
// Code generated by 'yaegi extract crypto/sha512'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"crypto/sha512"
"go/constant"
"go/token"
"reflect"
)
func init() {
Symbols["crypto/sha512/sha512"] = map[string]reflect.Value{
// function, constant and variable definitions
"BlockSize": reflect.ValueOf(constant.MakeFromLiteral("128", token.INT, 0)),
"New": reflect.ValueOf(sha512.New),
"New384": reflect.ValueOf(sha512.New384),
"New512_224": reflect.ValueOf(sha512.New512_224),
"New512_256": reflect.ValueOf(sha512.New512_256),
"Size": reflect.ValueOf(constant.MakeFromLiteral("64", token.INT, 0)),
"Size224": reflect.ValueOf(constant.MakeFromLiteral("28", token.INT, 0)),
"Size256": reflect.ValueOf(constant.MakeFromLiteral("32", token.INT, 0)),
"Size384": reflect.ValueOf(constant.MakeFromLiteral("48", token.INT, 0)),
"Sum384": reflect.ValueOf(sha512.Sum384),
"Sum512": reflect.ValueOf(sha512.Sum512),
"Sum512_224": reflect.ValueOf(sha512.Sum512_224),
"Sum512_256": reflect.ValueOf(sha512.Sum512_256),
}
}
================================================
FILE: stdlib/go1_22_crypto_subtle.go
================================================
// Code generated by 'yaegi extract crypto/subtle'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"crypto/subtle"
"reflect"
)
func init() {
Symbols["crypto/subtle/subtle"] = map[string]reflect.Value{
// function, constant and variable definitions
"ConstantTimeByteEq": reflect.ValueOf(subtle.ConstantTimeByteEq),
"ConstantTimeCompare": reflect.ValueOf(subtle.ConstantTimeCompare),
"ConstantTimeCopy": reflect.ValueOf(subtle.ConstantTimeCopy),
"ConstantTimeEq": reflect.ValueOf(subtle.ConstantTimeEq),
"ConstantTimeLessOrEq": reflect.ValueOf(subtle.ConstantTimeLessOrEq),
"ConstantTimeSelect": reflect.ValueOf(subtle.ConstantTimeSelect),
"XORBytes": reflect.ValueOf(subtle.XORBytes),
}
}
================================================
FILE: stdlib/go1_22_crypto_tls.go
================================================
// Code generated by 'yaegi extract crypto/tls'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"crypto/tls"
"go/constant"
"go/token"
"reflect"
)
func init() {
Symbols["crypto/tls/tls"] = map[string]reflect.Value{
// function, constant and variable definitions
"CipherSuiteName": reflect.ValueOf(tls.CipherSuiteName),
"CipherSuites": reflect.ValueOf(tls.CipherSuites),
"Client": reflect.ValueOf(tls.Client),
"CurveP256": reflect.ValueOf(tls.CurveP256),
"CurveP384": reflect.ValueOf(tls.CurveP384),
"CurveP521": reflect.ValueOf(tls.CurveP521),
"Dial": reflect.ValueOf(tls.Dial),
"DialWithDialer": reflect.ValueOf(tls.DialWithDialer),
"ECDSAWithP256AndSHA256": reflect.ValueOf(tls.ECDSAWithP256AndSHA256),
"ECDSAWithP384AndSHA384": reflect.ValueOf(tls.ECDSAWithP384AndSHA384),
"ECDSAWithP521AndSHA512": reflect.ValueOf(tls.ECDSAWithP521AndSHA512),
"ECDSAWithSHA1": reflect.ValueOf(tls.ECDSAWithSHA1),
"Ed25519": reflect.ValueOf(tls.Ed25519),
"InsecureCipherSuites": reflect.ValueOf(tls.InsecureCipherSuites),
"Listen": reflect.ValueOf(tls.Listen),
"LoadX509KeyPair": reflect.ValueOf(tls.LoadX509KeyPair),
"NewLRUClientSessionCache": reflect.ValueOf(tls.NewLRUClientSessionCache),
"NewListener": reflect.ValueOf(tls.NewListener),
"NewResumptionState": reflect.ValueOf(tls.NewResumptionState),
"NoClientCert": reflect.ValueOf(tls.NoClientCert),
"PKCS1WithSHA1": reflect.ValueOf(tls.PKCS1WithSHA1),
"PKCS1WithSHA256": reflect.ValueOf(tls.PKCS1WithSHA256),
"PKCS1WithSHA384": reflect.ValueOf(tls.PKCS1WithSHA384),
"PKCS1WithSHA512": reflect.ValueOf(tls.PKCS1WithSHA512),
"PSSWithSHA256": reflect.ValueOf(tls.PSSWithSHA256),
"PSSWithSHA384": reflect.ValueOf(tls.PSSWithSHA384),
"PSSWithSHA512": reflect.ValueOf(tls.PSSWithSHA512),
"ParseSessionState": reflect.ValueOf(tls.ParseSessionState),
"QUICClient": reflect.ValueOf(tls.QUICClient),
"QUICEncryptionLevelApplication": reflect.ValueOf(tls.QUICEncryptionLevelApplication),
"QUICEncryptionLevelEarly": reflect.ValueOf(tls.QUICEncryptionLevelEarly),
"QUICEncryptionLevelHandshake": reflect.ValueOf(tls.QUICEncryptionLevelHandshake),
"QUICEncryptionLevelInitial": reflect.ValueOf(tls.QUICEncryptionLevelInitial),
"QUICHandshakeDone": reflect.ValueOf(tls.QUICHandshakeDone),
"QUICNoEvent": reflect.ValueOf(tls.QUICNoEvent),
"QUICRejectedEarlyData": reflect.ValueOf(tls.QUICRejectedEarlyData),
"QUICServer": reflect.ValueOf(tls.QUICServer),
"QUICSetReadSecret": reflect.ValueOf(tls.QUICSetReadSecret),
"QUICSetWriteSecret": reflect.ValueOf(tls.QUICSetWriteSecret),
"QUICTransportParameters": reflect.ValueOf(tls.QUICTransportParameters),
"QUICTransportParametersRequired": reflect.ValueOf(tls.QUICTransportParametersRequired),
"QUICWriteData": reflect.ValueOf(tls.QUICWriteData),
"RenegotiateFreelyAsClient": reflect.ValueOf(tls.RenegotiateFreelyAsClient),
"RenegotiateNever": reflect.ValueOf(tls.RenegotiateNever),
"RenegotiateOnceAsClient": reflect.ValueOf(tls.RenegotiateOnceAsClient),
"RequestClientCert": reflect.ValueOf(tls.RequestClientCert),
"RequireAndVerifyClientCert": reflect.ValueOf(tls.RequireAndVerifyClientCert),
"RequireAnyClientCert": reflect.ValueOf(tls.RequireAnyClientCert),
"Server": reflect.ValueOf(tls.Server),
"TLS_AES_128_GCM_SHA256": reflect.ValueOf(tls.TLS_AES_128_GCM_SHA256),
"TLS_AES_256_GCM_SHA384": reflect.ValueOf(tls.TLS_AES_256_GCM_SHA384),
"TLS_CHACHA20_POLY1305_SHA256": reflect.ValueOf(tls.TLS_CHACHA20_POLY1305_SHA256),
"TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA": reflect.ValueOf(tls.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA),
"TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256": reflect.ValueOf(tls.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256),
"TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256": reflect.ValueOf(tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256),
"TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA": reflect.ValueOf(tls.TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA),
"TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384": reflect.ValueOf(tls.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384),
"TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305": reflect.ValueOf(tls.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305),
"TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256": reflect.ValueOf(tls.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256),
"TLS_ECDHE_ECDSA_WITH_RC4_128_SHA": reflect.ValueOf(tls.TLS_ECDHE_ECDSA_WITH_RC4_128_SHA),
"TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA": reflect.ValueOf(tls.TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA),
"TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA": reflect.ValueOf(tls.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA),
"TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256": reflect.ValueOf(tls.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256),
"TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256": reflect.ValueOf(tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256),
"TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA": reflect.ValueOf(tls.TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA),
"TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384": reflect.ValueOf(tls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384),
"TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305": reflect.ValueOf(tls.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305),
"TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256": reflect.ValueOf(tls.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256),
"TLS_ECDHE_RSA_WITH_RC4_128_SHA": reflect.ValueOf(tls.TLS_ECDHE_RSA_WITH_RC4_128_SHA),
"TLS_FALLBACK_SCSV": reflect.ValueOf(tls.TLS_FALLBACK_SCSV),
"TLS_RSA_WITH_3DES_EDE_CBC_SHA": reflect.ValueOf(tls.TLS_RSA_WITH_3DES_EDE_CBC_SHA),
"TLS_RSA_WITH_AES_128_CBC_SHA": reflect.ValueOf(tls.TLS_RSA_WITH_AES_128_CBC_SHA),
"TLS_RSA_WITH_AES_128_CBC_SHA256": reflect.ValueOf(tls.TLS_RSA_WITH_AES_128_CBC_SHA256),
"TLS_RSA_WITH_AES_128_GCM_SHA256": reflect.ValueOf(tls.TLS_RSA_WITH_AES_128_GCM_SHA256),
"TLS_RSA_WITH_AES_256_CBC_SHA": reflect.ValueOf(tls.TLS_RSA_WITH_AES_256_CBC_SHA),
"TLS_RSA_WITH_AES_256_GCM_SHA384": reflect.ValueOf(tls.TLS_RSA_WITH_AES_256_GCM_SHA384),
"TLS_RSA_WITH_RC4_128_SHA": reflect.ValueOf(tls.TLS_RSA_WITH_RC4_128_SHA),
"VerifyClientCertIfGiven": reflect.ValueOf(tls.VerifyClientCertIfGiven),
"VersionName": reflect.ValueOf(tls.VersionName),
"VersionSSL30": reflect.ValueOf(constant.MakeFromLiteral("768", token.INT, 0)),
"VersionTLS10": reflect.ValueOf(constant.MakeFromLiteral("769", token.INT, 0)),
"VersionTLS11": reflect.ValueOf(constant.MakeFromLiteral("770", token.INT, 0)),
"VersionTLS12": reflect.ValueOf(constant.MakeFromLiteral("771", token.INT, 0)),
"VersionTLS13": reflect.ValueOf(constant.MakeFromLiteral("772", token.INT, 0)),
"X25519": reflect.ValueOf(tls.X25519),
"X509KeyPair": reflect.ValueOf(tls.X509KeyPair),
// type definitions
"AlertError": reflect.ValueOf((*tls.AlertError)(nil)),
"Certificate": reflect.ValueOf((*tls.Certificate)(nil)),
"CertificateRequestInfo": reflect.ValueOf((*tls.CertificateRequestInfo)(nil)),
"CertificateVerificationError": reflect.ValueOf((*tls.CertificateVerificationError)(nil)),
"CipherSuite": reflect.ValueOf((*tls.CipherSuite)(nil)),
"ClientAuthType": reflect.ValueOf((*tls.ClientAuthType)(nil)),
"ClientHelloInfo": reflect.ValueOf((*tls.ClientHelloInfo)(nil)),
"ClientSessionCache": reflect.ValueOf((*tls.ClientSessionCache)(nil)),
"ClientSessionState": reflect.ValueOf((*tls.ClientSessionState)(nil)),
"Config": reflect.ValueOf((*tls.Config)(nil)),
"Conn": reflect.ValueOf((*tls.Conn)(nil)),
"ConnectionState": reflect.ValueOf((*tls.ConnectionState)(nil)),
"CurveID": reflect.ValueOf((*tls.CurveID)(nil)),
"Dialer": reflect.ValueOf((*tls.Dialer)(nil)),
"QUICConfig": reflect.ValueOf((*tls.QUICConfig)(nil)),
"QUICConn": reflect.ValueOf((*tls.QUICConn)(nil)),
"QUICEncryptionLevel": reflect.ValueOf((*tls.QUICEncryptionLevel)(nil)),
"QUICEvent": reflect.ValueOf((*tls.QUICEvent)(nil)),
"QUICEventKind": reflect.ValueOf((*tls.QUICEventKind)(nil)),
"QUICSessionTicketOptions": reflect.ValueOf((*tls.QUICSessionTicketOptions)(nil)),
"RecordHeaderError": reflect.ValueOf((*tls.RecordHeaderError)(nil)),
"RenegotiationSupport": reflect.ValueOf((*tls.RenegotiationSupport)(nil)),
"SessionState": reflect.ValueOf((*tls.SessionState)(nil)),
"SignatureScheme": reflect.ValueOf((*tls.SignatureScheme)(nil)),
// interface wrapper definitions
"_ClientSessionCache": reflect.ValueOf((*_crypto_tls_ClientSessionCache)(nil)),
}
}
// _crypto_tls_ClientSessionCache is an interface wrapper for ClientSessionCache type
type _crypto_tls_ClientSessionCache struct {
IValue interface{}
WGet func(sessionKey string) (session *tls.ClientSessionState, ok bool)
WPut func(sessionKey string, cs *tls.ClientSessionState)
}
func (W _crypto_tls_ClientSessionCache) Get(sessionKey string) (session *tls.ClientSessionState, ok bool) {
return W.WGet(sessionKey)
}
func (W _crypto_tls_ClientSessionCache) Put(sessionKey string, cs *tls.ClientSessionState) {
W.WPut(sessionKey, cs)
}
================================================
FILE: stdlib/go1_22_crypto_x509.go
================================================
// Code generated by 'yaegi extract crypto/x509'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"crypto/x509"
"reflect"
)
func init() {
Symbols["crypto/x509/x509"] = map[string]reflect.Value{
// function, constant and variable definitions
"CANotAuthorizedForExtKeyUsage": reflect.ValueOf(x509.CANotAuthorizedForExtKeyUsage),
"CANotAuthorizedForThisName": reflect.ValueOf(x509.CANotAuthorizedForThisName),
"CreateCertificate": reflect.ValueOf(x509.CreateCertificate),
"CreateCertificateRequest": reflect.ValueOf(x509.CreateCertificateRequest),
"CreateRevocationList": reflect.ValueOf(x509.CreateRevocationList),
"DSA": reflect.ValueOf(x509.DSA),
"DSAWithSHA1": reflect.ValueOf(x509.DSAWithSHA1),
"DSAWithSHA256": reflect.ValueOf(x509.DSAWithSHA256),
"DecryptPEMBlock": reflect.ValueOf(x509.DecryptPEMBlock),
"ECDSA": reflect.ValueOf(x509.ECDSA),
"ECDSAWithSHA1": reflect.ValueOf(x509.ECDSAWithSHA1),
"ECDSAWithSHA256": reflect.ValueOf(x509.ECDSAWithSHA256),
"ECDSAWithSHA384": reflect.ValueOf(x509.ECDSAWithSHA384),
"ECDSAWithSHA512": reflect.ValueOf(x509.ECDSAWithSHA512),
"Ed25519": reflect.ValueOf(x509.Ed25519),
"EncryptPEMBlock": reflect.ValueOf(x509.EncryptPEMBlock),
"ErrUnsupportedAlgorithm": reflect.ValueOf(&x509.ErrUnsupportedAlgorithm).Elem(),
"Expired": reflect.ValueOf(x509.Expired),
"ExtKeyUsageAny": reflect.ValueOf(x509.ExtKeyUsageAny),
"ExtKeyUsageClientAuth": reflect.ValueOf(x509.ExtKeyUsageClientAuth),
"ExtKeyUsageCodeSigning": reflect.ValueOf(x509.ExtKeyUsageCodeSigning),
"ExtKeyUsageEmailProtection": reflect.ValueOf(x509.ExtKeyUsageEmailProtection),
"ExtKeyUsageIPSECEndSystem": reflect.ValueOf(x509.ExtKeyUsageIPSECEndSystem),
"ExtKeyUsageIPSECTunnel": reflect.ValueOf(x509.ExtKeyUsageIPSECTunnel),
"ExtKeyUsageIPSECUser": reflect.ValueOf(x509.ExtKeyUsageIPSECUser),
"ExtKeyUsageMicrosoftCommercialCodeSigning": reflect.ValueOf(x509.ExtKeyUsageMicrosoftCommercialCodeSigning),
"ExtKeyUsageMicrosoftKernelCodeSigning": reflect.ValueOf(x509.ExtKeyUsageMicrosoftKernelCodeSigning),
"ExtKeyUsageMicrosoftServerGatedCrypto": reflect.ValueOf(x509.ExtKeyUsageMicrosoftServerGatedCrypto),
"ExtKeyUsageNetscapeServerGatedCrypto": reflect.ValueOf(x509.ExtKeyUsageNetscapeServerGatedCrypto),
"ExtKeyUsageOCSPSigning": reflect.ValueOf(x509.ExtKeyUsageOCSPSigning),
"ExtKeyUsageServerAuth": reflect.ValueOf(x509.ExtKeyUsageServerAuth),
"ExtKeyUsageTimeStamping": reflect.ValueOf(x509.ExtKeyUsageTimeStamping),
"IncompatibleUsage": reflect.ValueOf(x509.IncompatibleUsage),
"IncorrectPasswordError": reflect.ValueOf(&x509.IncorrectPasswordError).Elem(),
"IsEncryptedPEMBlock": reflect.ValueOf(x509.IsEncryptedPEMBlock),
"KeyUsageCRLSign": reflect.ValueOf(x509.KeyUsageCRLSign),
"KeyUsageCertSign": reflect.ValueOf(x509.KeyUsageCertSign),
"KeyUsageContentCommitment": reflect.ValueOf(x509.KeyUsageContentCommitment),
"KeyUsageDataEncipherment": reflect.ValueOf(x509.KeyUsageDataEncipherment),
"KeyUsageDecipherOnly": reflect.ValueOf(x509.KeyUsageDecipherOnly),
"KeyUsageDigitalSignature": reflect.ValueOf(x509.KeyUsageDigitalSignature),
"KeyUsageEncipherOnly": reflect.ValueOf(x509.KeyUsageEncipherOnly),
"KeyUsageKeyAgreement": reflect.ValueOf(x509.KeyUsageKeyAgreement),
"KeyUsageKeyEncipherment": reflect.ValueOf(x509.KeyUsageKeyEncipherment),
"MD2WithRSA": reflect.ValueOf(x509.MD2WithRSA),
"MD5WithRSA": reflect.ValueOf(x509.MD5WithRSA),
"MarshalECPrivateKey": reflect.ValueOf(x509.MarshalECPrivateKey),
"MarshalPKCS1PrivateKey": reflect.ValueOf(x509.MarshalPKCS1PrivateKey),
"MarshalPKCS1PublicKey": reflect.ValueOf(x509.MarshalPKCS1PublicKey),
"MarshalPKCS8PrivateKey": reflect.ValueOf(x509.MarshalPKCS8PrivateKey),
"MarshalPKIXPublicKey": reflect.ValueOf(x509.MarshalPKIXPublicKey),
"NameConstraintsWithoutSANs": reflect.ValueOf(x509.NameConstraintsWithoutSANs),
"NameMismatch": reflect.ValueOf(x509.NameMismatch),
"NewCertPool": reflect.ValueOf(x509.NewCertPool),
"NotAuthorizedToSign": reflect.ValueOf(x509.NotAuthorizedToSign),
"OIDFromInts": reflect.ValueOf(x509.OIDFromInts),
"PEMCipher3DES": reflect.ValueOf(x509.PEMCipher3DES),
"PEMCipherAES128": reflect.ValueOf(x509.PEMCipherAES128),
"PEMCipherAES192": reflect.ValueOf(x509.PEMCipherAES192),
"PEMCipherAES256": reflect.ValueOf(x509.PEMCipherAES256),
"PEMCipherDES": reflect.ValueOf(x509.PEMCipherDES),
"ParseCRL": reflect.ValueOf(x509.ParseCRL),
"ParseCertificate": reflect.ValueOf(x509.ParseCertificate),
"ParseCertificateRequest": reflect.ValueOf(x509.ParseCertificateRequest),
"ParseCertificates": reflect.ValueOf(x509.ParseCertificates),
"ParseDERCRL": reflect.ValueOf(x509.ParseDERCRL),
"ParseECPrivateKey": reflect.ValueOf(x509.ParseECPrivateKey),
"ParsePKCS1PrivateKey": reflect.ValueOf(x509.ParsePKCS1PrivateKey),
"ParsePKCS1PublicKey": reflect.ValueOf(x509.ParsePKCS1PublicKey),
"ParsePKCS8PrivateKey": reflect.ValueOf(x509.ParsePKCS8PrivateKey),
"ParsePKIXPublicKey": reflect.ValueOf(x509.ParsePKIXPublicKey),
"ParseRevocationList": reflect.ValueOf(x509.ParseRevocationList),
"PureEd25519": reflect.ValueOf(x509.PureEd25519),
"RSA": reflect.ValueOf(x509.RSA),
"SHA1WithRSA": reflect.ValueOf(x509.SHA1WithRSA),
"SHA256WithRSA": reflect.ValueOf(x509.SHA256WithRSA),
"SHA256WithRSAPSS": reflect.ValueOf(x509.SHA256WithRSAPSS),
"SHA384WithRSA": reflect.ValueOf(x509.SHA384WithRSA),
"SHA384WithRSAPSS": reflect.ValueOf(x509.SHA384WithRSAPSS),
"SHA512WithRSA": reflect.ValueOf(x509.SHA512WithRSA),
"SHA512WithRSAPSS": reflect.ValueOf(x509.SHA512WithRSAPSS),
"SetFallbackRoots": reflect.ValueOf(x509.SetFallbackRoots),
"SystemCertPool": reflect.ValueOf(x509.SystemCertPool),
"TooManyConstraints": reflect.ValueOf(x509.TooManyConstraints),
"TooManyIntermediates": reflect.ValueOf(x509.TooManyIntermediates),
"UnconstrainedName": reflect.ValueOf(x509.UnconstrainedName),
"UnknownPublicKeyAlgorithm": reflect.ValueOf(x509.UnknownPublicKeyAlgorithm),
"UnknownSignatureAlgorithm": reflect.ValueOf(x509.UnknownSignatureAlgorithm),
// type definitions
"CertPool": reflect.ValueOf((*x509.CertPool)(nil)),
"Certificate": reflect.ValueOf((*x509.Certificate)(nil)),
"CertificateInvalidError": reflect.ValueOf((*x509.CertificateInvalidError)(nil)),
"CertificateRequest": reflect.ValueOf((*x509.CertificateRequest)(nil)),
"ConstraintViolationError": reflect.ValueOf((*x509.ConstraintViolationError)(nil)),
"ExtKeyUsage": reflect.ValueOf((*x509.ExtKeyUsage)(nil)),
"HostnameError": reflect.ValueOf((*x509.HostnameError)(nil)),
"InsecureAlgorithmError": reflect.ValueOf((*x509.InsecureAlgorithmError)(nil)),
"InvalidReason": reflect.ValueOf((*x509.InvalidReason)(nil)),
"KeyUsage": reflect.ValueOf((*x509.KeyUsage)(nil)),
"OID": reflect.ValueOf((*x509.OID)(nil)),
"PEMCipher": reflect.ValueOf((*x509.PEMCipher)(nil)),
"PublicKeyAlgorithm": reflect.ValueOf((*x509.PublicKeyAlgorithm)(nil)),
"RevocationList": reflect.ValueOf((*x509.RevocationList)(nil)),
"RevocationListEntry": reflect.ValueOf((*x509.RevocationListEntry)(nil)),
"SignatureAlgorithm": reflect.ValueOf((*x509.SignatureAlgorithm)(nil)),
"SystemRootsError": reflect.ValueOf((*x509.SystemRootsError)(nil)),
"UnhandledCriticalExtension": reflect.ValueOf((*x509.UnhandledCriticalExtension)(nil)),
"UnknownAuthorityError": reflect.ValueOf((*x509.UnknownAuthorityError)(nil)),
"VerifyOptions": reflect.ValueOf((*x509.VerifyOptions)(nil)),
}
}
================================================
FILE: stdlib/go1_22_crypto_x509_pkix.go
================================================
// Code generated by 'yaegi extract crypto/x509/pkix'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"crypto/x509/pkix"
"reflect"
)
func init() {
Symbols["crypto/x509/pkix/pkix"] = map[string]reflect.Value{
// type definitions
"AlgorithmIdentifier": reflect.ValueOf((*pkix.AlgorithmIdentifier)(nil)),
"AttributeTypeAndValue": reflect.ValueOf((*pkix.AttributeTypeAndValue)(nil)),
"AttributeTypeAndValueSET": reflect.ValueOf((*pkix.AttributeTypeAndValueSET)(nil)),
"CertificateList": reflect.ValueOf((*pkix.CertificateList)(nil)),
"Extension": reflect.ValueOf((*pkix.Extension)(nil)),
"Name": reflect.ValueOf((*pkix.Name)(nil)),
"RDNSequence": reflect.ValueOf((*pkix.RDNSequence)(nil)),
"RelativeDistinguishedNameSET": reflect.ValueOf((*pkix.RelativeDistinguishedNameSET)(nil)),
"RevokedCertificate": reflect.ValueOf((*pkix.RevokedCertificate)(nil)),
"TBSCertificateList": reflect.ValueOf((*pkix.TBSCertificateList)(nil)),
}
}
================================================
FILE: stdlib/go1_22_database_sql.go
================================================
// Code generated by 'yaegi extract database/sql'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"database/sql"
"reflect"
)
func init() {
Symbols["database/sql/sql"] = map[string]reflect.Value{
// function, constant and variable definitions
"Drivers": reflect.ValueOf(sql.Drivers),
"ErrConnDone": reflect.ValueOf(&sql.ErrConnDone).Elem(),
"ErrNoRows": reflect.ValueOf(&sql.ErrNoRows).Elem(),
"ErrTxDone": reflect.ValueOf(&sql.ErrTxDone).Elem(),
"LevelDefault": reflect.ValueOf(sql.LevelDefault),
"LevelLinearizable": reflect.ValueOf(sql.LevelLinearizable),
"LevelReadCommitted": reflect.ValueOf(sql.LevelReadCommitted),
"LevelReadUncommitted": reflect.ValueOf(sql.LevelReadUncommitted),
"LevelRepeatableRead": reflect.ValueOf(sql.LevelRepeatableRead),
"LevelSerializable": reflect.ValueOf(sql.LevelSerializable),
"LevelSnapshot": reflect.ValueOf(sql.LevelSnapshot),
"LevelWriteCommitted": reflect.ValueOf(sql.LevelWriteCommitted),
"Named": reflect.ValueOf(sql.Named),
"Open": reflect.ValueOf(sql.Open),
"OpenDB": reflect.ValueOf(sql.OpenDB),
"Register": reflect.ValueOf(sql.Register),
// type definitions
"ColumnType": reflect.ValueOf((*sql.ColumnType)(nil)),
"Conn": reflect.ValueOf((*sql.Conn)(nil)),
"DB": reflect.ValueOf((*sql.DB)(nil)),
"DBStats": reflect.ValueOf((*sql.DBStats)(nil)),
"IsolationLevel": reflect.ValueOf((*sql.IsolationLevel)(nil)),
"NamedArg": reflect.ValueOf((*sql.NamedArg)(nil)),
"NullBool": reflect.ValueOf((*sql.NullBool)(nil)),
"NullByte": reflect.ValueOf((*sql.NullByte)(nil)),
"NullFloat64": reflect.ValueOf((*sql.NullFloat64)(nil)),
"NullInt16": reflect.ValueOf((*sql.NullInt16)(nil)),
"NullInt32": reflect.ValueOf((*sql.NullInt32)(nil)),
"NullInt64": reflect.ValueOf((*sql.NullInt64)(nil)),
"NullString": reflect.ValueOf((*sql.NullString)(nil)),
"NullTime": reflect.ValueOf((*sql.NullTime)(nil)),
"Out": reflect.ValueOf((*sql.Out)(nil)),
"RawBytes": reflect.ValueOf((*sql.RawBytes)(nil)),
"Result": reflect.ValueOf((*sql.Result)(nil)),
"Row": reflect.ValueOf((*sql.Row)(nil)),
"Rows": reflect.ValueOf((*sql.Rows)(nil)),
"Scanner": reflect.ValueOf((*sql.Scanner)(nil)),
"Stmt": reflect.ValueOf((*sql.Stmt)(nil)),
"Tx": reflect.ValueOf((*sql.Tx)(nil)),
"TxOptions": reflect.ValueOf((*sql.TxOptions)(nil)),
// interface wrapper definitions
"_Result": reflect.ValueOf((*_database_sql_Result)(nil)),
"_Scanner": reflect.ValueOf((*_database_sql_Scanner)(nil)),
}
}
// _database_sql_Result is an interface wrapper for Result type
type _database_sql_Result struct {
IValue interface{}
WLastInsertId func() (int64, error)
WRowsAffected func() (int64, error)
}
func (W _database_sql_Result) LastInsertId() (int64, error) { return W.WLastInsertId() }
func (W _database_sql_Result) RowsAffected() (int64, error) { return W.WRowsAffected() }
// _database_sql_Scanner is an interface wrapper for Scanner type
type _database_sql_Scanner struct {
IValue interface{}
WScan func(src any) error
}
func (W _database_sql_Scanner) Scan(src any) error { return W.WScan(src) }
================================================
FILE: stdlib/go1_22_database_sql_driver.go
================================================
// Code generated by 'yaegi extract database/sql/driver'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"context"
"database/sql/driver"
"reflect"
)
func init() {
Symbols["database/sql/driver/driver"] = map[string]reflect.Value{
// function, constant and variable definitions
"Bool": reflect.ValueOf(&driver.Bool).Elem(),
"DefaultParameterConverter": reflect.ValueOf(&driver.DefaultParameterConverter).Elem(),
"ErrBadConn": reflect.ValueOf(&driver.ErrBadConn).Elem(),
"ErrRemoveArgument": reflect.ValueOf(&driver.ErrRemoveArgument).Elem(),
"ErrSkip": reflect.ValueOf(&driver.ErrSkip).Elem(),
"Int32": reflect.ValueOf(&driver.Int32).Elem(),
"IsScanValue": reflect.ValueOf(driver.IsScanValue),
"IsValue": reflect.ValueOf(driver.IsValue),
"ResultNoRows": reflect.ValueOf(&driver.ResultNoRows).Elem(),
"String": reflect.ValueOf(&driver.String).Elem(),
// type definitions
"ColumnConverter": reflect.ValueOf((*driver.ColumnConverter)(nil)),
"Conn": reflect.ValueOf((*driver.Conn)(nil)),
"ConnBeginTx": reflect.ValueOf((*driver.ConnBeginTx)(nil)),
"ConnPrepareContext": reflect.ValueOf((*driver.ConnPrepareContext)(nil)),
"Connector": reflect.ValueOf((*driver.Connector)(nil)),
"Driver": reflect.ValueOf((*driver.Driver)(nil)),
"DriverContext": reflect.ValueOf((*driver.DriverContext)(nil)),
"Execer": reflect.ValueOf((*driver.Execer)(nil)),
"ExecerContext": reflect.ValueOf((*driver.ExecerContext)(nil)),
"IsolationLevel": reflect.ValueOf((*driver.IsolationLevel)(nil)),
"NamedValue": reflect.ValueOf((*driver.NamedValue)(nil)),
"NamedValueChecker": reflect.ValueOf((*driver.NamedValueChecker)(nil)),
"NotNull": reflect.ValueOf((*driver.NotNull)(nil)),
"Null": reflect.ValueOf((*driver.Null)(nil)),
"Pinger": reflect.ValueOf((*driver.Pinger)(nil)),
"Queryer": reflect.ValueOf((*driver.Queryer)(nil)),
"QueryerContext": reflect.ValueOf((*driver.QueryerContext)(nil)),
"Result": reflect.ValueOf((*driver.Result)(nil)),
"Rows": reflect.ValueOf((*driver.Rows)(nil)),
"RowsAffected": reflect.ValueOf((*driver.RowsAffected)(nil)),
"RowsColumnTypeDatabaseTypeName": reflect.ValueOf((*driver.RowsColumnTypeDatabaseTypeName)(nil)),
"RowsColumnTypeLength": reflect.ValueOf((*driver.RowsColumnTypeLength)(nil)),
"RowsColumnTypeNullable": reflect.ValueOf((*driver.RowsColumnTypeNullable)(nil)),
"RowsColumnTypePrecisionScale": reflect.ValueOf((*driver.RowsColumnTypePrecisionScale)(nil)),
"RowsColumnTypeScanType": reflect.ValueOf((*driver.RowsColumnTypeScanType)(nil)),
"RowsNextResultSet": reflect.ValueOf((*driver.RowsNextResultSet)(nil)),
"SessionResetter": reflect.ValueOf((*driver.SessionResetter)(nil)),
"Stmt": reflect.ValueOf((*driver.Stmt)(nil)),
"StmtExecContext": reflect.ValueOf((*driver.StmtExecContext)(nil)),
"StmtQueryContext": reflect.ValueOf((*driver.StmtQueryContext)(nil)),
"Tx": reflect.ValueOf((*driver.Tx)(nil)),
"TxOptions": reflect.ValueOf((*driver.TxOptions)(nil)),
"Validator": reflect.ValueOf((*driver.Validator)(nil)),
"Value": reflect.ValueOf((*driver.Value)(nil)),
"ValueConverter": reflect.ValueOf((*driver.ValueConverter)(nil)),
"Valuer": reflect.ValueOf((*driver.Valuer)(nil)),
// interface wrapper definitions
"_ColumnConverter": reflect.ValueOf((*_database_sql_driver_ColumnConverter)(nil)),
"_Conn": reflect.ValueOf((*_database_sql_driver_Conn)(nil)),
"_ConnBeginTx": reflect.ValueOf((*_database_sql_driver_ConnBeginTx)(nil)),
"_ConnPrepareContext": reflect.ValueOf((*_database_sql_driver_ConnPrepareContext)(nil)),
"_Connector": reflect.ValueOf((*_database_sql_driver_Connector)(nil)),
"_Driver": reflect.ValueOf((*_database_sql_driver_Driver)(nil)),
"_DriverContext": reflect.ValueOf((*_database_sql_driver_DriverContext)(nil)),
"_Execer": reflect.ValueOf((*_database_sql_driver_Execer)(nil)),
"_ExecerContext": reflect.ValueOf((*_database_sql_driver_ExecerContext)(nil)),
"_NamedValueChecker": reflect.ValueOf((*_database_sql_driver_NamedValueChecker)(nil)),
"_Pinger": reflect.ValueOf((*_database_sql_driver_Pinger)(nil)),
"_Queryer": reflect.ValueOf((*_database_sql_driver_Queryer)(nil)),
"_QueryerContext": reflect.ValueOf((*_database_sql_driver_QueryerContext)(nil)),
"_Result": reflect.ValueOf((*_database_sql_driver_Result)(nil)),
"_Rows": reflect.ValueOf((*_database_sql_driver_Rows)(nil)),
"_RowsColumnTypeDatabaseTypeName": reflect.ValueOf((*_database_sql_driver_RowsColumnTypeDatabaseTypeName)(nil)),
"_RowsColumnTypeLength": reflect.ValueOf((*_database_sql_driver_RowsColumnTypeLength)(nil)),
"_RowsColumnTypeNullable": reflect.ValueOf((*_database_sql_driver_RowsColumnTypeNullable)(nil)),
"_RowsColumnTypePrecisionScale": reflect.ValueOf((*_database_sql_driver_RowsColumnTypePrecisionScale)(nil)),
"_RowsColumnTypeScanType": reflect.ValueOf((*_database_sql_driver_RowsColumnTypeScanType)(nil)),
"_RowsNextResultSet": reflect.ValueOf((*_database_sql_driver_RowsNextResultSet)(nil)),
"_SessionResetter": reflect.ValueOf((*_database_sql_driver_SessionResetter)(nil)),
"_Stmt": reflect.ValueOf((*_database_sql_driver_Stmt)(nil)),
"_StmtExecContext": reflect.ValueOf((*_database_sql_driver_StmtExecContext)(nil)),
"_StmtQueryContext": reflect.ValueOf((*_database_sql_driver_StmtQueryContext)(nil)),
"_Tx": reflect.ValueOf((*_database_sql_driver_Tx)(nil)),
"_Validator": reflect.ValueOf((*_database_sql_driver_Validator)(nil)),
"_Value": reflect.ValueOf((*_database_sql_driver_Value)(nil)),
"_ValueConverter": reflect.ValueOf((*_database_sql_driver_ValueConverter)(nil)),
"_Valuer": reflect.ValueOf((*_database_sql_driver_Valuer)(nil)),
}
}
// _database_sql_driver_ColumnConverter is an interface wrapper for ColumnConverter type
type _database_sql_driver_ColumnConverter struct {
IValue interface{}
WColumnConverter func(idx int) driver.ValueConverter
}
func (W _database_sql_driver_ColumnConverter) ColumnConverter(idx int) driver.ValueConverter {
return W.WColumnConverter(idx)
}
// _database_sql_driver_Conn is an interface wrapper for Conn type
type _database_sql_driver_Conn struct {
IValue interface{}
WBegin func() (driver.Tx, error)
WClose func() error
WPrepare func(query string) (driver.Stmt, error)
}
func (W _database_sql_driver_Conn) Begin() (driver.Tx, error) { return W.WBegin() }
func (W _database_sql_driver_Conn) Close() error { return W.WClose() }
func (W _database_sql_driver_Conn) Prepare(query string) (driver.Stmt, error) {
return W.WPrepare(query)
}
// _database_sql_driver_ConnBeginTx is an interface wrapper for ConnBeginTx type
type _database_sql_driver_ConnBeginTx struct {
IValue interface{}
WBeginTx func(ctx context.Context, opts driver.TxOptions) (driver.Tx, error)
}
func (W _database_sql_driver_ConnBeginTx) BeginTx(ctx context.Context, opts driver.TxOptions) (driver.Tx, error) {
return W.WBeginTx(ctx, opts)
}
// _database_sql_driver_ConnPrepareContext is an interface wrapper for ConnPrepareContext type
type _database_sql_driver_ConnPrepareContext struct {
IValue interface{}
WPrepareContext func(ctx context.Context, query string) (driver.Stmt, error)
}
func (W _database_sql_driver_ConnPrepareContext) PrepareContext(ctx context.Context, query string) (driver.Stmt, error) {
return W.WPrepareContext(ctx, query)
}
// _database_sql_driver_Connector is an interface wrapper for Connector type
type _database_sql_driver_Connector struct {
IValue interface{}
WConnect func(a0 context.Context) (driver.Conn, error)
WDriver func() driver.Driver
}
func (W _database_sql_driver_Connector) Connect(a0 context.Context) (driver.Conn, error) {
return W.WConnect(a0)
}
func (W _database_sql_driver_Connector) Driver() driver.Driver { return W.WDriver() }
// _database_sql_driver_Driver is an interface wrapper for Driver type
type _database_sql_driver_Driver struct {
IValue interface{}
WOpen func(name string) (driver.Conn, error)
}
func (W _database_sql_driver_Driver) Open(name string) (driver.Conn, error) { return W.WOpen(name) }
// _database_sql_driver_DriverContext is an interface wrapper for DriverContext type
type _database_sql_driver_DriverContext struct {
IValue interface{}
WOpenConnector func(name string) (driver.Connector, error)
}
func (W _database_sql_driver_DriverContext) OpenConnector(name string) (driver.Connector, error) {
return W.WOpenConnector(name)
}
// _database_sql_driver_Execer is an interface wrapper for Execer type
type _database_sql_driver_Execer struct {
IValue interface{}
WExec func(query string, args []driver.Value) (driver.Result, error)
}
func (W _database_sql_driver_Execer) Exec(query string, args []driver.Value) (driver.Result, error) {
return W.WExec(query, args)
}
// _database_sql_driver_ExecerContext is an interface wrapper for ExecerContext type
type _database_sql_driver_ExecerContext struct {
IValue interface{}
WExecContext func(ctx context.Context, query string, args []driver.NamedValue) (driver.Result, error)
}
func (W _database_sql_driver_ExecerContext) ExecContext(ctx context.Context, query string, args []driver.NamedValue) (driver.Result, error) {
return W.WExecContext(ctx, query, args)
}
// _database_sql_driver_NamedValueChecker is an interface wrapper for NamedValueChecker type
type _database_sql_driver_NamedValueChecker struct {
IValue interface{}
WCheckNamedValue func(a0 *driver.NamedValue) error
}
func (W _database_sql_driver_NamedValueChecker) CheckNamedValue(a0 *driver.NamedValue) error {
return W.WCheckNamedValue(a0)
}
// _database_sql_driver_Pinger is an interface wrapper for Pinger type
type _database_sql_driver_Pinger struct {
IValue interface{}
WPing func(ctx context.Context) error
}
func (W _database_sql_driver_Pinger) Ping(ctx context.Context) error { return W.WPing(ctx) }
// _database_sql_driver_Queryer is an interface wrapper for Queryer type
type _database_sql_driver_Queryer struct {
IValue interface{}
WQuery func(query string, args []driver.Value) (driver.Rows, error)
}
func (W _database_sql_driver_Queryer) Query(query string, args []driver.Value) (driver.Rows, error) {
return W.WQuery(query, args)
}
// _database_sql_driver_QueryerContext is an interface wrapper for QueryerContext type
type _database_sql_driver_QueryerContext struct {
IValue interface{}
WQueryContext func(ctx context.Context, query string, args []driver.NamedValue) (driver.Rows, error)
}
func (W _database_sql_driver_QueryerContext) QueryContext(ctx context.Context, query string, args []driver.NamedValue) (driver.Rows, error) {
return W.WQueryContext(ctx, query, args)
}
// _database_sql_driver_Result is an interface wrapper for Result type
type _database_sql_driver_Result struct {
IValue interface{}
WLastInsertId func() (int64, error)
WRowsAffected func() (int64, error)
}
func (W _database_sql_driver_Result) LastInsertId() (int64, error) { return W.WLastInsertId() }
func (W _database_sql_driver_Result) RowsAffected() (int64, error) { return W.WRowsAffected() }
// _database_sql_driver_Rows is an interface wrapper for Rows type
type _database_sql_driver_Rows struct {
IValue interface{}
WClose func() error
WColumns func() []string
WNext func(dest []driver.Value) error
}
func (W _database_sql_driver_Rows) Close() error { return W.WClose() }
func (W _database_sql_driver_Rows) Columns() []string { return W.WColumns() }
func (W _database_sql_driver_Rows) Next(dest []driver.Value) error { return W.WNext(dest) }
// _database_sql_driver_RowsColumnTypeDatabaseTypeName is an interface wrapper for RowsColumnTypeDatabaseTypeName type
type _database_sql_driver_RowsColumnTypeDatabaseTypeName struct {
IValue interface{}
WClose func() error
WColumnTypeDatabaseTypeName func(index int) string
WColumns func() []string
WNext func(dest []driver.Value) error
}
func (W _database_sql_driver_RowsColumnTypeDatabaseTypeName) Close() error { return W.WClose() }
func (W _database_sql_driver_RowsColumnTypeDatabaseTypeName) ColumnTypeDatabaseTypeName(index int) string {
return W.WColumnTypeDatabaseTypeName(index)
}
func (W _database_sql_driver_RowsColumnTypeDatabaseTypeName) Columns() []string { return W.WColumns() }
func (W _database_sql_driver_RowsColumnTypeDatabaseTypeName) Next(dest []driver.Value) error {
return W.WNext(dest)
}
// _database_sql_driver_RowsColumnTypeLength is an interface wrapper for RowsColumnTypeLength type
type _database_sql_driver_RowsColumnTypeLength struct {
IValue interface{}
WClose func() error
WColumnTypeLength func(index int) (length int64, ok bool)
WColumns func() []string
WNext func(dest []driver.Value) error
}
func (W _database_sql_driver_RowsColumnTypeLength) Close() error { return W.WClose() }
func (W _database_sql_driver_RowsColumnTypeLength) ColumnTypeLength(index int) (length int64, ok bool) {
return W.WColumnTypeLength(index)
}
func (W _database_sql_driver_RowsColumnTypeLength) Columns() []string { return W.WColumns() }
func (W _database_sql_driver_RowsColumnTypeLength) Next(dest []driver.Value) error {
return W.WNext(dest)
}
// _database_sql_driver_RowsColumnTypeNullable is an interface wrapper for RowsColumnTypeNullable type
type _database_sql_driver_RowsColumnTypeNullable struct {
IValue interface{}
WClose func() error
WColumnTypeNullable func(index int) (nullable bool, ok bool)
WColumns func() []string
WNext func(dest []driver.Value) error
}
func (W _database_sql_driver_RowsColumnTypeNullable) Close() error { return W.WClose() }
func (W _database_sql_driver_RowsColumnTypeNullable) ColumnTypeNullable(index int) (nullable bool, ok bool) {
return W.WColumnTypeNullable(index)
}
func (W _database_sql_driver_RowsColumnTypeNullable) Columns() []string { return W.WColumns() }
func (W _database_sql_driver_RowsColumnTypeNullable) Next(dest []driver.Value) error {
return W.WNext(dest)
}
// _database_sql_driver_RowsColumnTypePrecisionScale is an interface wrapper for RowsColumnTypePrecisionScale type
type _database_sql_driver_RowsColumnTypePrecisionScale struct {
IValue interface{}
WClose func() error
WColumnTypePrecisionScale func(index int) (precision int64, scale int64, ok bool)
WColumns func() []string
WNext func(dest []driver.Value) error
}
func (W _database_sql_driver_RowsColumnTypePrecisionScale) Close() error { return W.WClose() }
func (W _database_sql_driver_RowsColumnTypePrecisionScale) ColumnTypePrecisionScale(index int) (precision int64, scale int64, ok bool) {
return W.WColumnTypePrecisionScale(index)
}
func (W _database_sql_driver_RowsColumnTypePrecisionScale) Columns() []string { return W.WColumns() }
func (W _database_sql_driver_RowsColumnTypePrecisionScale) Next(dest []driver.Value) error {
return W.WNext(dest)
}
// _database_sql_driver_RowsColumnTypeScanType is an interface wrapper for RowsColumnTypeScanType type
type _database_sql_driver_RowsColumnTypeScanType struct {
IValue interface{}
WClose func() error
WColumnTypeScanType func(index int) reflect.Type
WColumns func() []string
WNext func(dest []driver.Value) error
}
func (W _database_sql_driver_RowsColumnTypeScanType) Close() error { return W.WClose() }
func (W _database_sql_driver_RowsColumnTypeScanType) ColumnTypeScanType(index int) reflect.Type {
return W.WColumnTypeScanType(index)
}
func (W _database_sql_driver_RowsColumnTypeScanType) Columns() []string { return W.WColumns() }
func (W _database_sql_driver_RowsColumnTypeScanType) Next(dest []driver.Value) error {
return W.WNext(dest)
}
// _database_sql_driver_RowsNextResultSet is an interface wrapper for RowsNextResultSet type
type _database_sql_driver_RowsNextResultSet struct {
IValue interface{}
WClose func() error
WColumns func() []string
WHasNextResultSet func() bool
WNext func(dest []driver.Value) error
WNextResultSet func() error
}
func (W _database_sql_driver_RowsNextResultSet) Close() error { return W.WClose() }
func (W _database_sql_driver_RowsNextResultSet) Columns() []string { return W.WColumns() }
func (W _database_sql_driver_RowsNextResultSet) HasNextResultSet() bool { return W.WHasNextResultSet() }
func (W _database_sql_driver_RowsNextResultSet) Next(dest []driver.Value) error { return W.WNext(dest) }
func (W _database_sql_driver_RowsNextResultSet) NextResultSet() error { return W.WNextResultSet() }
// _database_sql_driver_SessionResetter is an interface wrapper for SessionResetter type
type _database_sql_driver_SessionResetter struct {
IValue interface{}
WResetSession func(ctx context.Context) error
}
func (W _database_sql_driver_SessionResetter) ResetSession(ctx context.Context) error {
return W.WResetSession(ctx)
}
// _database_sql_driver_Stmt is an interface wrapper for Stmt type
type _database_sql_driver_Stmt struct {
IValue interface{}
WClose func() error
WExec func(args []driver.Value) (driver.Result, error)
WNumInput func() int
WQuery func(args []driver.Value) (driver.Rows, error)
}
func (W _database_sql_driver_Stmt) Close() error { return W.WClose() }
func (W _database_sql_driver_Stmt) Exec(args []driver.Value) (driver.Result, error) {
return W.WExec(args)
}
func (W _database_sql_driver_Stmt) NumInput() int { return W.WNumInput() }
func (W _database_sql_driver_Stmt) Query(args []driver.Value) (driver.Rows, error) {
return W.WQuery(args)
}
// _database_sql_driver_StmtExecContext is an interface wrapper for StmtExecContext type
type _database_sql_driver_StmtExecContext struct {
IValue interface{}
WExecContext func(ctx context.Context, args []driver.NamedValue) (driver.Result, error)
}
func (W _database_sql_driver_StmtExecContext) ExecContext(ctx context.Context, args []driver.NamedValue) (driver.Result, error) {
return W.WExecContext(ctx, args)
}
// _database_sql_driver_StmtQueryContext is an interface wrapper for StmtQueryContext type
type _database_sql_driver_StmtQueryContext struct {
IValue interface{}
WQueryContext func(ctx context.Context, args []driver.NamedValue) (driver.Rows, error)
}
func (W _database_sql_driver_StmtQueryContext) QueryContext(ctx context.Context, args []driver.NamedValue) (driver.Rows, error) {
return W.WQueryContext(ctx, args)
}
// _database_sql_driver_Tx is an interface wrapper for Tx type
type _database_sql_driver_Tx struct {
IValue interface{}
WCommit func() error
WRollback func() error
}
func (W _database_sql_driver_Tx) Commit() error { return W.WCommit() }
func (W _database_sql_driver_Tx) Rollback() error { return W.WRollback() }
// _database_sql_driver_Validator is an interface wrapper for Validator type
type _database_sql_driver_Validator struct {
IValue interface{}
WIsValid func() bool
}
func (W _database_sql_driver_Validator) IsValid() bool { return W.WIsValid() }
// _database_sql_driver_Value is an interface wrapper for Value type
type _database_sql_driver_Value struct {
IValue interface{}
}
// _database_sql_driver_ValueConverter is an interface wrapper for ValueConverter type
type _database_sql_driver_ValueConverter struct {
IValue interface{}
WConvertValue func(v any) (driver.Value, error)
}
func (W _database_sql_driver_ValueConverter) ConvertValue(v any) (driver.Value, error) {
return W.WConvertValue(v)
}
// _database_sql_driver_Valuer is an interface wrapper for Valuer type
type _database_sql_driver_Valuer struct {
IValue interface{}
WValue func() (driver.Value, error)
}
func (W _database_sql_driver_Valuer) Value() (driver.Value, error) { return W.WValue() }
================================================
FILE: stdlib/go1_22_debug_buildinfo.go
================================================
// Code generated by 'yaegi extract debug/buildinfo'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"debug/buildinfo"
"reflect"
)
func init() {
Symbols["debug/buildinfo/buildinfo"] = map[string]reflect.Value{
// function, constant and variable definitions
"Read": reflect.ValueOf(buildinfo.Read),
"ReadFile": reflect.ValueOf(buildinfo.ReadFile),
// type definitions
"BuildInfo": reflect.ValueOf((*buildinfo.BuildInfo)(nil)),
}
}
================================================
FILE: stdlib/go1_22_debug_dwarf.go
================================================
// Code generated by 'yaegi extract debug/dwarf'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"debug/dwarf"
"reflect"
)
func init() {
Symbols["debug/dwarf/dwarf"] = map[string]reflect.Value{
// function, constant and variable definitions
"AttrAbstractOrigin": reflect.ValueOf(dwarf.AttrAbstractOrigin),
"AttrAccessibility": reflect.ValueOf(dwarf.AttrAccessibility),
"AttrAddrBase": reflect.ValueOf(dwarf.AttrAddrBase),
"AttrAddrClass": reflect.ValueOf(dwarf.AttrAddrClass),
"AttrAlignment": reflect.ValueOf(dwarf.AttrAlignment),
"AttrAllocated": reflect.ValueOf(dwarf.AttrAllocated),
"AttrArtificial": reflect.ValueOf(dwarf.AttrArtificial),
"AttrAssociated": reflect.ValueOf(dwarf.AttrAssociated),
"AttrBaseTypes": reflect.ValueOf(dwarf.AttrBaseTypes),
"AttrBinaryScale": reflect.ValueOf(dwarf.AttrBinaryScale),
"AttrBitOffset": reflect.ValueOf(dwarf.AttrBitOffset),
"AttrBitSize": reflect.ValueOf(dwarf.AttrBitSize),
"AttrByteSize": reflect.ValueOf(dwarf.AttrByteSize),
"AttrCallAllCalls": reflect.ValueOf(dwarf.AttrCallAllCalls),
"AttrCallAllSourceCalls": reflect.ValueOf(dwarf.AttrCallAllSourceCalls),
"AttrCallAllTailCalls": reflect.ValueOf(dwarf.AttrCallAllTailCalls),
"AttrCallColumn": reflect.ValueOf(dwarf.AttrCallColumn),
"AttrCallDataLocation": reflect.ValueOf(dwarf.AttrCallDataLocation),
"AttrCallDataValue": reflect.ValueOf(dwarf.AttrCallDataValue),
"AttrCallFile": reflect.ValueOf(dwarf.AttrCallFile),
"AttrCallLine": reflect.ValueOf(dwarf.AttrCallLine),
"AttrCallOrigin": reflect.ValueOf(dwarf.AttrCallOrigin),
"AttrCallPC": reflect.ValueOf(dwarf.AttrCallPC),
"AttrCallParameter": reflect.ValueOf(dwarf.AttrCallParameter),
"AttrCallReturnPC": reflect.ValueOf(dwarf.AttrCallReturnPC),
"AttrCallTailCall": reflect.ValueOf(dwarf.AttrCallTailCall),
"AttrCallTarget": reflect.ValueOf(dwarf.AttrCallTarget),
"AttrCallTargetClobbered": reflect.ValueOf(dwarf.AttrCallTargetClobbered),
"AttrCallValue": reflect.ValueOf(dwarf.AttrCallValue),
"AttrCalling": reflect.ValueOf(dwarf.AttrCalling),
"AttrCommonRef": reflect.ValueOf(dwarf.AttrCommonRef),
"AttrCompDir": reflect.ValueOf(dwarf.AttrCompDir),
"AttrConstExpr": reflect.ValueOf(dwarf.AttrConstExpr),
"AttrConstValue": reflect.ValueOf(dwarf.AttrConstValue),
"AttrContainingType": reflect.ValueOf(dwarf.AttrContainingType),
"AttrCount": reflect.ValueOf(dwarf.AttrCount),
"AttrDataBitOffset": reflect.ValueOf(dwarf.AttrDataBitOffset),
"AttrDataLocation": reflect.ValueOf(dwarf.AttrDataLocation),
"AttrDataMemberLoc": reflect.ValueOf(dwarf.AttrDataMemberLoc),
"AttrDecimalScale": reflect.ValueOf(dwarf.AttrDecimalScale),
"AttrDecimalSign": reflect.ValueOf(dwarf.AttrDecimalSign),
"AttrDeclColumn": reflect.ValueOf(dwarf.AttrDeclColumn),
"AttrDeclFile": reflect.ValueOf(dwarf.AttrDeclFile),
"AttrDeclLine": reflect.ValueOf(dwarf.AttrDeclLine),
"AttrDeclaration": reflect.ValueOf(dwarf.AttrDeclaration),
"AttrDefaultValue": reflect.ValueOf(dwarf.AttrDefaultValue),
"AttrDefaulted": reflect.ValueOf(dwarf.AttrDefaulted),
"AttrDeleted": reflect.ValueOf(dwarf.AttrDeleted),
"AttrDescription": reflect.ValueOf(dwarf.AttrDescription),
"AttrDigitCount": reflect.ValueOf(dwarf.AttrDigitCount),
"AttrDiscr": reflect.ValueOf(dwarf.AttrDiscr),
"AttrDiscrList": reflect.ValueOf(dwarf.AttrDiscrList),
"AttrDiscrValue": reflect.ValueOf(dwarf.AttrDiscrValue),
"AttrDwoName": reflect.ValueOf(dwarf.AttrDwoName),
"AttrElemental": reflect.ValueOf(dwarf.AttrElemental),
"AttrEncoding": reflect.ValueOf(dwarf.AttrEncoding),
"AttrEndianity": reflect.ValueOf(dwarf.AttrEndianity),
"AttrEntrypc": reflect.ValueOf(dwarf.AttrEntrypc),
"AttrEnumClass": reflect.ValueOf(dwarf.AttrEnumClass),
"AttrExplicit": reflect.ValueOf(dwarf.AttrExplicit),
"AttrExportSymbols": reflect.ValueOf(dwarf.AttrExportSymbols),
"AttrExtension": reflect.ValueOf(dwarf.AttrExtension),
"AttrExternal": reflect.ValueOf(dwarf.AttrExternal),
"AttrFrameBase": reflect.ValueOf(dwarf.AttrFrameBase),
"AttrFriend": reflect.ValueOf(dwarf.AttrFriend),
"AttrHighpc": reflect.ValueOf(dwarf.AttrHighpc),
"AttrIdentifierCase": reflect.ValueOf(dwarf.AttrIdentifierCase),
"AttrImport": reflect.ValueOf(dwarf.AttrImport),
"AttrInline": reflect.ValueOf(dwarf.AttrInline),
"AttrIsOptional": reflect.ValueOf(dwarf.AttrIsOptional),
"AttrLanguage": reflect.ValueOf(dwarf.AttrLanguage),
"AttrLinkageName": reflect.ValueOf(dwarf.AttrLinkageName),
"AttrLocation": reflect.ValueOf(dwarf.AttrLocation),
"AttrLoclistsBase": reflect.ValueOf(dwarf.AttrLoclistsBase),
"AttrLowerBound": reflect.ValueOf(dwarf.AttrLowerBound),
"AttrLowpc": reflect.ValueOf(dwarf.AttrLowpc),
"AttrMacroInfo": reflect.ValueOf(dwarf.AttrMacroInfo),
"AttrMacros": reflect.ValueOf(dwarf.AttrMacros),
"AttrMainSubprogram": reflect.ValueOf(dwarf.AttrMainSubprogram),
"AttrMutable": reflect.ValueOf(dwarf.AttrMutable),
"AttrName": reflect.ValueOf(dwarf.AttrName),
"AttrNamelistItem": reflect.ValueOf(dwarf.AttrNamelistItem),
"AttrNoreturn": reflect.ValueOf(dwarf.AttrNoreturn),
"AttrObjectPointer": reflect.ValueOf(dwarf.AttrObjectPointer),
"AttrOrdering": reflect.ValueOf(dwarf.AttrOrdering),
"AttrPictureString": reflect.ValueOf(dwarf.AttrPictureString),
"AttrPriority": reflect.ValueOf(dwarf.AttrPriority),
"AttrProducer": reflect.ValueOf(dwarf.AttrProducer),
"AttrPrototyped": reflect.ValueOf(dwarf.AttrPrototyped),
"AttrPure": reflect.ValueOf(dwarf.AttrPure),
"AttrRanges": reflect.ValueOf(dwarf.AttrRanges),
"AttrRank": reflect.ValueOf(dwarf.AttrRank),
"AttrRecursive": reflect.ValueOf(dwarf.AttrRecursive),
"AttrReference": reflect.ValueOf(dwarf.AttrReference),
"AttrReturnAddr": reflect.ValueOf(dwarf.AttrReturnAddr),
"AttrRnglistsBase": reflect.ValueOf(dwarf.AttrRnglistsBase),
"AttrRvalueReference": reflect.ValueOf(dwarf.AttrRvalueReference),
"AttrSegment": reflect.ValueOf(dwarf.AttrSegment),
"AttrSibling": reflect.ValueOf(dwarf.AttrSibling),
"AttrSignature": reflect.ValueOf(dwarf.AttrSignature),
"AttrSmall": reflect.ValueOf(dwarf.AttrSmall),
"AttrSpecification": reflect.ValueOf(dwarf.AttrSpecification),
"AttrStartScope": reflect.ValueOf(dwarf.AttrStartScope),
"AttrStaticLink": reflect.ValueOf(dwarf.AttrStaticLink),
"AttrStmtList": reflect.ValueOf(dwarf.AttrStmtList),
"AttrStrOffsetsBase": reflect.ValueOf(dwarf.AttrStrOffsetsBase),
"AttrStride": reflect.ValueOf(dwarf.AttrStride),
"AttrStrideSize": reflect.ValueOf(dwarf.AttrStrideSize),
"AttrStringLength": reflect.ValueOf(dwarf.AttrStringLength),
"AttrStringLengthBitSize": reflect.ValueOf(dwarf.AttrStringLengthBitSize),
"AttrStringLengthByteSize": reflect.ValueOf(dwarf.AttrStringLengthByteSize),
"AttrThreadsScaled": reflect.ValueOf(dwarf.AttrThreadsScaled),
"AttrTrampoline": reflect.ValueOf(dwarf.AttrTrampoline),
"AttrType": reflect.ValueOf(dwarf.AttrType),
"AttrUpperBound": reflect.ValueOf(dwarf.AttrUpperBound),
"AttrUseLocation": reflect.ValueOf(dwarf.AttrUseLocation),
"AttrUseUTF8": reflect.ValueOf(dwarf.AttrUseUTF8),
"AttrVarParam": reflect.ValueOf(dwarf.AttrVarParam),
"AttrVirtuality": reflect.ValueOf(dwarf.AttrVirtuality),
"AttrVisibility": reflect.ValueOf(dwarf.AttrVisibility),
"AttrVtableElemLoc": reflect.ValueOf(dwarf.AttrVtableElemLoc),
"ClassAddrPtr": reflect.ValueOf(dwarf.ClassAddrPtr),
"ClassAddress": reflect.ValueOf(dwarf.ClassAddress),
"ClassBlock": reflect.ValueOf(dwarf.ClassBlock),
"ClassConstant": reflect.ValueOf(dwarf.ClassConstant),
"ClassExprLoc": reflect.ValueOf(dwarf.ClassExprLoc),
"ClassFlag": reflect.ValueOf(dwarf.ClassFlag),
"ClassLinePtr": reflect.ValueOf(dwarf.ClassLinePtr),
"ClassLocList": reflect.ValueOf(dwarf.ClassLocList),
"ClassLocListPtr": reflect.ValueOf(dwarf.ClassLocListPtr),
"ClassMacPtr": reflect.ValueOf(dwarf.ClassMacPtr),
"ClassRangeListPtr": reflect.ValueOf(dwarf.ClassRangeListPtr),
"ClassReference": reflect.ValueOf(dwarf.ClassReference),
"ClassReferenceAlt": reflect.ValueOf(dwarf.ClassReferenceAlt),
"ClassReferenceSig": reflect.ValueOf(dwarf.ClassReferenceSig),
"ClassRngList": reflect.ValueOf(dwarf.ClassRngList),
"ClassRngListsPtr": reflect.ValueOf(dwarf.ClassRngListsPtr),
"ClassStrOffsetsPtr": reflect.ValueOf(dwarf.ClassStrOffsetsPtr),
"ClassString": reflect.ValueOf(dwarf.ClassString),
"ClassStringAlt": reflect.ValueOf(dwarf.ClassStringAlt),
"ClassUnknown": reflect.ValueOf(dwarf.ClassUnknown),
"ErrUnknownPC": reflect.ValueOf(&dwarf.ErrUnknownPC).Elem(),
"New": reflect.ValueOf(dwarf.New),
"TagAccessDeclaration": reflect.ValueOf(dwarf.TagAccessDeclaration),
"TagArrayType": reflect.ValueOf(dwarf.TagArrayType),
"TagAtomicType": reflect.ValueOf(dwarf.TagAtomicType),
"TagBaseType": reflect.ValueOf(dwarf.TagBaseType),
"TagCallSite": reflect.ValueOf(dwarf.TagCallSite),
"TagCallSiteParameter": reflect.ValueOf(dwarf.TagCallSiteParameter),
"TagCatchDwarfBlock": reflect.ValueOf(dwarf.TagCatchDwarfBlock),
"TagClassType": reflect.ValueOf(dwarf.TagClassType),
"TagCoarrayType": reflect.ValueOf(dwarf.TagCoarrayType),
"TagCommonDwarfBlock": reflect.ValueOf(dwarf.TagCommonDwarfBlock),
"TagCommonInclusion": reflect.ValueOf(dwarf.TagCommonInclusion),
"TagCompileUnit": reflect.ValueOf(dwarf.TagCompileUnit),
"TagCondition": reflect.ValueOf(dwarf.TagCondition),
"TagConstType": reflect.ValueOf(dwarf.TagConstType),
"TagConstant": reflect.ValueOf(dwarf.TagConstant),
"TagDwarfProcedure": reflect.ValueOf(dwarf.TagDwarfProcedure),
"TagDynamicType": reflect.ValueOf(dwarf.TagDynamicType),
"TagEntryPoint": reflect.ValueOf(dwarf.TagEntryPoint),
"TagEnumerationType": reflect.ValueOf(dwarf.TagEnumerationType),
"TagEnumerator": reflect.ValueOf(dwarf.TagEnumerator),
"TagFileType": reflect.ValueOf(dwarf.TagFileType),
"TagFormalParameter": reflect.ValueOf(dwarf.TagFormalParameter),
"TagFriend": reflect.ValueOf(dwarf.TagFriend),
"TagGenericSubrange": reflect.ValueOf(dwarf.TagGenericSubrange),
"TagImmutableType": reflect.ValueOf(dwarf.TagImmutableType),
"TagImportedDeclaration": reflect.ValueOf(dwarf.TagImportedDeclaration),
"TagImportedModule": reflect.ValueOf(dwarf.TagImportedModule),
"TagImportedUnit": reflect.ValueOf(dwarf.TagImportedUnit),
"TagInheritance": reflect.ValueOf(dwarf.TagInheritance),
"TagInlinedSubroutine": reflect.ValueOf(dwarf.TagInlinedSubroutine),
"TagInterfaceType": reflect.ValueOf(dwarf.TagInterfaceType),
"TagLabel": reflect.ValueOf(dwarf.TagLabel),
"TagLexDwarfBlock": reflect.ValueOf(dwarf.TagLexDwarfBlock),
"TagMember": reflect.ValueOf(dwarf.TagMember),
"TagModule": reflect.ValueOf(dwarf.TagModule),
"TagMutableType": reflect.ValueOf(dwarf.TagMutableType),
"TagNamelist": reflect.ValueOf(dwarf.TagNamelist),
"TagNamelistItem": reflect.ValueOf(dwarf.TagNamelistItem),
"TagNamespace": reflect.ValueOf(dwarf.TagNamespace),
"TagPackedType": reflect.ValueOf(dwarf.TagPackedType),
"TagPartialUnit": reflect.ValueOf(dwarf.TagPartialUnit),
"TagPointerType": reflect.ValueOf(dwarf.TagPointerType),
"TagPtrToMemberType": reflect.ValueOf(dwarf.TagPtrToMemberType),
"TagReferenceType": reflect.ValueOf(dwarf.TagReferenceType),
"TagRestrictType": reflect.ValueOf(dwarf.TagRestrictType),
"TagRvalueReferenceType": reflect.ValueOf(dwarf.TagRvalueReferenceType),
"TagSetType": reflect.ValueOf(dwarf.TagSetType),
"TagSharedType": reflect.ValueOf(dwarf.TagSharedType),
"TagSkeletonUnit": reflect.ValueOf(dwarf.TagSkeletonUnit),
"TagStringType": reflect.ValueOf(dwarf.TagStringType),
"TagStructType": reflect.ValueOf(dwarf.TagStructType),
"TagSubprogram": reflect.ValueOf(dwarf.TagSubprogram),
"TagSubrangeType": reflect.ValueOf(dwarf.TagSubrangeType),
"TagSubroutineType": reflect.ValueOf(dwarf.TagSubroutineType),
"TagTemplateAlias": reflect.ValueOf(dwarf.TagTemplateAlias),
"TagTemplateTypeParameter": reflect.ValueOf(dwarf.TagTemplateTypeParameter),
"TagTemplateValueParameter": reflect.ValueOf(dwarf.TagTemplateValueParameter),
"TagThrownType": reflect.ValueOf(dwarf.TagThrownType),
"TagTryDwarfBlock": reflect.ValueOf(dwarf.TagTryDwarfBlock),
"TagTypeUnit": reflect.ValueOf(dwarf.TagTypeUnit),
"TagTypedef": reflect.ValueOf(dwarf.TagTypedef),
"TagUnionType": reflect.ValueOf(dwarf.TagUnionType),
"TagUnspecifiedParameters": reflect.ValueOf(dwarf.TagUnspecifiedParameters),
"TagUnspecifiedType": reflect.ValueOf(dwarf.TagUnspecifiedType),
"TagVariable": reflect.ValueOf(dwarf.TagVariable),
"TagVariant": reflect.ValueOf(dwarf.TagVariant),
"TagVariantPart": reflect.ValueOf(dwarf.TagVariantPart),
"TagVolatileType": reflect.ValueOf(dwarf.TagVolatileType),
"TagWithStmt": reflect.ValueOf(dwarf.TagWithStmt),
// type definitions
"AddrType": reflect.ValueOf((*dwarf.AddrType)(nil)),
"ArrayType": reflect.ValueOf((*dwarf.ArrayType)(nil)),
"Attr": reflect.ValueOf((*dwarf.Attr)(nil)),
"BasicType": reflect.ValueOf((*dwarf.BasicType)(nil)),
"BoolType": reflect.ValueOf((*dwarf.BoolType)(nil)),
"CharType": reflect.ValueOf((*dwarf.CharType)(nil)),
"Class": reflect.ValueOf((*dwarf.Class)(nil)),
"CommonType": reflect.ValueOf((*dwarf.CommonType)(nil)),
"ComplexType": reflect.ValueOf((*dwarf.ComplexType)(nil)),
"Data": reflect.ValueOf((*dwarf.Data)(nil)),
"DecodeError": reflect.ValueOf((*dwarf.DecodeError)(nil)),
"DotDotDotType": reflect.ValueOf((*dwarf.DotDotDotType)(nil)),
"Entry": reflect.ValueOf((*dwarf.Entry)(nil)),
"EnumType": reflect.ValueOf((*dwarf.EnumType)(nil)),
"EnumValue": reflect.ValueOf((*dwarf.EnumValue)(nil)),
"Field": reflect.ValueOf((*dwarf.Field)(nil)),
"FloatType": reflect.ValueOf((*dwarf.FloatType)(nil)),
"FuncType": reflect.ValueOf((*dwarf.FuncType)(nil)),
"IntType": reflect.ValueOf((*dwarf.IntType)(nil)),
"LineEntry": reflect.ValueOf((*dwarf.LineEntry)(nil)),
"LineFile": reflect.ValueOf((*dwarf.LineFile)(nil)),
"LineReader": reflect.ValueOf((*dwarf.LineReader)(nil)),
"LineReaderPos": reflect.ValueOf((*dwarf.LineReaderPos)(nil)),
"Offset": reflect.ValueOf((*dwarf.Offset)(nil)),
"PtrType": reflect.ValueOf((*dwarf.PtrType)(nil)),
"QualType": reflect.ValueOf((*dwarf.QualType)(nil)),
"Reader": reflect.ValueOf((*dwarf.Reader)(nil)),
"StructField": reflect.ValueOf((*dwarf.StructField)(nil)),
"StructType": reflect.ValueOf((*dwarf.StructType)(nil)),
"Tag": reflect.ValueOf((*dwarf.Tag)(nil)),
"Type": reflect.ValueOf((*dwarf.Type)(nil)),
"TypedefType": reflect.ValueOf((*dwarf.TypedefType)(nil)),
"UcharType": reflect.ValueOf((*dwarf.UcharType)(nil)),
"UintType": reflect.ValueOf((*dwarf.UintType)(nil)),
"UnspecifiedType": reflect.ValueOf((*dwarf.UnspecifiedType)(nil)),
"UnsupportedType": reflect.ValueOf((*dwarf.UnsupportedType)(nil)),
"VoidType": reflect.ValueOf((*dwarf.VoidType)(nil)),
// interface wrapper definitions
"_Type": reflect.ValueOf((*_debug_dwarf_Type)(nil)),
}
}
// _debug_dwarf_Type is an interface wrapper for Type type
type _debug_dwarf_Type struct {
IValue interface{}
WCommon func() *dwarf.CommonType
WSize func() int64
WString func() string
}
func (W _debug_dwarf_Type) Common() *dwarf.CommonType { return W.WCommon() }
func (W _debug_dwarf_Type) Size() int64 { return W.WSize() }
func (W _debug_dwarf_Type) String() string {
if W.WString == nil {
return ""
}
return W.WString()
}
================================================
FILE: stdlib/go1_22_debug_elf.go
================================================
// Code generated by 'yaegi extract debug/elf'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"debug/elf"
"go/constant"
"go/token"
"reflect"
)
func init() {
Symbols["debug/elf/elf"] = map[string]reflect.Value{
// function, constant and variable definitions
"ARM_MAGIC_TRAMP_NUMBER": reflect.ValueOf(constant.MakeFromLiteral("1543503875", token.INT, 0)),
"COMPRESS_HIOS": reflect.ValueOf(elf.COMPRESS_HIOS),
"COMPRESS_HIPROC": reflect.ValueOf(elf.COMPRESS_HIPROC),
"COMPRESS_LOOS": reflect.ValueOf(elf.COMPRESS_LOOS),
"COMPRESS_LOPROC": reflect.ValueOf(elf.COMPRESS_LOPROC),
"COMPRESS_ZLIB": reflect.ValueOf(elf.COMPRESS_ZLIB),
"COMPRESS_ZSTD": reflect.ValueOf(elf.COMPRESS_ZSTD),
"DF_1_CONFALT": reflect.ValueOf(elf.DF_1_CONFALT),
"DF_1_DIRECT": reflect.ValueOf(elf.DF_1_DIRECT),
"DF_1_DISPRELDNE": reflect.ValueOf(elf.DF_1_DISPRELDNE),
"DF_1_DISPRELPND": reflect.ValueOf(elf.DF_1_DISPRELPND),
"DF_1_EDITED": reflect.ValueOf(elf.DF_1_EDITED),
"DF_1_ENDFILTEE": reflect.ValueOf(elf.DF_1_ENDFILTEE),
"DF_1_GLOBAL": reflect.ValueOf(elf.DF_1_GLOBAL),
"DF_1_GLOBAUDIT": reflect.ValueOf(elf.DF_1_GLOBAUDIT),
"DF_1_GROUP": reflect.ValueOf(elf.DF_1_GROUP),
"DF_1_IGNMULDEF": reflect.ValueOf(elf.DF_1_IGNMULDEF),
"DF_1_INITFIRST": reflect.ValueOf(elf.DF_1_INITFIRST),
"DF_1_INTERPOSE": reflect.ValueOf(elf.DF_1_INTERPOSE),
"DF_1_KMOD": reflect.ValueOf(elf.DF_1_KMOD),
"DF_1_LOADFLTR": reflect.ValueOf(elf.DF_1_LOADFLTR),
"DF_1_NOCOMMON": reflect.ValueOf(elf.DF_1_NOCOMMON),
"DF_1_NODEFLIB": reflect.ValueOf(elf.DF_1_NODEFLIB),
"DF_1_NODELETE": reflect.ValueOf(elf.DF_1_NODELETE),
"DF_1_NODIRECT": reflect.ValueOf(elf.DF_1_NODIRECT),
"DF_1_NODUMP": reflect.ValueOf(elf.DF_1_NODUMP),
"DF_1_NOHDR": reflect.ValueOf(elf.DF_1_NOHDR),
"DF_1_NOKSYMS": reflect.ValueOf(elf.DF_1_NOKSYMS),
"DF_1_NOOPEN": reflect.ValueOf(elf.DF_1_NOOPEN),
"DF_1_NORELOC": reflect.ValueOf(elf.DF_1_NORELOC),
"DF_1_NOW": reflect.ValueOf(elf.DF_1_NOW),
"DF_1_ORIGIN": reflect.ValueOf(elf.DF_1_ORIGIN),
"DF_1_PIE": reflect.ValueOf(elf.DF_1_PIE),
"DF_1_SINGLETON": reflect.ValueOf(elf.DF_1_SINGLETON),
"DF_1_STUB": reflect.ValueOf(elf.DF_1_STUB),
"DF_1_SYMINTPOSE": reflect.ValueOf(elf.DF_1_SYMINTPOSE),
"DF_1_TRANS": reflect.ValueOf(elf.DF_1_TRANS),
"DF_1_WEAKFILTER": reflect.ValueOf(elf.DF_1_WEAKFILTER),
"DF_BIND_NOW": reflect.ValueOf(elf.DF_BIND_NOW),
"DF_ORIGIN": reflect.ValueOf(elf.DF_ORIGIN),
"DF_STATIC_TLS": reflect.ValueOf(elf.DF_STATIC_TLS),
"DF_SYMBOLIC": reflect.ValueOf(elf.DF_SYMBOLIC),
"DF_TEXTREL": reflect.ValueOf(elf.DF_TEXTREL),
"DT_ADDRRNGHI": reflect.ValueOf(elf.DT_ADDRRNGHI),
"DT_ADDRRNGLO": reflect.ValueOf(elf.DT_ADDRRNGLO),
"DT_AUDIT": reflect.ValueOf(elf.DT_AUDIT),
"DT_AUXILIARY": reflect.ValueOf(elf.DT_AUXILIARY),
"DT_BIND_NOW": reflect.ValueOf(elf.DT_BIND_NOW),
"DT_CHECKSUM": reflect.ValueOf(elf.DT_CHECKSUM),
"DT_CONFIG": reflect.ValueOf(elf.DT_CONFIG),
"DT_DEBUG": reflect.ValueOf(elf.DT_DEBUG),
"DT_DEPAUDIT": reflect.ValueOf(elf.DT_DEPAUDIT),
"DT_ENCODING": reflect.ValueOf(elf.DT_ENCODING),
"DT_FEATURE": reflect.ValueOf(elf.DT_FEATURE),
"DT_FILTER": reflect.ValueOf(elf.DT_FILTER),
"DT_FINI": reflect.ValueOf(elf.DT_FINI),
"DT_FINI_ARRAY": reflect.ValueOf(elf.DT_FINI_ARRAY),
"DT_FINI_ARRAYSZ": reflect.ValueOf(elf.DT_FINI_ARRAYSZ),
"DT_FLAGS": reflect.ValueOf(elf.DT_FLAGS),
"DT_FLAGS_1": reflect.ValueOf(elf.DT_FLAGS_1),
"DT_GNU_CONFLICT": reflect.ValueOf(elf.DT_GNU_CONFLICT),
"DT_GNU_CONFLICTSZ": reflect.ValueOf(elf.DT_GNU_CONFLICTSZ),
"DT_GNU_HASH": reflect.ValueOf(elf.DT_GNU_HASH),
"DT_GNU_LIBLIST": reflect.ValueOf(elf.DT_GNU_LIBLIST),
"DT_GNU_LIBLISTSZ": reflect.ValueOf(elf.DT_GNU_LIBLISTSZ),
"DT_GNU_PRELINKED": reflect.ValueOf(elf.DT_GNU_PRELINKED),
"DT_HASH": reflect.ValueOf(elf.DT_HASH),
"DT_HIOS": reflect.ValueOf(elf.DT_HIOS),
"DT_HIPROC": reflect.ValueOf(elf.DT_HIPROC),
"DT_INIT": reflect.ValueOf(elf.DT_INIT),
"DT_INIT_ARRAY": reflect.ValueOf(elf.DT_INIT_ARRAY),
"DT_INIT_ARRAYSZ": reflect.ValueOf(elf.DT_INIT_ARRAYSZ),
"DT_JMPREL": reflect.ValueOf(elf.DT_JMPREL),
"DT_LOOS": reflect.ValueOf(elf.DT_LOOS),
"DT_LOPROC": reflect.ValueOf(elf.DT_LOPROC),
"DT_MIPS_AUX_DYNAMIC": reflect.ValueOf(elf.DT_MIPS_AUX_DYNAMIC),
"DT_MIPS_BASE_ADDRESS": reflect.ValueOf(elf.DT_MIPS_BASE_ADDRESS),
"DT_MIPS_COMPACT_SIZE": reflect.ValueOf(elf.DT_MIPS_COMPACT_SIZE),
"DT_MIPS_CONFLICT": reflect.ValueOf(elf.DT_MIPS_CONFLICT),
"DT_MIPS_CONFLICTNO": reflect.ValueOf(elf.DT_MIPS_CONFLICTNO),
"DT_MIPS_CXX_FLAGS": reflect.ValueOf(elf.DT_MIPS_CXX_FLAGS),
"DT_MIPS_DELTA_CLASS": reflect.ValueOf(elf.DT_MIPS_DELTA_CLASS),
"DT_MIPS_DELTA_CLASSSYM": reflect.ValueOf(elf.DT_MIPS_DELTA_CLASSSYM),
"DT_MIPS_DELTA_CLASSSYM_NO": reflect.ValueOf(elf.DT_MIPS_DELTA_CLASSSYM_NO),
"DT_MIPS_DELTA_CLASS_NO": reflect.ValueOf(elf.DT_MIPS_DELTA_CLASS_NO),
"DT_MIPS_DELTA_INSTANCE": reflect.ValueOf(elf.DT_MIPS_DELTA_INSTANCE),
"DT_MIPS_DELTA_INSTANCE_NO": reflect.ValueOf(elf.DT_MIPS_DELTA_INSTANCE_NO),
"DT_MIPS_DELTA_RELOC": reflect.ValueOf(elf.DT_MIPS_DELTA_RELOC),
"DT_MIPS_DELTA_RELOC_NO": reflect.ValueOf(elf.DT_MIPS_DELTA_RELOC_NO),
"DT_MIPS_DELTA_SYM": reflect.ValueOf(elf.DT_MIPS_DELTA_SYM),
"DT_MIPS_DELTA_SYM_NO": reflect.ValueOf(elf.DT_MIPS_DELTA_SYM_NO),
"DT_MIPS_DYNSTR_ALIGN": reflect.ValueOf(elf.DT_MIPS_DYNSTR_ALIGN),
"DT_MIPS_FLAGS": reflect.ValueOf(elf.DT_MIPS_FLAGS),
"DT_MIPS_GOTSYM": reflect.ValueOf(elf.DT_MIPS_GOTSYM),
"DT_MIPS_GP_VALUE": reflect.ValueOf(elf.DT_MIPS_GP_VALUE),
"DT_MIPS_HIDDEN_GOTIDX": reflect.ValueOf(elf.DT_MIPS_HIDDEN_GOTIDX),
"DT_MIPS_HIPAGENO": reflect.ValueOf(elf.DT_MIPS_HIPAGENO),
"DT_MIPS_ICHECKSUM": reflect.ValueOf(elf.DT_MIPS_ICHECKSUM),
"DT_MIPS_INTERFACE": reflect.ValueOf(elf.DT_MIPS_INTERFACE),
"DT_MIPS_INTERFACE_SIZE": reflect.ValueOf(elf.DT_MIPS_INTERFACE_SIZE),
"DT_MIPS_IVERSION": reflect.ValueOf(elf.DT_MIPS_IVERSION),
"DT_MIPS_LIBLIST": reflect.ValueOf(elf.DT_MIPS_LIBLIST),
"DT_MIPS_LIBLISTNO": reflect.ValueOf(elf.DT_MIPS_LIBLISTNO),
"DT_MIPS_LOCALPAGE_GOTIDX": reflect.ValueOf(elf.DT_MIPS_LOCALPAGE_GOTIDX),
"DT_MIPS_LOCAL_GOTIDX": reflect.ValueOf(elf.DT_MIPS_LOCAL_GOTIDX),
"DT_MIPS_LOCAL_GOTNO": reflect.ValueOf(elf.DT_MIPS_LOCAL_GOTNO),
"DT_MIPS_MSYM": reflect.ValueOf(elf.DT_MIPS_MSYM),
"DT_MIPS_OPTIONS": reflect.ValueOf(elf.DT_MIPS_OPTIONS),
"DT_MIPS_PERF_SUFFIX": reflect.ValueOf(elf.DT_MIPS_PERF_SUFFIX),
"DT_MIPS_PIXIE_INIT": reflect.ValueOf(elf.DT_MIPS_PIXIE_INIT),
"DT_MIPS_PLTGOT": reflect.ValueOf(elf.DT_MIPS_PLTGOT),
"DT_MIPS_PROTECTED_GOTIDX": reflect.ValueOf(elf.DT_MIPS_PROTECTED_GOTIDX),
"DT_MIPS_RLD_MAP": reflect.ValueOf(elf.DT_MIPS_RLD_MAP),
"DT_MIPS_RLD_MAP_REL": reflect.ValueOf(elf.DT_MIPS_RLD_MAP_REL),
"DT_MIPS_RLD_TEXT_RESOLVE_ADDR": reflect.ValueOf(elf.DT_MIPS_RLD_TEXT_RESOLVE_ADDR),
"DT_MIPS_RLD_VERSION": reflect.ValueOf(elf.DT_MIPS_RLD_VERSION),
"DT_MIPS_RWPLT": reflect.ValueOf(elf.DT_MIPS_RWPLT),
"DT_MIPS_SYMBOL_LIB": reflect.ValueOf(elf.DT_MIPS_SYMBOL_LIB),
"DT_MIPS_SYMTABNO": reflect.ValueOf(elf.DT_MIPS_SYMTABNO),
"DT_MIPS_TIME_STAMP": reflect.ValueOf(elf.DT_MIPS_TIME_STAMP),
"DT_MIPS_UNREFEXTNO": reflect.ValueOf(elf.DT_MIPS_UNREFEXTNO),
"DT_MOVEENT": reflect.ValueOf(elf.DT_MOVEENT),
"DT_MOVESZ": reflect.ValueOf(elf.DT_MOVESZ),
"DT_MOVETAB": reflect.ValueOf(elf.DT_MOVETAB),
"DT_NEEDED": reflect.ValueOf(elf.DT_NEEDED),
"DT_NULL": reflect.ValueOf(elf.DT_NULL),
"DT_PLTGOT": reflect.ValueOf(elf.DT_PLTGOT),
"DT_PLTPAD": reflect.ValueOf(elf.DT_PLTPAD),
"DT_PLTPADSZ": reflect.ValueOf(elf.DT_PLTPADSZ),
"DT_PLTREL": reflect.ValueOf(elf.DT_PLTREL),
"DT_PLTRELSZ": reflect.ValueOf(elf.DT_PLTRELSZ),
"DT_POSFLAG_1": reflect.ValueOf(elf.DT_POSFLAG_1),
"DT_PPC64_GLINK": reflect.ValueOf(elf.DT_PPC64_GLINK),
"DT_PPC64_OPD": reflect.ValueOf(elf.DT_PPC64_OPD),
"DT_PPC64_OPDSZ": reflect.ValueOf(elf.DT_PPC64_OPDSZ),
"DT_PPC64_OPT": reflect.ValueOf(elf.DT_PPC64_OPT),
"DT_PPC_GOT": reflect.ValueOf(elf.DT_PPC_GOT),
"DT_PPC_OPT": reflect.ValueOf(elf.DT_PPC_OPT),
"DT_PREINIT_ARRAY": reflect.ValueOf(elf.DT_PREINIT_ARRAY),
"DT_PREINIT_ARRAYSZ": reflect.ValueOf(elf.DT_PREINIT_ARRAYSZ),
"DT_REL": reflect.ValueOf(elf.DT_REL),
"DT_RELA": reflect.ValueOf(elf.DT_RELA),
"DT_RELACOUNT": reflect.ValueOf(elf.DT_RELACOUNT),
"DT_RELAENT": reflect.ValueOf(elf.DT_RELAENT),
"DT_RELASZ": reflect.ValueOf(elf.DT_RELASZ),
"DT_RELCOUNT": reflect.ValueOf(elf.DT_RELCOUNT),
"DT_RELENT": reflect.ValueOf(elf.DT_RELENT),
"DT_RELSZ": reflect.ValueOf(elf.DT_RELSZ),
"DT_RPATH": reflect.ValueOf(elf.DT_RPATH),
"DT_RUNPATH": reflect.ValueOf(elf.DT_RUNPATH),
"DT_SONAME": reflect.ValueOf(elf.DT_SONAME),
"DT_SPARC_REGISTER": reflect.ValueOf(elf.DT_SPARC_REGISTER),
"DT_STRSZ": reflect.ValueOf(elf.DT_STRSZ),
"DT_STRTAB": reflect.ValueOf(elf.DT_STRTAB),
"DT_SYMBOLIC": reflect.ValueOf(elf.DT_SYMBOLIC),
"DT_SYMENT": reflect.ValueOf(elf.DT_SYMENT),
"DT_SYMINENT": reflect.ValueOf(elf.DT_SYMINENT),
"DT_SYMINFO": reflect.ValueOf(elf.DT_SYMINFO),
"DT_SYMINSZ": reflect.ValueOf(elf.DT_SYMINSZ),
"DT_SYMTAB": reflect.ValueOf(elf.DT_SYMTAB),
"DT_SYMTAB_SHNDX": reflect.ValueOf(elf.DT_SYMTAB_SHNDX),
"DT_TEXTREL": reflect.ValueOf(elf.DT_TEXTREL),
"DT_TLSDESC_GOT": reflect.ValueOf(elf.DT_TLSDESC_GOT),
"DT_TLSDESC_PLT": reflect.ValueOf(elf.DT_TLSDESC_PLT),
"DT_USED": reflect.ValueOf(elf.DT_USED),
"DT_VALRNGHI": reflect.ValueOf(elf.DT_VALRNGHI),
"DT_VALRNGLO": reflect.ValueOf(elf.DT_VALRNGLO),
"DT_VERDEF": reflect.ValueOf(elf.DT_VERDEF),
"DT_VERDEFNUM": reflect.ValueOf(elf.DT_VERDEFNUM),
"DT_VERNEED": reflect.ValueOf(elf.DT_VERNEED),
"DT_VERNEEDNUM": reflect.ValueOf(elf.DT_VERNEEDNUM),
"DT_VERSYM": reflect.ValueOf(elf.DT_VERSYM),
"EI_ABIVERSION": reflect.ValueOf(constant.MakeFromLiteral("8", token.INT, 0)),
"EI_CLASS": reflect.ValueOf(constant.MakeFromLiteral("4", token.INT, 0)),
"EI_DATA": reflect.ValueOf(constant.MakeFromLiteral("5", token.INT, 0)),
"EI_NIDENT": reflect.ValueOf(constant.MakeFromLiteral("16", token.INT, 0)),
"EI_OSABI": reflect.ValueOf(constant.MakeFromLiteral("7", token.INT, 0)),
"EI_PAD": reflect.ValueOf(constant.MakeFromLiteral("9", token.INT, 0)),
"EI_VERSION": reflect.ValueOf(constant.MakeFromLiteral("6", token.INT, 0)),
"ELFCLASS32": reflect.ValueOf(elf.ELFCLASS32),
"ELFCLASS64": reflect.ValueOf(elf.ELFCLASS64),
"ELFCLASSNONE": reflect.ValueOf(elf.ELFCLASSNONE),
"ELFDATA2LSB": reflect.ValueOf(elf.ELFDATA2LSB),
"ELFDATA2MSB": reflect.ValueOf(elf.ELFDATA2MSB),
"ELFDATANONE": reflect.ValueOf(elf.ELFDATANONE),
"ELFMAG": reflect.ValueOf(constant.MakeFromLiteral("\"\\x7fELF\"", token.STRING, 0)),
"ELFOSABI_86OPEN": reflect.ValueOf(elf.ELFOSABI_86OPEN),
"ELFOSABI_AIX": reflect.ValueOf(elf.ELFOSABI_AIX),
"ELFOSABI_ARM": reflect.ValueOf(elf.ELFOSABI_ARM),
"ELFOSABI_AROS": reflect.ValueOf(elf.ELFOSABI_AROS),
"ELFOSABI_CLOUDABI": reflect.ValueOf(elf.ELFOSABI_CLOUDABI),
"ELFOSABI_FENIXOS": reflect.ValueOf(elf.ELFOSABI_FENIXOS),
"ELFOSABI_FREEBSD": reflect.ValueOf(elf.ELFOSABI_FREEBSD),
"ELFOSABI_HPUX": reflect.ValueOf(elf.ELFOSABI_HPUX),
"ELFOSABI_HURD": reflect.ValueOf(elf.ELFOSABI_HURD),
"ELFOSABI_IRIX": reflect.ValueOf(elf.ELFOSABI_IRIX),
"ELFOSABI_LINUX": reflect.ValueOf(elf.ELFOSABI_LINUX),
"ELFOSABI_MODESTO": reflect.ValueOf(elf.ELFOSABI_MODESTO),
"ELFOSABI_NETBSD": reflect.ValueOf(elf.ELFOSABI_NETBSD),
"ELFOSABI_NONE": reflect.ValueOf(elf.ELFOSABI_NONE),
"ELFOSABI_NSK": reflect.ValueOf(elf.ELFOSABI_NSK),
"ELFOSABI_OPENBSD": reflect.ValueOf(elf.ELFOSABI_OPENBSD),
"ELFOSABI_OPENVMS": reflect.ValueOf(elf.ELFOSABI_OPENVMS),
"ELFOSABI_SOLARIS": reflect.ValueOf(elf.ELFOSABI_SOLARIS),
"ELFOSABI_STANDALONE": reflect.ValueOf(elf.ELFOSABI_STANDALONE),
"ELFOSABI_TRU64": reflect.ValueOf(elf.ELFOSABI_TRU64),
"EM_386": reflect.ValueOf(elf.EM_386),
"EM_486": reflect.ValueOf(elf.EM_486),
"EM_56800EX": reflect.ValueOf(elf.EM_56800EX),
"EM_68HC05": reflect.ValueOf(elf.EM_68HC05),
"EM_68HC08": reflect.ValueOf(elf.EM_68HC08),
"EM_68HC11": reflect.ValueOf(elf.EM_68HC11),
"EM_68HC12": reflect.ValueOf(elf.EM_68HC12),
"EM_68HC16": reflect.ValueOf(elf.EM_68HC16),
"EM_68K": reflect.ValueOf(elf.EM_68K),
"EM_78KOR": reflect.ValueOf(elf.EM_78KOR),
"EM_8051": reflect.ValueOf(elf.EM_8051),
"EM_860": reflect.ValueOf(elf.EM_860),
"EM_88K": reflect.ValueOf(elf.EM_88K),
"EM_960": reflect.ValueOf(elf.EM_960),
"EM_AARCH64": reflect.ValueOf(elf.EM_AARCH64),
"EM_ALPHA": reflect.ValueOf(elf.EM_ALPHA),
"EM_ALPHA_STD": reflect.ValueOf(elf.EM_ALPHA_STD),
"EM_ALTERA_NIOS2": reflect.ValueOf(elf.EM_ALTERA_NIOS2),
"EM_AMDGPU": reflect.ValueOf(elf.EM_AMDGPU),
"EM_ARC": reflect.ValueOf(elf.EM_ARC),
"EM_ARCA": reflect.ValueOf(elf.EM_ARCA),
"EM_ARC_COMPACT": reflect.ValueOf(elf.EM_ARC_COMPACT),
"EM_ARC_COMPACT2": reflect.ValueOf(elf.EM_ARC_COMPACT2),
"EM_ARM": reflect.ValueOf(elf.EM_ARM),
"EM_AVR": reflect.ValueOf(elf.EM_AVR),
"EM_AVR32": reflect.ValueOf(elf.EM_AVR32),
"EM_BA1": reflect.ValueOf(elf.EM_BA1),
"EM_BA2": reflect.ValueOf(elf.EM_BA2),
"EM_BLACKFIN": reflect.ValueOf(elf.EM_BLACKFIN),
"EM_BPF": reflect.ValueOf(elf.EM_BPF),
"EM_C166": reflect.ValueOf(elf.EM_C166),
"EM_CDP": reflect.ValueOf(elf.EM_CDP),
"EM_CE": reflect.ValueOf(elf.EM_CE),
"EM_CLOUDSHIELD": reflect.ValueOf(elf.EM_CLOUDSHIELD),
"EM_COGE": reflect.ValueOf(elf.EM_COGE),
"EM_COLDFIRE": reflect.ValueOf(elf.EM_COLDFIRE),
"EM_COOL": reflect.ValueOf(elf.EM_COOL),
"EM_COREA_1ST": reflect.ValueOf(elf.EM_COREA_1ST),
"EM_COREA_2ND": reflect.ValueOf(elf.EM_COREA_2ND),
"EM_CR": reflect.ValueOf(elf.EM_CR),
"EM_CR16": reflect.ValueOf(elf.EM_CR16),
"EM_CRAYNV2": reflect.ValueOf(elf.EM_CRAYNV2),
"EM_CRIS": reflect.ValueOf(elf.EM_CRIS),
"EM_CRX": reflect.ValueOf(elf.EM_CRX),
"EM_CSR_KALIMBA": reflect.ValueOf(elf.EM_CSR_KALIMBA),
"EM_CUDA": reflect.ValueOf(elf.EM_CUDA),
"EM_CYPRESS_M8C": reflect.ValueOf(elf.EM_CYPRESS_M8C),
"EM_D10V": reflect.ValueOf(elf.EM_D10V),
"EM_D30V": reflect.ValueOf(elf.EM_D30V),
"EM_DSP24": reflect.ValueOf(elf.EM_DSP24),
"EM_DSPIC30F": reflect.ValueOf(elf.EM_DSPIC30F),
"EM_DXP": reflect.ValueOf(elf.EM_DXP),
"EM_ECOG1": reflect.ValueOf(elf.EM_ECOG1),
"EM_ECOG16": reflect.ValueOf(elf.EM_ECOG16),
"EM_ECOG1X": reflect.ValueOf(elf.EM_ECOG1X),
"EM_ECOG2": reflect.ValueOf(elf.EM_ECOG2),
"EM_ETPU": reflect.ValueOf(elf.EM_ETPU),
"EM_EXCESS": reflect.ValueOf(elf.EM_EXCESS),
"EM_F2MC16": reflect.ValueOf(elf.EM_F2MC16),
"EM_FIREPATH": reflect.ValueOf(elf.EM_FIREPATH),
"EM_FR20": reflect.ValueOf(elf.EM_FR20),
"EM_FR30": reflect.ValueOf(elf.EM_FR30),
"EM_FT32": reflect.ValueOf(elf.EM_FT32),
"EM_FX66": reflect.ValueOf(elf.EM_FX66),
"EM_H8S": reflect.ValueOf(elf.EM_H8S),
"EM_H8_300": reflect.ValueOf(elf.EM_H8_300),
"EM_H8_300H": reflect.ValueOf(elf.EM_H8_300H),
"EM_H8_500": reflect.ValueOf(elf.EM_H8_500),
"EM_HUANY": reflect.ValueOf(elf.EM_HUANY),
"EM_IA_64": reflect.ValueOf(elf.EM_IA_64),
"EM_INTEL205": reflect.ValueOf(elf.EM_INTEL205),
"EM_INTEL206": reflect.ValueOf(elf.EM_INTEL206),
"EM_INTEL207": reflect.ValueOf(elf.EM_INTEL207),
"EM_INTEL208": reflect.ValueOf(elf.EM_INTEL208),
"EM_INTEL209": reflect.ValueOf(elf.EM_INTEL209),
"EM_IP2K": reflect.ValueOf(elf.EM_IP2K),
"EM_JAVELIN": reflect.ValueOf(elf.EM_JAVELIN),
"EM_K10M": reflect.ValueOf(elf.EM_K10M),
"EM_KM32": reflect.ValueOf(elf.EM_KM32),
"EM_KMX16": reflect.ValueOf(elf.EM_KMX16),
"EM_KMX32": reflect.ValueOf(elf.EM_KMX32),
"EM_KMX8": reflect.ValueOf(elf.EM_KMX8),
"EM_KVARC": reflect.ValueOf(elf.EM_KVARC),
"EM_L10M": reflect.ValueOf(elf.EM_L10M),
"EM_LANAI": reflect.ValueOf(elf.EM_LANAI),
"EM_LATTICEMICO32": reflect.ValueOf(elf.EM_LATTICEMICO32),
"EM_LOONGARCH": reflect.ValueOf(elf.EM_LOONGARCH),
"EM_M16C": reflect.ValueOf(elf.EM_M16C),
"EM_M32": reflect.ValueOf(elf.EM_M32),
"EM_M32C": reflect.ValueOf(elf.EM_M32C),
"EM_M32R": reflect.ValueOf(elf.EM_M32R),
"EM_MANIK": reflect.ValueOf(elf.EM_MANIK),
"EM_MAX": reflect.ValueOf(elf.EM_MAX),
"EM_MAXQ30": reflect.ValueOf(elf.EM_MAXQ30),
"EM_MCHP_PIC": reflect.ValueOf(elf.EM_MCHP_PIC),
"EM_MCST_ELBRUS": reflect.ValueOf(elf.EM_MCST_ELBRUS),
"EM_ME16": reflect.ValueOf(elf.EM_ME16),
"EM_METAG": reflect.ValueOf(elf.EM_METAG),
"EM_MICROBLAZE": reflect.ValueOf(elf.EM_MICROBLAZE),
"EM_MIPS": reflect.ValueOf(elf.EM_MIPS),
"EM_MIPS_RS3_LE": reflect.ValueOf(elf.EM_MIPS_RS3_LE),
"EM_MIPS_RS4_BE": reflect.ValueOf(elf.EM_MIPS_RS4_BE),
"EM_MIPS_X": reflect.ValueOf(elf.EM_MIPS_X),
"EM_MMA": reflect.ValueOf(elf.EM_MMA),
"EM_MMDSP_PLUS": reflect.ValueOf(elf.EM_MMDSP_PLUS),
"EM_MMIX": reflect.ValueOf(elf.EM_MMIX),
"EM_MN10200": reflect.ValueOf(elf.EM_MN10200),
"EM_MN10300": reflect.ValueOf(elf.EM_MN10300),
"EM_MOXIE": reflect.ValueOf(elf.EM_MOXIE),
"EM_MSP430": reflect.ValueOf(elf.EM_MSP430),
"EM_NCPU": reflect.ValueOf(elf.EM_NCPU),
"EM_NDR1": reflect.ValueOf(elf.EM_NDR1),
"EM_NDS32": reflect.ValueOf(elf.EM_NDS32),
"EM_NONE": reflect.ValueOf(elf.EM_NONE),
"EM_NORC": reflect.ValueOf(elf.EM_NORC),
"EM_NS32K": reflect.ValueOf(elf.EM_NS32K),
"EM_OPEN8": reflect.ValueOf(elf.EM_OPEN8),
"EM_OPENRISC": reflect.ValueOf(elf.EM_OPENRISC),
"EM_PARISC": reflect.ValueOf(elf.EM_PARISC),
"EM_PCP": reflect.ValueOf(elf.EM_PCP),
"EM_PDP10": reflect.ValueOf(elf.EM_PDP10),
"EM_PDP11": reflect.ValueOf(elf.EM_PDP11),
"EM_PDSP": reflect.ValueOf(elf.EM_PDSP),
"EM_PJ": reflect.ValueOf(elf.EM_PJ),
"EM_PPC": reflect.ValueOf(elf.EM_PPC),
"EM_PPC64": reflect.ValueOf(elf.EM_PPC64),
"EM_PRISM": reflect.ValueOf(elf.EM_PRISM),
"EM_QDSP6": reflect.ValueOf(elf.EM_QDSP6),
"EM_R32C": reflect.ValueOf(elf.EM_R32C),
"EM_RCE": reflect.ValueOf(elf.EM_RCE),
"EM_RH32": reflect.ValueOf(elf.EM_RH32),
"EM_RISCV": reflect.ValueOf(elf.EM_RISCV),
"EM_RL78": reflect.ValueOf(elf.EM_RL78),
"EM_RS08": reflect.ValueOf(elf.EM_RS08),
"EM_RX": reflect.ValueOf(elf.EM_RX),
"EM_S370": reflect.ValueOf(elf.EM_S370),
"EM_S390": reflect.ValueOf(elf.EM_S390),
"EM_SCORE7": reflect.ValueOf(elf.EM_SCORE7),
"EM_SEP": reflect.ValueOf(elf.EM_SEP),
"EM_SE_C17": reflect.ValueOf(elf.EM_SE_C17),
"EM_SE_C33": reflect.ValueOf(elf.EM_SE_C33),
"EM_SH": reflect.ValueOf(elf.EM_SH),
"EM_SHARC": reflect.ValueOf(elf.EM_SHARC),
"EM_SLE9X": reflect.ValueOf(elf.EM_SLE9X),
"EM_SNP1K": reflect.ValueOf(elf.EM_SNP1K),
"EM_SPARC": reflect.ValueOf(elf.EM_SPARC),
"EM_SPARC32PLUS": reflect.ValueOf(elf.EM_SPARC32PLUS),
"EM_SPARCV9": reflect.ValueOf(elf.EM_SPARCV9),
"EM_ST100": reflect.ValueOf(elf.EM_ST100),
"EM_ST19": reflect.ValueOf(elf.EM_ST19),
"EM_ST200": reflect.ValueOf(elf.EM_ST200),
"EM_ST7": reflect.ValueOf(elf.EM_ST7),
"EM_ST9PLUS": reflect.ValueOf(elf.EM_ST9PLUS),
"EM_STARCORE": reflect.ValueOf(elf.EM_STARCORE),
"EM_STM8": reflect.ValueOf(elf.EM_STM8),
"EM_STXP7X": reflect.ValueOf(elf.EM_STXP7X),
"EM_SVX": reflect.ValueOf(elf.EM_SVX),
"EM_TILE64": reflect.ValueOf(elf.EM_TILE64),
"EM_TILEGX": reflect.ValueOf(elf.EM_TILEGX),
"EM_TILEPRO": reflect.ValueOf(elf.EM_TILEPRO),
"EM_TINYJ": reflect.ValueOf(elf.EM_TINYJ),
"EM_TI_ARP32": reflect.ValueOf(elf.EM_TI_ARP32),
"EM_TI_C2000": reflect.ValueOf(elf.EM_TI_C2000),
"EM_TI_C5500": reflect.ValueOf(elf.EM_TI_C5500),
"EM_TI_C6000": reflect.ValueOf(elf.EM_TI_C6000),
"EM_TI_PRU": reflect.ValueOf(elf.EM_TI_PRU),
"EM_TMM_GPP": reflect.ValueOf(elf.EM_TMM_GPP),
"EM_TPC": reflect.ValueOf(elf.EM_TPC),
"EM_TRICORE": reflect.ValueOf(elf.EM_TRICORE),
"EM_TRIMEDIA": reflect.ValueOf(elf.EM_TRIMEDIA),
"EM_TSK3000": reflect.ValueOf(elf.EM_TSK3000),
"EM_UNICORE": reflect.ValueOf(elf.EM_UNICORE),
"EM_V800": reflect.ValueOf(elf.EM_V800),
"EM_V850": reflect.ValueOf(elf.EM_V850),
"EM_VAX": reflect.ValueOf(elf.EM_VAX),
"EM_VIDEOCORE": reflect.ValueOf(elf.EM_VIDEOCORE),
"EM_VIDEOCORE3": reflect.ValueOf(elf.EM_VIDEOCORE3),
"EM_VIDEOCORE5": reflect.ValueOf(elf.EM_VIDEOCORE5),
"EM_VISIUM": reflect.ValueOf(elf.EM_VISIUM),
"EM_VPP500": reflect.ValueOf(elf.EM_VPP500),
"EM_X86_64": reflect.ValueOf(elf.EM_X86_64),
"EM_XCORE": reflect.ValueOf(elf.EM_XCORE),
"EM_XGATE": reflect.ValueOf(elf.EM_XGATE),
"EM_XIMO16": reflect.ValueOf(elf.EM_XIMO16),
"EM_XTENSA": reflect.ValueOf(elf.EM_XTENSA),
"EM_Z80": reflect.ValueOf(elf.EM_Z80),
"EM_ZSP": reflect.ValueOf(elf.EM_ZSP),
"ET_CORE": reflect.ValueOf(elf.ET_CORE),
"ET_DYN": reflect.ValueOf(elf.ET_DYN),
"ET_EXEC": reflect.ValueOf(elf.ET_EXEC),
"ET_HIOS": reflect.ValueOf(elf.ET_HIOS),
"ET_HIPROC": reflect.ValueOf(elf.ET_HIPROC),
"ET_LOOS": reflect.ValueOf(elf.ET_LOOS),
"ET_LOPROC": reflect.ValueOf(elf.ET_LOPROC),
"ET_NONE": reflect.ValueOf(elf.ET_NONE),
"ET_REL": reflect.ValueOf(elf.ET_REL),
"EV_CURRENT": reflect.ValueOf(elf.EV_CURRENT),
"EV_NONE": reflect.ValueOf(elf.EV_NONE),
"ErrNoSymbols": reflect.ValueOf(&elf.ErrNoSymbols).Elem(),
"NT_FPREGSET": reflect.ValueOf(elf.NT_FPREGSET),
"NT_PRPSINFO": reflect.ValueOf(elf.NT_PRPSINFO),
"NT_PRSTATUS": reflect.ValueOf(elf.NT_PRSTATUS),
"NewFile": reflect.ValueOf(elf.NewFile),
"Open": reflect.ValueOf(elf.Open),
"PF_MASKOS": reflect.ValueOf(elf.PF_MASKOS),
"PF_MASKPROC": reflect.ValueOf(elf.PF_MASKPROC),
"PF_R": reflect.ValueOf(elf.PF_R),
"PF_W": reflect.ValueOf(elf.PF_W),
"PF_X": reflect.ValueOf(elf.PF_X),
"PT_AARCH64_ARCHEXT": reflect.ValueOf(elf.PT_AARCH64_ARCHEXT),
"PT_AARCH64_UNWIND": reflect.ValueOf(elf.PT_AARCH64_UNWIND),
"PT_ARM_ARCHEXT": reflect.ValueOf(elf.PT_ARM_ARCHEXT),
"PT_ARM_EXIDX": reflect.ValueOf(elf.PT_ARM_EXIDX),
"PT_DYNAMIC": reflect.ValueOf(elf.PT_DYNAMIC),
"PT_GNU_EH_FRAME": reflect.ValueOf(elf.PT_GNU_EH_FRAME),
"PT_GNU_MBIND_HI": reflect.ValueOf(elf.PT_GNU_MBIND_HI),
"PT_GNU_MBIND_LO": reflect.ValueOf(elf.PT_GNU_MBIND_LO),
"PT_GNU_PROPERTY": reflect.ValueOf(elf.PT_GNU_PROPERTY),
"PT_GNU_RELRO": reflect.ValueOf(elf.PT_GNU_RELRO),
"PT_GNU_STACK": reflect.ValueOf(elf.PT_GNU_STACK),
"PT_HIOS": reflect.ValueOf(elf.PT_HIOS),
"PT_HIPROC": reflect.ValueOf(elf.PT_HIPROC),
"PT_INTERP": reflect.ValueOf(elf.PT_INTERP),
"PT_LOAD": reflect.ValueOf(elf.PT_LOAD),
"PT_LOOS": reflect.ValueOf(elf.PT_LOOS),
"PT_LOPROC": reflect.ValueOf(elf.PT_LOPROC),
"PT_MIPS_ABIFLAGS": reflect.ValueOf(elf.PT_MIPS_ABIFLAGS),
"PT_MIPS_OPTIONS": reflect.ValueOf(elf.PT_MIPS_OPTIONS),
"PT_MIPS_REGINFO": reflect.ValueOf(elf.PT_MIPS_REGINFO),
"PT_MIPS_RTPROC": reflect.ValueOf(elf.PT_MIPS_RTPROC),
"PT_NOTE": reflect.ValueOf(elf.PT_NOTE),
"PT_NULL": reflect.ValueOf(elf.PT_NULL),
"PT_OPENBSD_BOOTDATA": reflect.ValueOf(elf.PT_OPENBSD_BOOTDATA),
"PT_OPENBSD_RANDOMIZE": reflect.ValueOf(elf.PT_OPENBSD_RANDOMIZE),
"PT_OPENBSD_WXNEEDED": reflect.ValueOf(elf.PT_OPENBSD_WXNEEDED),
"PT_PAX_FLAGS": reflect.ValueOf(elf.PT_PAX_FLAGS),
"PT_PHDR": reflect.ValueOf(elf.PT_PHDR),
"PT_S390_PGSTE": reflect.ValueOf(elf.PT_S390_PGSTE),
"PT_SHLIB": reflect.ValueOf(elf.PT_SHLIB),
"PT_SUNWSTACK": reflect.ValueOf(elf.PT_SUNWSTACK),
"PT_SUNW_EH_FRAME": reflect.ValueOf(elf.PT_SUNW_EH_FRAME),
"PT_TLS": reflect.ValueOf(elf.PT_TLS),
"R_386_16": reflect.ValueOf(elf.R_386_16),
"R_386_32": reflect.ValueOf(elf.R_386_32),
"R_386_32PLT": reflect.ValueOf(elf.R_386_32PLT),
"R_386_8": reflect.ValueOf(elf.R_386_8),
"R_386_COPY": reflect.ValueOf(elf.R_386_COPY),
"R_386_GLOB_DAT": reflect.ValueOf(elf.R_386_GLOB_DAT),
"R_386_GOT32": reflect.ValueOf(elf.R_386_GOT32),
"R_386_GOT32X": reflect.ValueOf(elf.R_386_GOT32X),
"R_386_GOTOFF": reflect.ValueOf(elf.R_386_GOTOFF),
"R_386_GOTPC": reflect.ValueOf(elf.R_386_GOTPC),
"R_386_IRELATIVE": reflect.ValueOf(elf.R_386_IRELATIVE),
"R_386_JMP_SLOT": reflect.ValueOf(elf.R_386_JMP_SLOT),
"R_386_NONE": reflect.ValueOf(elf.R_386_NONE),
"R_386_PC16": reflect.ValueOf(elf.R_386_PC16),
"R_386_PC32": reflect.ValueOf(elf.R_386_PC32),
"R_386_PC8": reflect.ValueOf(elf.R_386_PC8),
"R_386_PLT32": reflect.ValueOf(elf.R_386_PLT32),
"R_386_RELATIVE": reflect.ValueOf(elf.R_386_RELATIVE),
"R_386_SIZE32": reflect.ValueOf(elf.R_386_SIZE32),
"R_386_TLS_DESC": reflect.ValueOf(elf.R_386_TLS_DESC),
"R_386_TLS_DESC_CALL": reflect.ValueOf(elf.R_386_TLS_DESC_CALL),
"R_386_TLS_DTPMOD32": reflect.ValueOf(elf.R_386_TLS_DTPMOD32),
"R_386_TLS_DTPOFF32": reflect.ValueOf(elf.R_386_TLS_DTPOFF32),
"R_386_TLS_GD": reflect.ValueOf(elf.R_386_TLS_GD),
"R_386_TLS_GD_32": reflect.ValueOf(elf.R_386_TLS_GD_32),
"R_386_TLS_GD_CALL": reflect.ValueOf(elf.R_386_TLS_GD_CALL),
"R_386_TLS_GD_POP": reflect.ValueOf(elf.R_386_TLS_GD_POP),
"R_386_TLS_GD_PUSH": reflect.ValueOf(elf.R_386_TLS_GD_PUSH),
"R_386_TLS_GOTDESC": reflect.ValueOf(elf.R_386_TLS_GOTDESC),
"R_386_TLS_GOTIE": reflect.ValueOf(elf.R_386_TLS_GOTIE),
"R_386_TLS_IE": reflect.ValueOf(elf.R_386_TLS_IE),
"R_386_TLS_IE_32": reflect.ValueOf(elf.R_386_TLS_IE_32),
"R_386_TLS_LDM": reflect.ValueOf(elf.R_386_TLS_LDM),
"R_386_TLS_LDM_32": reflect.ValueOf(elf.R_386_TLS_LDM_32),
"R_386_TLS_LDM_CALL": reflect.ValueOf(elf.R_386_TLS_LDM_CALL),
"R_386_TLS_LDM_POP": reflect.ValueOf(elf.R_386_TLS_LDM_POP),
"R_386_TLS_LDM_PUSH": reflect.ValueOf(elf.R_386_TLS_LDM_PUSH),
"R_386_TLS_LDO_32": reflect.ValueOf(elf.R_386_TLS_LDO_32),
"R_386_TLS_LE": reflect.ValueOf(elf.R_386_TLS_LE),
"R_386_TLS_LE_32": reflect.ValueOf(elf.R_386_TLS_LE_32),
"R_386_TLS_TPOFF": reflect.ValueOf(elf.R_386_TLS_TPOFF),
"R_386_TLS_TPOFF32": reflect.ValueOf(elf.R_386_TLS_TPOFF32),
"R_390_12": reflect.ValueOf(elf.R_390_12),
"R_390_16": reflect.ValueOf(elf.R_390_16),
"R_390_20": reflect.ValueOf(elf.R_390_20),
"R_390_32": reflect.ValueOf(elf.R_390_32),
"R_390_64": reflect.ValueOf(elf.R_390_64),
"R_390_8": reflect.ValueOf(elf.R_390_8),
"R_390_COPY": reflect.ValueOf(elf.R_390_COPY),
"R_390_GLOB_DAT": reflect.ValueOf(elf.R_390_GLOB_DAT),
"R_390_GOT12": reflect.ValueOf(elf.R_390_GOT12),
"R_390_GOT16": reflect.ValueOf(elf.R_390_GOT16),
"R_390_GOT20": reflect.ValueOf(elf.R_390_GOT20),
"R_390_GOT32": reflect.ValueOf(elf.R_390_GOT32),
"R_390_GOT64": reflect.ValueOf(elf.R_390_GOT64),
"R_390_GOTENT": reflect.ValueOf(elf.R_390_GOTENT),
"R_390_GOTOFF": reflect.ValueOf(elf.R_390_GOTOFF),
"R_390_GOTOFF16": reflect.ValueOf(elf.R_390_GOTOFF16),
"R_390_GOTOFF64": reflect.ValueOf(elf.R_390_GOTOFF64),
"R_390_GOTPC": reflect.ValueOf(elf.R_390_GOTPC),
"R_390_GOTPCDBL": reflect.ValueOf(elf.R_390_GOTPCDBL),
"R_390_GOTPLT12": reflect.ValueOf(elf.R_390_GOTPLT12),
"R_390_GOTPLT16": reflect.ValueOf(elf.R_390_GOTPLT16),
"R_390_GOTPLT20": reflect.ValueOf(elf.R_390_GOTPLT20),
"R_390_GOTPLT32": reflect.ValueOf(elf.R_390_GOTPLT32),
"R_390_GOTPLT64": reflect.ValueOf(elf.R_390_GOTPLT64),
"R_390_GOTPLTENT": reflect.ValueOf(elf.R_390_GOTPLTENT),
"R_390_GOTPLTOFF16": reflect.ValueOf(elf.R_390_GOTPLTOFF16),
"R_390_GOTPLTOFF32": reflect.ValueOf(elf.R_390_GOTPLTOFF32),
"R_390_GOTPLTOFF64": reflect.ValueOf(elf.R_390_GOTPLTOFF64),
"R_390_JMP_SLOT": reflect.ValueOf(elf.R_390_JMP_SLOT),
"R_390_NONE": reflect.ValueOf(elf.R_390_NONE),
"R_390_PC16": reflect.ValueOf(elf.R_390_PC16),
"R_390_PC16DBL": reflect.ValueOf(elf.R_390_PC16DBL),
"R_390_PC32": reflect.ValueOf(elf.R_390_PC32),
"R_390_PC32DBL": reflect.ValueOf(elf.R_390_PC32DBL),
"R_390_PC64": reflect.ValueOf(elf.R_390_PC64),
"R_390_PLT16DBL": reflect.ValueOf(elf.R_390_PLT16DBL),
"R_390_PLT32": reflect.ValueOf(elf.R_390_PLT32),
"R_390_PLT32DBL": reflect.ValueOf(elf.R_390_PLT32DBL),
"R_390_PLT64": reflect.ValueOf(elf.R_390_PLT64),
"R_390_RELATIVE": reflect.ValueOf(elf.R_390_RELATIVE),
"R_390_TLS_DTPMOD": reflect.ValueOf(elf.R_390_TLS_DTPMOD),
"R_390_TLS_DTPOFF": reflect.ValueOf(elf.R_390_TLS_DTPOFF),
"R_390_TLS_GD32": reflect.ValueOf(elf.R_390_TLS_GD32),
"R_390_TLS_GD64": reflect.ValueOf(elf.R_390_TLS_GD64),
"R_390_TLS_GDCALL": reflect.ValueOf(elf.R_390_TLS_GDCALL),
"R_390_TLS_GOTIE12": reflect.ValueOf(elf.R_390_TLS_GOTIE12),
"R_390_TLS_GOTIE20": reflect.ValueOf(elf.R_390_TLS_GOTIE20),
"R_390_TLS_GOTIE32": reflect.ValueOf(elf.R_390_TLS_GOTIE32),
"R_390_TLS_GOTIE64": reflect.ValueOf(elf.R_390_TLS_GOTIE64),
"R_390_TLS_IE32": reflect.ValueOf(elf.R_390_TLS_IE32),
"R_390_TLS_IE64": reflect.ValueOf(elf.R_390_TLS_IE64),
"R_390_TLS_IEENT": reflect.ValueOf(elf.R_390_TLS_IEENT),
"R_390_TLS_LDCALL": reflect.ValueOf(elf.R_390_TLS_LDCALL),
"R_390_TLS_LDM32": reflect.ValueOf(elf.R_390_TLS_LDM32),
"R_390_TLS_LDM64": reflect.ValueOf(elf.R_390_TLS_LDM64),
"R_390_TLS_LDO32": reflect.ValueOf(elf.R_390_TLS_LDO32),
"R_390_TLS_LDO64": reflect.ValueOf(elf.R_390_TLS_LDO64),
"R_390_TLS_LE32": reflect.ValueOf(elf.R_390_TLS_LE32),
"R_390_TLS_LE64": reflect.ValueOf(elf.R_390_TLS_LE64),
"R_390_TLS_LOAD": reflect.ValueOf(elf.R_390_TLS_LOAD),
"R_390_TLS_TPOFF": reflect.ValueOf(elf.R_390_TLS_TPOFF),
"R_AARCH64_ABS16": reflect.ValueOf(elf.R_AARCH64_ABS16),
"R_AARCH64_ABS32": reflect.ValueOf(elf.R_AARCH64_ABS32),
"R_AARCH64_ABS64": reflect.ValueOf(elf.R_AARCH64_ABS64),
"R_AARCH64_ADD_ABS_LO12_NC": reflect.ValueOf(elf.R_AARCH64_ADD_ABS_LO12_NC),
"R_AARCH64_ADR_GOT_PAGE": reflect.ValueOf(elf.R_AARCH64_ADR_GOT_PAGE),
"R_AARCH64_ADR_PREL_LO21": reflect.ValueOf(elf.R_AARCH64_ADR_PREL_LO21),
"R_AARCH64_ADR_PREL_PG_HI21": reflect.ValueOf(elf.R_AARCH64_ADR_PREL_PG_HI21),
"R_AARCH64_ADR_PREL_PG_HI21_NC": reflect.ValueOf(elf.R_AARCH64_ADR_PREL_PG_HI21_NC),
"R_AARCH64_CALL26": reflect.ValueOf(elf.R_AARCH64_CALL26),
"R_AARCH64_CONDBR19": reflect.ValueOf(elf.R_AARCH64_CONDBR19),
"R_AARCH64_COPY": reflect.ValueOf(elf.R_AARCH64_COPY),
"R_AARCH64_GLOB_DAT": reflect.ValueOf(elf.R_AARCH64_GLOB_DAT),
"R_AARCH64_GOT_LD_PREL19": reflect.ValueOf(elf.R_AARCH64_GOT_LD_PREL19),
"R_AARCH64_IRELATIVE": reflect.ValueOf(elf.R_AARCH64_IRELATIVE),
"R_AARCH64_JUMP26": reflect.ValueOf(elf.R_AARCH64_JUMP26),
"R_AARCH64_JUMP_SLOT": reflect.ValueOf(elf.R_AARCH64_JUMP_SLOT),
"R_AARCH64_LD64_GOTOFF_LO15": reflect.ValueOf(elf.R_AARCH64_LD64_GOTOFF_LO15),
"R_AARCH64_LD64_GOTPAGE_LO15": reflect.ValueOf(elf.R_AARCH64_LD64_GOTPAGE_LO15),
"R_AARCH64_LD64_GOT_LO12_NC": reflect.ValueOf(elf.R_AARCH64_LD64_GOT_LO12_NC),
"R_AARCH64_LDST128_ABS_LO12_NC": reflect.ValueOf(elf.R_AARCH64_LDST128_ABS_LO12_NC),
"R_AARCH64_LDST16_ABS_LO12_NC": reflect.ValueOf(elf.R_AARCH64_LDST16_ABS_LO12_NC),
"R_AARCH64_LDST32_ABS_LO12_NC": reflect.ValueOf(elf.R_AARCH64_LDST32_ABS_LO12_NC),
"R_AARCH64_LDST64_ABS_LO12_NC": reflect.ValueOf(elf.R_AARCH64_LDST64_ABS_LO12_NC),
"R_AARCH64_LDST8_ABS_LO12_NC": reflect.ValueOf(elf.R_AARCH64_LDST8_ABS_LO12_NC),
"R_AARCH64_LD_PREL_LO19": reflect.ValueOf(elf.R_AARCH64_LD_PREL_LO19),
"R_AARCH64_MOVW_SABS_G0": reflect.ValueOf(elf.R_AARCH64_MOVW_SABS_G0),
"R_AARCH64_MOVW_SABS_G1": reflect.ValueOf(elf.R_AARCH64_MOVW_SABS_G1),
"R_AARCH64_MOVW_SABS_G2": reflect.ValueOf(elf.R_AARCH64_MOVW_SABS_G2),
"R_AARCH64_MOVW_UABS_G0": reflect.ValueOf(elf.R_AARCH64_MOVW_UABS_G0),
"R_AARCH64_MOVW_UABS_G0_NC": reflect.ValueOf(elf.R_AARCH64_MOVW_UABS_G0_NC),
"R_AARCH64_MOVW_UABS_G1": reflect.ValueOf(elf.R_AARCH64_MOVW_UABS_G1),
"R_AARCH64_MOVW_UABS_G1_NC": reflect.ValueOf(elf.R_AARCH64_MOVW_UABS_G1_NC),
"R_AARCH64_MOVW_UABS_G2": reflect.ValueOf(elf.R_AARCH64_MOVW_UABS_G2),
"R_AARCH64_MOVW_UABS_G2_NC": reflect.ValueOf(elf.R_AARCH64_MOVW_UABS_G2_NC),
"R_AARCH64_MOVW_UABS_G3": reflect.ValueOf(elf.R_AARCH64_MOVW_UABS_G3),
"R_AARCH64_NONE": reflect.ValueOf(elf.R_AARCH64_NONE),
"R_AARCH64_NULL": reflect.ValueOf(elf.R_AARCH64_NULL),
"R_AARCH64_P32_ABS16": reflect.ValueOf(elf.R_AARCH64_P32_ABS16),
"R_AARCH64_P32_ABS32": reflect.ValueOf(elf.R_AARCH64_P32_ABS32),
"R_AARCH64_P32_ADD_ABS_LO12_NC": reflect.ValueOf(elf.R_AARCH64_P32_ADD_ABS_LO12_NC),
"R_AARCH64_P32_ADR_GOT_PAGE": reflect.ValueOf(elf.R_AARCH64_P32_ADR_GOT_PAGE),
"R_AARCH64_P32_ADR_PREL_LO21": reflect.ValueOf(elf.R_AARCH64_P32_ADR_PREL_LO21),
"R_AARCH64_P32_ADR_PREL_PG_HI21": reflect.ValueOf(elf.R_AARCH64_P32_ADR_PREL_PG_HI21),
"R_AARCH64_P32_CALL26": reflect.ValueOf(elf.R_AARCH64_P32_CALL26),
"R_AARCH64_P32_CONDBR19": reflect.ValueOf(elf.R_AARCH64_P32_CONDBR19),
"R_AARCH64_P32_COPY": reflect.ValueOf(elf.R_AARCH64_P32_COPY),
"R_AARCH64_P32_GLOB_DAT": reflect.ValueOf(elf.R_AARCH64_P32_GLOB_DAT),
"R_AARCH64_P32_GOT_LD_PREL19": reflect.ValueOf(elf.R_AARCH64_P32_GOT_LD_PREL19),
"R_AARCH64_P32_IRELATIVE": reflect.ValueOf(elf.R_AARCH64_P32_IRELATIVE),
"R_AARCH64_P32_JUMP26": reflect.ValueOf(elf.R_AARCH64_P32_JUMP26),
"R_AARCH64_P32_JUMP_SLOT": reflect.ValueOf(elf.R_AARCH64_P32_JUMP_SLOT),
"R_AARCH64_P32_LD32_GOT_LO12_NC": reflect.ValueOf(elf.R_AARCH64_P32_LD32_GOT_LO12_NC),
"R_AARCH64_P32_LDST128_ABS_LO12_NC": reflect.ValueOf(elf.R_AARCH64_P32_LDST128_ABS_LO12_NC),
"R_AARCH64_P32_LDST16_ABS_LO12_NC": reflect.ValueOf(elf.R_AARCH64_P32_LDST16_ABS_LO12_NC),
"R_AARCH64_P32_LDST32_ABS_LO12_NC": reflect.ValueOf(elf.R_AARCH64_P32_LDST32_ABS_LO12_NC),
"R_AARCH64_P32_LDST64_ABS_LO12_NC": reflect.ValueOf(elf.R_AARCH64_P32_LDST64_ABS_LO12_NC),
"R_AARCH64_P32_LDST8_ABS_LO12_NC": reflect.ValueOf(elf.R_AARCH64_P32_LDST8_ABS_LO12_NC),
"R_AARCH64_P32_LD_PREL_LO19": reflect.ValueOf(elf.R_AARCH64_P32_LD_PREL_LO19),
"R_AARCH64_P32_MOVW_SABS_G0": reflect.ValueOf(elf.R_AARCH64_P32_MOVW_SABS_G0),
"R_AARCH64_P32_MOVW_UABS_G0": reflect.ValueOf(elf.R_AARCH64_P32_MOVW_UABS_G0),
"R_AARCH64_P32_MOVW_UABS_G0_NC": reflect.ValueOf(elf.R_AARCH64_P32_MOVW_UABS_G0_NC),
"R_AARCH64_P32_MOVW_UABS_G1": reflect.ValueOf(elf.R_AARCH64_P32_MOVW_UABS_G1),
"R_AARCH64_P32_PREL16": reflect.ValueOf(elf.R_AARCH64_P32_PREL16),
"R_AARCH64_P32_PREL32": reflect.ValueOf(elf.R_AARCH64_P32_PREL32),
"R_AARCH64_P32_RELATIVE": reflect.ValueOf(elf.R_AARCH64_P32_RELATIVE),
"R_AARCH64_P32_TLSDESC": reflect.ValueOf(elf.R_AARCH64_P32_TLSDESC),
"R_AARCH64_P32_TLSDESC_ADD_LO12_NC": reflect.ValueOf(elf.R_AARCH64_P32_TLSDESC_ADD_LO12_NC),
"R_AARCH64_P32_TLSDESC_ADR_PAGE21": reflect.ValueOf(elf.R_AARCH64_P32_TLSDESC_ADR_PAGE21),
"R_AARCH64_P32_TLSDESC_ADR_PREL21": reflect.ValueOf(elf.R_AARCH64_P32_TLSDESC_ADR_PREL21),
"R_AARCH64_P32_TLSDESC_CALL": reflect.ValueOf(elf.R_AARCH64_P32_TLSDESC_CALL),
"R_AARCH64_P32_TLSDESC_LD32_LO12_NC": reflect.ValueOf(elf.R_AARCH64_P32_TLSDESC_LD32_LO12_NC),
"R_AARCH64_P32_TLSDESC_LD_PREL19": reflect.ValueOf(elf.R_AARCH64_P32_TLSDESC_LD_PREL19),
"R_AARCH64_P32_TLSGD_ADD_LO12_NC": reflect.ValueOf(elf.R_AARCH64_P32_TLSGD_ADD_LO12_NC),
"R_AARCH64_P32_TLSGD_ADR_PAGE21": reflect.ValueOf(elf.R_AARCH64_P32_TLSGD_ADR_PAGE21),
"R_AARCH64_P32_TLSIE_ADR_GOTTPREL_PAGE21": reflect.ValueOf(elf.R_AARCH64_P32_TLSIE_ADR_GOTTPREL_PAGE21),
"R_AARCH64_P32_TLSIE_LD32_GOTTPREL_LO12_NC": reflect.ValueOf(elf.R_AARCH64_P32_TLSIE_LD32_GOTTPREL_LO12_NC),
"R_AARCH64_P32_TLSIE_LD_GOTTPREL_PREL19": reflect.ValueOf(elf.R_AARCH64_P32_TLSIE_LD_GOTTPREL_PREL19),
"R_AARCH64_P32_TLSLE_ADD_TPREL_HI12": reflect.ValueOf(elf.R_AARCH64_P32_TLSLE_ADD_TPREL_HI12),
"R_AARCH64_P32_TLSLE_ADD_TPREL_LO12": reflect.ValueOf(elf.R_AARCH64_P32_TLSLE_ADD_TPREL_LO12),
"R_AARCH64_P32_TLSLE_ADD_TPREL_LO12_NC": reflect.ValueOf(elf.R_AARCH64_P32_TLSLE_ADD_TPREL_LO12_NC),
"R_AARCH64_P32_TLSLE_MOVW_TPREL_G0": reflect.ValueOf(elf.R_AARCH64_P32_TLSLE_MOVW_TPREL_G0),
"R_AARCH64_P32_TLSLE_MOVW_TPREL_G0_NC": reflect.ValueOf(elf.R_AARCH64_P32_TLSLE_MOVW_TPREL_G0_NC),
"R_AARCH64_P32_TLSLE_MOVW_TPREL_G1": reflect.ValueOf(elf.R_AARCH64_P32_TLSLE_MOVW_TPREL_G1),
"R_AARCH64_P32_TLS_DTPMOD": reflect.ValueOf(elf.R_AARCH64_P32_TLS_DTPMOD),
"R_AARCH64_P32_TLS_DTPREL": reflect.ValueOf(elf.R_AARCH64_P32_TLS_DTPREL),
"R_AARCH64_P32_TLS_TPREL": reflect.ValueOf(elf.R_AARCH64_P32_TLS_TPREL),
"R_AARCH64_P32_TSTBR14": reflect.ValueOf(elf.R_AARCH64_P32_TSTBR14),
"R_AARCH64_PREL16": reflect.ValueOf(elf.R_AARCH64_PREL16),
"R_AARCH64_PREL32": reflect.ValueOf(elf.R_AARCH64_PREL32),
"R_AARCH64_PREL64": reflect.ValueOf(elf.R_AARCH64_PREL64),
"R_AARCH64_RELATIVE": reflect.ValueOf(elf.R_AARCH64_RELATIVE),
"R_AARCH64_TLSDESC": reflect.ValueOf(elf.R_AARCH64_TLSDESC),
"R_AARCH64_TLSDESC_ADD": reflect.ValueOf(elf.R_AARCH64_TLSDESC_ADD),
"R_AARCH64_TLSDESC_ADD_LO12_NC": reflect.ValueOf(elf.R_AARCH64_TLSDESC_ADD_LO12_NC),
"R_AARCH64_TLSDESC_ADR_PAGE21": reflect.ValueOf(elf.R_AARCH64_TLSDESC_ADR_PAGE21),
"R_AARCH64_TLSDESC_ADR_PREL21": reflect.ValueOf(elf.R_AARCH64_TLSDESC_ADR_PREL21),
"R_AARCH64_TLSDESC_CALL": reflect.ValueOf(elf.R_AARCH64_TLSDESC_CALL),
"R_AARCH64_TLSDESC_LD64_LO12_NC": reflect.ValueOf(elf.R_AARCH64_TLSDESC_LD64_LO12_NC),
"R_AARCH64_TLSDESC_LDR": reflect.ValueOf(elf.R_AARCH64_TLSDESC_LDR),
"R_AARCH64_TLSDESC_LD_PREL19": reflect.ValueOf(elf.R_AARCH64_TLSDESC_LD_PREL19),
"R_AARCH64_TLSDESC_OFF_G0_NC": reflect.ValueOf(elf.R_AARCH64_TLSDESC_OFF_G0_NC),
"R_AARCH64_TLSDESC_OFF_G1": reflect.ValueOf(elf.R_AARCH64_TLSDESC_OFF_G1),
"R_AARCH64_TLSGD_ADD_LO12_NC": reflect.ValueOf(elf.R_AARCH64_TLSGD_ADD_LO12_NC),
"R_AARCH64_TLSGD_ADR_PAGE21": reflect.ValueOf(elf.R_AARCH64_TLSGD_ADR_PAGE21),
"R_AARCH64_TLSGD_ADR_PREL21": reflect.ValueOf(elf.R_AARCH64_TLSGD_ADR_PREL21),
"R_AARCH64_TLSGD_MOVW_G0_NC": reflect.ValueOf(elf.R_AARCH64_TLSGD_MOVW_G0_NC),
"R_AARCH64_TLSGD_MOVW_G1": reflect.ValueOf(elf.R_AARCH64_TLSGD_MOVW_G1),
"R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21": reflect.ValueOf(elf.R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21),
"R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC": reflect.ValueOf(elf.R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC),
"R_AARCH64_TLSIE_LD_GOTTPREL_PREL19": reflect.ValueOf(elf.R_AARCH64_TLSIE_LD_GOTTPREL_PREL19),
"R_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC": reflect.ValueOf(elf.R_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC),
"R_AARCH64_TLSIE_MOVW_GOTTPREL_G1": reflect.ValueOf(elf.R_AARCH64_TLSIE_MOVW_GOTTPREL_G1),
"R_AARCH64_TLSLD_ADR_PAGE21": reflect.ValueOf(elf.R_AARCH64_TLSLD_ADR_PAGE21),
"R_AARCH64_TLSLD_ADR_PREL21": reflect.ValueOf(elf.R_AARCH64_TLSLD_ADR_PREL21),
"R_AARCH64_TLSLD_LDST128_DTPREL_LO12": reflect.ValueOf(elf.R_AARCH64_TLSLD_LDST128_DTPREL_LO12),
"R_AARCH64_TLSLD_LDST128_DTPREL_LO12_NC": reflect.ValueOf(elf.R_AARCH64_TLSLD_LDST128_DTPREL_LO12_NC),
"R_AARCH64_TLSLE_ADD_TPREL_HI12": reflect.ValueOf(elf.R_AARCH64_TLSLE_ADD_TPREL_HI12),
"R_AARCH64_TLSLE_ADD_TPREL_LO12": reflect.ValueOf(elf.R_AARCH64_TLSLE_ADD_TPREL_LO12),
"R_AARCH64_TLSLE_ADD_TPREL_LO12_NC": reflect.ValueOf(elf.R_AARCH64_TLSLE_ADD_TPREL_LO12_NC),
"R_AARCH64_TLSLE_LDST128_TPREL_LO12": reflect.ValueOf(elf.R_AARCH64_TLSLE_LDST128_TPREL_LO12),
"R_AARCH64_TLSLE_LDST128_TPREL_LO12_NC": reflect.ValueOf(elf.R_AARCH64_TLSLE_LDST128_TPREL_LO12_NC),
"R_AARCH64_TLSLE_MOVW_TPREL_G0": reflect.ValueOf(elf.R_AARCH64_TLSLE_MOVW_TPREL_G0),
"R_AARCH64_TLSLE_MOVW_TPREL_G0_NC": reflect.ValueOf(elf.R_AARCH64_TLSLE_MOVW_TPREL_G0_NC),
"R_AARCH64_TLSLE_MOVW_TPREL_G1": reflect.ValueOf(elf.R_AARCH64_TLSLE_MOVW_TPREL_G1),
"R_AARCH64_TLSLE_MOVW_TPREL_G1_NC": reflect.ValueOf(elf.R_AARCH64_TLSLE_MOVW_TPREL_G1_NC),
"R_AARCH64_TLSLE_MOVW_TPREL_G2": reflect.ValueOf(elf.R_AARCH64_TLSLE_MOVW_TPREL_G2),
"R_AARCH64_TLS_DTPMOD64": reflect.ValueOf(elf.R_AARCH64_TLS_DTPMOD64),
"R_AARCH64_TLS_DTPREL64": reflect.ValueOf(elf.R_AARCH64_TLS_DTPREL64),
"R_AARCH64_TLS_TPREL64": reflect.ValueOf(elf.R_AARCH64_TLS_TPREL64),
"R_AARCH64_TSTBR14": reflect.ValueOf(elf.R_AARCH64_TSTBR14),
"R_ALPHA_BRADDR": reflect.ValueOf(elf.R_ALPHA_BRADDR),
"R_ALPHA_COPY": reflect.ValueOf(elf.R_ALPHA_COPY),
"R_ALPHA_GLOB_DAT": reflect.ValueOf(elf.R_ALPHA_GLOB_DAT),
"R_ALPHA_GPDISP": reflect.ValueOf(elf.R_ALPHA_GPDISP),
"R_ALPHA_GPREL32": reflect.ValueOf(elf.R_ALPHA_GPREL32),
"R_ALPHA_GPRELHIGH": reflect.ValueOf(elf.R_ALPHA_GPRELHIGH),
"R_ALPHA_GPRELLOW": reflect.ValueOf(elf.R_ALPHA_GPRELLOW),
"R_ALPHA_GPVALUE": reflect.ValueOf(elf.R_ALPHA_GPVALUE),
"R_ALPHA_HINT": reflect.ValueOf(elf.R_ALPHA_HINT),
"R_ALPHA_IMMED_BR_HI32": reflect.ValueOf(elf.R_ALPHA_IMMED_BR_HI32),
"R_ALPHA_IMMED_GP_16": reflect.ValueOf(elf.R_ALPHA_IMMED_GP_16),
"R_ALPHA_IMMED_GP_HI32": reflect.ValueOf(elf.R_ALPHA_IMMED_GP_HI32),
"R_ALPHA_IMMED_LO32": reflect.ValueOf(elf.R_ALPHA_IMMED_LO32),
"R_ALPHA_IMMED_SCN_HI32": reflect.ValueOf(elf.R_ALPHA_IMMED_SCN_HI32),
"R_ALPHA_JMP_SLOT": reflect.ValueOf(elf.R_ALPHA_JMP_SLOT),
"R_ALPHA_LITERAL": reflect.ValueOf(elf.R_ALPHA_LITERAL),
"R_ALPHA_LITUSE": reflect.ValueOf(elf.R_ALPHA_LITUSE),
"R_ALPHA_NONE": reflect.ValueOf(elf.R_ALPHA_NONE),
"R_ALPHA_OP_PRSHIFT": reflect.ValueOf(elf.R_ALPHA_OP_PRSHIFT),
"R_ALPHA_OP_PSUB": reflect.ValueOf(elf.R_ALPHA_OP_PSUB),
"R_ALPHA_OP_PUSH": reflect.ValueOf(elf.R_ALPHA_OP_PUSH),
"R_ALPHA_OP_STORE": reflect.ValueOf(elf.R_ALPHA_OP_STORE),
"R_ALPHA_REFLONG": reflect.ValueOf(elf.R_ALPHA_REFLONG),
"R_ALPHA_REFQUAD": reflect.ValueOf(elf.R_ALPHA_REFQUAD),
"R_ALPHA_RELATIVE": reflect.ValueOf(elf.R_ALPHA_RELATIVE),
"R_ALPHA_SREL16": reflect.ValueOf(elf.R_ALPHA_SREL16),
"R_ALPHA_SREL32": reflect.ValueOf(elf.R_ALPHA_SREL32),
"R_ALPHA_SREL64": reflect.ValueOf(elf.R_ALPHA_SREL64),
"R_ARM_ABS12": reflect.ValueOf(elf.R_ARM_ABS12),
"R_ARM_ABS16": reflect.ValueOf(elf.R_ARM_ABS16),
"R_ARM_ABS32": reflect.ValueOf(elf.R_ARM_ABS32),
"R_ARM_ABS32_NOI": reflect.ValueOf(elf.R_ARM_ABS32_NOI),
"R_ARM_ABS8": reflect.ValueOf(elf.R_ARM_ABS8),
"R_ARM_ALU_PCREL_15_8": reflect.ValueOf(elf.R_ARM_ALU_PCREL_15_8),
"R_ARM_ALU_PCREL_23_15": reflect.ValueOf(elf.R_ARM_ALU_PCREL_23_15),
"R_ARM_ALU_PCREL_7_0": reflect.ValueOf(elf.R_ARM_ALU_PCREL_7_0),
"R_ARM_ALU_PC_G0": reflect.ValueOf(elf.R_ARM_ALU_PC_G0),
"R_ARM_ALU_PC_G0_NC": reflect.ValueOf(elf.R_ARM_ALU_PC_G0_NC),
"R_ARM_ALU_PC_G1": reflect.ValueOf(elf.R_ARM_ALU_PC_G1),
"R_ARM_ALU_PC_G1_NC": reflect.ValueOf(elf.R_ARM_ALU_PC_G1_NC),
"R_ARM_ALU_PC_G2": reflect.ValueOf(elf.R_ARM_ALU_PC_G2),
"R_ARM_ALU_SBREL_19_12_NC": reflect.ValueOf(elf.R_ARM_ALU_SBREL_19_12_NC),
"R_ARM_ALU_SBREL_27_20_CK": reflect.ValueOf(elf.R_ARM_ALU_SBREL_27_20_CK),
"R_ARM_ALU_SB_G0": reflect.ValueOf(elf.R_ARM_ALU_SB_G0),
"R_ARM_ALU_SB_G0_NC": reflect.ValueOf(elf.R_ARM_ALU_SB_G0_NC),
"R_ARM_ALU_SB_G1": reflect.ValueOf(elf.R_ARM_ALU_SB_G1),
"R_ARM_ALU_SB_G1_NC": reflect.ValueOf(elf.R_ARM_ALU_SB_G1_NC),
"R_ARM_ALU_SB_G2": reflect.ValueOf(elf.R_ARM_ALU_SB_G2),
"R_ARM_AMP_VCALL9": reflect.ValueOf(elf.R_ARM_AMP_VCALL9),
"R_ARM_BASE_ABS": reflect.ValueOf(elf.R_ARM_BASE_ABS),
"R_ARM_CALL": reflect.ValueOf(elf.R_ARM_CALL),
"R_ARM_COPY": reflect.ValueOf(elf.R_ARM_COPY),
"R_ARM_GLOB_DAT": reflect.ValueOf(elf.R_ARM_GLOB_DAT),
"R_ARM_GNU_VTENTRY": reflect.ValueOf(elf.R_ARM_GNU_VTENTRY),
"R_ARM_GNU_VTINHERIT": reflect.ValueOf(elf.R_ARM_GNU_VTINHERIT),
"R_ARM_GOT32": reflect.ValueOf(elf.R_ARM_GOT32),
"R_ARM_GOTOFF": reflect.ValueOf(elf.R_ARM_GOTOFF),
"R_ARM_GOTOFF12": reflect.ValueOf(elf.R_ARM_GOTOFF12),
"R_ARM_GOTPC": reflect.ValueOf(elf.R_ARM_GOTPC),
"R_ARM_GOTRELAX": reflect.ValueOf(elf.R_ARM_GOTRELAX),
"R_ARM_GOT_ABS": reflect.ValueOf(elf.R_ARM_GOT_ABS),
"R_ARM_GOT_BREL12": reflect.ValueOf(elf.R_ARM_GOT_BREL12),
"R_ARM_GOT_PREL": reflect.ValueOf(elf.R_ARM_GOT_PREL),
"R_ARM_IRELATIVE": reflect.ValueOf(elf.R_ARM_IRELATIVE),
"R_ARM_JUMP24": reflect.ValueOf(elf.R_ARM_JUMP24),
"R_ARM_JUMP_SLOT": reflect.ValueOf(elf.R_ARM_JUMP_SLOT),
"R_ARM_LDC_PC_G0": reflect.ValueOf(elf.R_ARM_LDC_PC_G0),
"R_ARM_LDC_PC_G1": reflect.ValueOf(elf.R_ARM_LDC_PC_G1),
"R_ARM_LDC_PC_G2": reflect.ValueOf(elf.R_ARM_LDC_PC_G2),
"R_ARM_LDC_SB_G0": reflect.ValueOf(elf.R_ARM_LDC_SB_G0),
"R_ARM_LDC_SB_G1": reflect.ValueOf(elf.R_ARM_LDC_SB_G1),
"R_ARM_LDC_SB_G2": reflect.ValueOf(elf.R_ARM_LDC_SB_G2),
"R_ARM_LDRS_PC_G0": reflect.ValueOf(elf.R_ARM_LDRS_PC_G0),
"R_ARM_LDRS_PC_G1": reflect.ValueOf(elf.R_ARM_LDRS_PC_G1),
"R_ARM_LDRS_PC_G2": reflect.ValueOf(elf.R_ARM_LDRS_PC_G2),
"R_ARM_LDRS_SB_G0": reflect.ValueOf(elf.R_ARM_LDRS_SB_G0),
"R_ARM_LDRS_SB_G1": reflect.ValueOf(elf.R_ARM_LDRS_SB_G1),
"R_ARM_LDRS_SB_G2": reflect.ValueOf(elf.R_ARM_LDRS_SB_G2),
"R_ARM_LDR_PC_G1": reflect.ValueOf(elf.R_ARM_LDR_PC_G1),
"R_ARM_LDR_PC_G2": reflect.ValueOf(elf.R_ARM_LDR_PC_G2),
"R_ARM_LDR_SBREL_11_10_NC": reflect.ValueOf(elf.R_ARM_LDR_SBREL_11_10_NC),
"R_ARM_LDR_SB_G0": reflect.ValueOf(elf.R_ARM_LDR_SB_G0),
"R_ARM_LDR_SB_G1": reflect.ValueOf(elf.R_ARM_LDR_SB_G1),
"R_ARM_LDR_SB_G2": reflect.ValueOf(elf.R_ARM_LDR_SB_G2),
"R_ARM_ME_TOO": reflect.ValueOf(elf.R_ARM_ME_TOO),
"R_ARM_MOVT_ABS": reflect.ValueOf(elf.R_ARM_MOVT_ABS),
"R_ARM_MOVT_BREL": reflect.ValueOf(elf.R_ARM_MOVT_BREL),
"R_ARM_MOVT_PREL": reflect.ValueOf(elf.R_ARM_MOVT_PREL),
"R_ARM_MOVW_ABS_NC": reflect.ValueOf(elf.R_ARM_MOVW_ABS_NC),
"R_ARM_MOVW_BREL": reflect.ValueOf(elf.R_ARM_MOVW_BREL),
"R_ARM_MOVW_BREL_NC": reflect.ValueOf(elf.R_ARM_MOVW_BREL_NC),
"R_ARM_MOVW_PREL_NC": reflect.ValueOf(elf.R_ARM_MOVW_PREL_NC),
"R_ARM_NONE": reflect.ValueOf(elf.R_ARM_NONE),
"R_ARM_PC13": reflect.ValueOf(elf.R_ARM_PC13),
"R_ARM_PC24": reflect.ValueOf(elf.R_ARM_PC24),
"R_ARM_PLT32": reflect.ValueOf(elf.R_ARM_PLT32),
"R_ARM_PLT32_ABS": reflect.ValueOf(elf.R_ARM_PLT32_ABS),
"R_ARM_PREL31": reflect.ValueOf(elf.R_ARM_PREL31),
"R_ARM_PRIVATE_0": reflect.ValueOf(elf.R_ARM_PRIVATE_0),
"R_ARM_PRIVATE_1": reflect.ValueOf(elf.R_ARM_PRIVATE_1),
"R_ARM_PRIVATE_10": reflect.ValueOf(elf.R_ARM_PRIVATE_10),
"R_ARM_PRIVATE_11": reflect.ValueOf(elf.R_ARM_PRIVATE_11),
"R_ARM_PRIVATE_12": reflect.ValueOf(elf.R_ARM_PRIVATE_12),
"R_ARM_PRIVATE_13": reflect.ValueOf(elf.R_ARM_PRIVATE_13),
"R_ARM_PRIVATE_14": reflect.ValueOf(elf.R_ARM_PRIVATE_14),
"R_ARM_PRIVATE_15": reflect.ValueOf(elf.R_ARM_PRIVATE_15),
"R_ARM_PRIVATE_2": reflect.ValueOf(elf.R_ARM_PRIVATE_2),
"R_ARM_PRIVATE_3": reflect.ValueOf(elf.R_ARM_PRIVATE_3),
"R_ARM_PRIVATE_4": reflect.ValueOf(elf.R_ARM_PRIVATE_4),
"R_ARM_PRIVATE_5": reflect.ValueOf(elf.R_ARM_PRIVATE_5),
"R_ARM_PRIVATE_6": reflect.ValueOf(elf.R_ARM_PRIVATE_6),
"R_ARM_PRIVATE_7": reflect.ValueOf(elf.R_ARM_PRIVATE_7),
"R_ARM_PRIVATE_8": reflect.ValueOf(elf.R_ARM_PRIVATE_8),
"R_ARM_PRIVATE_9": reflect.ValueOf(elf.R_ARM_PRIVATE_9),
"R_ARM_RABS32": reflect.ValueOf(elf.R_ARM_RABS32),
"R_ARM_RBASE": reflect.ValueOf(elf.R_ARM_RBASE),
"R_ARM_REL32": reflect.ValueOf(elf.R_ARM_REL32),
"R_ARM_REL32_NOI": reflect.ValueOf(elf.R_ARM_REL32_NOI),
"R_ARM_RELATIVE": reflect.ValueOf(elf.R_ARM_RELATIVE),
"R_ARM_RPC24": reflect.ValueOf(elf.R_ARM_RPC24),
"R_ARM_RREL32": reflect.ValueOf(elf.R_ARM_RREL32),
"R_ARM_RSBREL32": reflect.ValueOf(elf.R_ARM_RSBREL32),
"R_ARM_RXPC25": reflect.ValueOf(elf.R_ARM_RXPC25),
"R_ARM_SBREL31": reflect.ValueOf(elf.R_ARM_SBREL31),
"R_ARM_SBREL32": reflect.ValueOf(elf.R_ARM_SBREL32),
"R_ARM_SWI24": reflect.ValueOf(elf.R_ARM_SWI24),
"R_ARM_TARGET1": reflect.ValueOf(elf.R_ARM_TARGET1),
"R_ARM_TARGET2": reflect.ValueOf(elf.R_ARM_TARGET2),
"R_ARM_THM_ABS5": reflect.ValueOf(elf.R_ARM_THM_ABS5),
"R_ARM_THM_ALU_ABS_G0_NC": reflect.ValueOf(elf.R_ARM_THM_ALU_ABS_G0_NC),
"R_ARM_THM_ALU_ABS_G1_NC": reflect.ValueOf(elf.R_ARM_THM_ALU_ABS_G1_NC),
"R_ARM_THM_ALU_ABS_G2_NC": reflect.ValueOf(elf.R_ARM_THM_ALU_ABS_G2_NC),
"R_ARM_THM_ALU_ABS_G3": reflect.ValueOf(elf.R_ARM_THM_ALU_ABS_G3),
"R_ARM_THM_ALU_PREL_11_0": reflect.ValueOf(elf.R_ARM_THM_ALU_PREL_11_0),
"R_ARM_THM_GOT_BREL12": reflect.ValueOf(elf.R_ARM_THM_GOT_BREL12),
"R_ARM_THM_JUMP11": reflect.ValueOf(elf.R_ARM_THM_JUMP11),
"R_ARM_THM_JUMP19": reflect.ValueOf(elf.R_ARM_THM_JUMP19),
"R_ARM_THM_JUMP24": reflect.ValueOf(elf.R_ARM_THM_JUMP24),
"R_ARM_THM_JUMP6": reflect.ValueOf(elf.R_ARM_THM_JUMP6),
"R_ARM_THM_JUMP8": reflect.ValueOf(elf.R_ARM_THM_JUMP8),
"R_ARM_THM_MOVT_ABS": reflect.ValueOf(elf.R_ARM_THM_MOVT_ABS),
"R_ARM_THM_MOVT_BREL": reflect.ValueOf(elf.R_ARM_THM_MOVT_BREL),
"R_ARM_THM_MOVT_PREL": reflect.ValueOf(elf.R_ARM_THM_MOVT_PREL),
"R_ARM_THM_MOVW_ABS_NC": reflect.ValueOf(elf.R_ARM_THM_MOVW_ABS_NC),
"R_ARM_THM_MOVW_BREL": reflect.ValueOf(elf.R_ARM_THM_MOVW_BREL),
"R_ARM_THM_MOVW_BREL_NC": reflect.ValueOf(elf.R_ARM_THM_MOVW_BREL_NC),
"R_ARM_THM_MOVW_PREL_NC": reflect.ValueOf(elf.R_ARM_THM_MOVW_PREL_NC),
"R_ARM_THM_PC12": reflect.ValueOf(elf.R_ARM_THM_PC12),
"R_ARM_THM_PC22": reflect.ValueOf(elf.R_ARM_THM_PC22),
"R_ARM_THM_PC8": reflect.ValueOf(elf.R_ARM_THM_PC8),
"R_ARM_THM_RPC22": reflect.ValueOf(elf.R_ARM_THM_RPC22),
"R_ARM_THM_SWI8": reflect.ValueOf(elf.R_ARM_THM_SWI8),
"R_ARM_THM_TLS_CALL": reflect.ValueOf(elf.R_ARM_THM_TLS_CALL),
"R_ARM_THM_TLS_DESCSEQ16": reflect.ValueOf(elf.R_ARM_THM_TLS_DESCSEQ16),
"R_ARM_THM_TLS_DESCSEQ32": reflect.ValueOf(elf.R_ARM_THM_TLS_DESCSEQ32),
"R_ARM_THM_XPC22": reflect.ValueOf(elf.R_ARM_THM_XPC22),
"R_ARM_TLS_CALL": reflect.ValueOf(elf.R_ARM_TLS_CALL),
"R_ARM_TLS_DESCSEQ": reflect.ValueOf(elf.R_ARM_TLS_DESCSEQ),
"R_ARM_TLS_DTPMOD32": reflect.ValueOf(elf.R_ARM_TLS_DTPMOD32),
"R_ARM_TLS_DTPOFF32": reflect.ValueOf(elf.R_ARM_TLS_DTPOFF32),
"R_ARM_TLS_GD32": reflect.ValueOf(elf.R_ARM_TLS_GD32),
"R_ARM_TLS_GOTDESC": reflect.ValueOf(elf.R_ARM_TLS_GOTDESC),
"R_ARM_TLS_IE12GP": reflect.ValueOf(elf.R_ARM_TLS_IE12GP),
"R_ARM_TLS_IE32": reflect.ValueOf(elf.R_ARM_TLS_IE32),
"R_ARM_TLS_LDM32": reflect.ValueOf(elf.R_ARM_TLS_LDM32),
"R_ARM_TLS_LDO12": reflect.ValueOf(elf.R_ARM_TLS_LDO12),
"R_ARM_TLS_LDO32": reflect.ValueOf(elf.R_ARM_TLS_LDO32),
"R_ARM_TLS_LE12": reflect.ValueOf(elf.R_ARM_TLS_LE12),
"R_ARM_TLS_LE32": reflect.ValueOf(elf.R_ARM_TLS_LE32),
"R_ARM_TLS_TPOFF32": reflect.ValueOf(elf.R_ARM_TLS_TPOFF32),
"R_ARM_V4BX": reflect.ValueOf(elf.R_ARM_V4BX),
"R_ARM_XPC25": reflect.ValueOf(elf.R_ARM_XPC25),
"R_INFO": reflect.ValueOf(elf.R_INFO),
"R_INFO32": reflect.ValueOf(elf.R_INFO32),
"R_LARCH_32": reflect.ValueOf(elf.R_LARCH_32),
"R_LARCH_32_PCREL": reflect.ValueOf(elf.R_LARCH_32_PCREL),
"R_LARCH_64": reflect.ValueOf(elf.R_LARCH_64),
"R_LARCH_64_PCREL": reflect.ValueOf(elf.R_LARCH_64_PCREL),
"R_LARCH_ABS64_HI12": reflect.ValueOf(elf.R_LARCH_ABS64_HI12),
"R_LARCH_ABS64_LO20": reflect.ValueOf(elf.R_LARCH_ABS64_LO20),
"R_LARCH_ABS_HI20": reflect.ValueOf(elf.R_LARCH_ABS_HI20),
"R_LARCH_ABS_LO12": reflect.ValueOf(elf.R_LARCH_ABS_LO12),
"R_LARCH_ADD16": reflect.ValueOf(elf.R_LARCH_ADD16),
"R_LARCH_ADD24": reflect.ValueOf(elf.R_LARCH_ADD24),
"R_LARCH_ADD32": reflect.ValueOf(elf.R_LARCH_ADD32),
"R_LARCH_ADD6": reflect.ValueOf(elf.R_LARCH_ADD6),
"R_LARCH_ADD64": reflect.ValueOf(elf.R_LARCH_ADD64),
"R_LARCH_ADD8": reflect.ValueOf(elf.R_LARCH_ADD8),
"R_LARCH_ADD_ULEB128": reflect.ValueOf(elf.R_LARCH_ADD_ULEB128),
"R_LARCH_ALIGN": reflect.ValueOf(elf.R_LARCH_ALIGN),
"R_LARCH_B16": reflect.ValueOf(elf.R_LARCH_B16),
"R_LARCH_B21": reflect.ValueOf(elf.R_LARCH_B21),
"R_LARCH_B26": reflect.ValueOf(elf.R_LARCH_B26),
"R_LARCH_CFA": reflect.ValueOf(elf.R_LARCH_CFA),
"R_LARCH_COPY": reflect.ValueOf(elf.R_LARCH_COPY),
"R_LARCH_DELETE": reflect.ValueOf(elf.R_LARCH_DELETE),
"R_LARCH_GNU_VTENTRY": reflect.ValueOf(elf.R_LARCH_GNU_VTENTRY),
"R_LARCH_GNU_VTINHERIT": reflect.ValueOf(elf.R_LARCH_GNU_VTINHERIT),
"R_LARCH_GOT64_HI12": reflect.ValueOf(elf.R_LARCH_GOT64_HI12),
"R_LARCH_GOT64_LO20": reflect.ValueOf(elf.R_LARCH_GOT64_LO20),
"R_LARCH_GOT64_PC_HI12": reflect.ValueOf(elf.R_LARCH_GOT64_PC_HI12),
"R_LARCH_GOT64_PC_LO20": reflect.ValueOf(elf.R_LARCH_GOT64_PC_LO20),
"R_LARCH_GOT_HI20": reflect.ValueOf(elf.R_LARCH_GOT_HI20),
"R_LARCH_GOT_LO12": reflect.ValueOf(elf.R_LARCH_GOT_LO12),
"R_LARCH_GOT_PC_HI20": reflect.ValueOf(elf.R_LARCH_GOT_PC_HI20),
"R_LARCH_GOT_PC_LO12": reflect.ValueOf(elf.R_LARCH_GOT_PC_LO12),
"R_LARCH_IRELATIVE": reflect.ValueOf(elf.R_LARCH_IRELATIVE),
"R_LARCH_JUMP_SLOT": reflect.ValueOf(elf.R_LARCH_JUMP_SLOT),
"R_LARCH_MARK_LA": reflect.ValueOf(elf.R_LARCH_MARK_LA),
"R_LARCH_MARK_PCREL": reflect.ValueOf(elf.R_LARCH_MARK_PCREL),
"R_LARCH_NONE": reflect.ValueOf(elf.R_LARCH_NONE),
"R_LARCH_PCALA64_HI12": reflect.ValueOf(elf.R_LARCH_PCALA64_HI12),
"R_LARCH_PCALA64_LO20": reflect.ValueOf(elf.R_LARCH_PCALA64_LO20),
"R_LARCH_PCALA_HI20": reflect.ValueOf(elf.R_LARCH_PCALA_HI20),
"R_LARCH_PCALA_LO12": reflect.ValueOf(elf.R_LARCH_PCALA_LO12),
"R_LARCH_PCREL20_S2": reflect.ValueOf(elf.R_LARCH_PCREL20_S2),
"R_LARCH_RELATIVE": reflect.ValueOf(elf.R_LARCH_RELATIVE),
"R_LARCH_RELAX": reflect.ValueOf(elf.R_LARCH_RELAX),
"R_LARCH_SOP_ADD": reflect.ValueOf(elf.R_LARCH_SOP_ADD),
"R_LARCH_SOP_AND": reflect.ValueOf(elf.R_LARCH_SOP_AND),
"R_LARCH_SOP_ASSERT": reflect.ValueOf(elf.R_LARCH_SOP_ASSERT),
"R_LARCH_SOP_IF_ELSE": reflect.ValueOf(elf.R_LARCH_SOP_IF_ELSE),
"R_LARCH_SOP_NOT": reflect.ValueOf(elf.R_LARCH_SOP_NOT),
"R_LARCH_SOP_POP_32_S_0_10_10_16_S2": reflect.ValueOf(elf.R_LARCH_SOP_POP_32_S_0_10_10_16_S2),
"R_LARCH_SOP_POP_32_S_0_5_10_16_S2": reflect.ValueOf(elf.R_LARCH_SOP_POP_32_S_0_5_10_16_S2),
"R_LARCH_SOP_POP_32_S_10_12": reflect.ValueOf(elf.R_LARCH_SOP_POP_32_S_10_12),
"R_LARCH_SOP_POP_32_S_10_16": reflect.ValueOf(elf.R_LARCH_SOP_POP_32_S_10_16),
"R_LARCH_SOP_POP_32_S_10_16_S2": reflect.ValueOf(elf.R_LARCH_SOP_POP_32_S_10_16_S2),
"R_LARCH_SOP_POP_32_S_10_5": reflect.ValueOf(elf.R_LARCH_SOP_POP_32_S_10_5),
"R_LARCH_SOP_POP_32_S_5_20": reflect.ValueOf(elf.R_LARCH_SOP_POP_32_S_5_20),
"R_LARCH_SOP_POP_32_U": reflect.ValueOf(elf.R_LARCH_SOP_POP_32_U),
"R_LARCH_SOP_POP_32_U_10_12": reflect.ValueOf(elf.R_LARCH_SOP_POP_32_U_10_12),
"R_LARCH_SOP_PUSH_ABSOLUTE": reflect.ValueOf(elf.R_LARCH_SOP_PUSH_ABSOLUTE),
"R_LARCH_SOP_PUSH_DUP": reflect.ValueOf(elf.R_LARCH_SOP_PUSH_DUP),
"R_LARCH_SOP_PUSH_GPREL": reflect.ValueOf(elf.R_LARCH_SOP_PUSH_GPREL),
"R_LARCH_SOP_PUSH_PCREL": reflect.ValueOf(elf.R_LARCH_SOP_PUSH_PCREL),
"R_LARCH_SOP_PUSH_PLT_PCREL": reflect.ValueOf(elf.R_LARCH_SOP_PUSH_PLT_PCREL),
"R_LARCH_SOP_PUSH_TLS_GD": reflect.ValueOf(elf.R_LARCH_SOP_PUSH_TLS_GD),
"R_LARCH_SOP_PUSH_TLS_GOT": reflect.ValueOf(elf.R_LARCH_SOP_PUSH_TLS_GOT),
"R_LARCH_SOP_PUSH_TLS_TPREL": reflect.ValueOf(elf.R_LARCH_SOP_PUSH_TLS_TPREL),
"R_LARCH_SOP_SL": reflect.ValueOf(elf.R_LARCH_SOP_SL),
"R_LARCH_SOP_SR": reflect.ValueOf(elf.R_LARCH_SOP_SR),
"R_LARCH_SOP_SUB": reflect.ValueOf(elf.R_LARCH_SOP_SUB),
"R_LARCH_SUB16": reflect.ValueOf(elf.R_LARCH_SUB16),
"R_LARCH_SUB24": reflect.ValueOf(elf.R_LARCH_SUB24),
"R_LARCH_SUB32": reflect.ValueOf(elf.R_LARCH_SUB32),
"R_LARCH_SUB6": reflect.ValueOf(elf.R_LARCH_SUB6),
"R_LARCH_SUB64": reflect.ValueOf(elf.R_LARCH_SUB64),
"R_LARCH_SUB8": reflect.ValueOf(elf.R_LARCH_SUB8),
"R_LARCH_SUB_ULEB128": reflect.ValueOf(elf.R_LARCH_SUB_ULEB128),
"R_LARCH_TLS_DTPMOD32": reflect.ValueOf(elf.R_LARCH_TLS_DTPMOD32),
"R_LARCH_TLS_DTPMOD64": reflect.ValueOf(elf.R_LARCH_TLS_DTPMOD64),
"R_LARCH_TLS_DTPREL32": reflect.ValueOf(elf.R_LARCH_TLS_DTPREL32),
"R_LARCH_TLS_DTPREL64": reflect.ValueOf(elf.R_LARCH_TLS_DTPREL64),
"R_LARCH_TLS_GD_HI20": reflect.ValueOf(elf.R_LARCH_TLS_GD_HI20),
"R_LARCH_TLS_GD_PC_HI20": reflect.ValueOf(elf.R_LARCH_TLS_GD_PC_HI20),
"R_LARCH_TLS_IE64_HI12": reflect.ValueOf(elf.R_LARCH_TLS_IE64_HI12),
"R_LARCH_TLS_IE64_LO20": reflect.ValueOf(elf.R_LARCH_TLS_IE64_LO20),
"R_LARCH_TLS_IE64_PC_HI12": reflect.ValueOf(elf.R_LARCH_TLS_IE64_PC_HI12),
"R_LARCH_TLS_IE64_PC_LO20": reflect.ValueOf(elf.R_LARCH_TLS_IE64_PC_LO20),
"R_LARCH_TLS_IE_HI20": reflect.ValueOf(elf.R_LARCH_TLS_IE_HI20),
"R_LARCH_TLS_IE_LO12": reflect.ValueOf(elf.R_LARCH_TLS_IE_LO12),
"R_LARCH_TLS_IE_PC_HI20": reflect.ValueOf(elf.R_LARCH_TLS_IE_PC_HI20),
"R_LARCH_TLS_IE_PC_LO12": reflect.ValueOf(elf.R_LARCH_TLS_IE_PC_LO12),
"R_LARCH_TLS_LD_HI20": reflect.ValueOf(elf.R_LARCH_TLS_LD_HI20),
"R_LARCH_TLS_LD_PC_HI20": reflect.ValueOf(elf.R_LARCH_TLS_LD_PC_HI20),
"R_LARCH_TLS_LE64_HI12": reflect.ValueOf(elf.R_LARCH_TLS_LE64_HI12),
"R_LARCH_TLS_LE64_LO20": reflect.ValueOf(elf.R_LARCH_TLS_LE64_LO20),
"R_LARCH_TLS_LE_HI20": reflect.ValueOf(elf.R_LARCH_TLS_LE_HI20),
"R_LARCH_TLS_LE_LO12": reflect.ValueOf(elf.R_LARCH_TLS_LE_LO12),
"R_LARCH_TLS_TPREL32": reflect.ValueOf(elf.R_LARCH_TLS_TPREL32),
"R_LARCH_TLS_TPREL64": reflect.ValueOf(elf.R_LARCH_TLS_TPREL64),
"R_MIPS_16": reflect.ValueOf(elf.R_MIPS_16),
"R_MIPS_26": reflect.ValueOf(elf.R_MIPS_26),
"R_MIPS_32": reflect.ValueOf(elf.R_MIPS_32),
"R_MIPS_64": reflect.ValueOf(elf.R_MIPS_64),
"R_MIPS_ADD_IMMEDIATE": reflect.ValueOf(elf.R_MIPS_ADD_IMMEDIATE),
"R_MIPS_CALL16": reflect.ValueOf(elf.R_MIPS_CALL16),
"R_MIPS_CALL_HI16": reflect.ValueOf(elf.R_MIPS_CALL_HI16),
"R_MIPS_CALL_LO16": reflect.ValueOf(elf.R_MIPS_CALL_LO16),
"R_MIPS_DELETE": reflect.ValueOf(elf.R_MIPS_DELETE),
"R_MIPS_GOT16": reflect.ValueOf(elf.R_MIPS_GOT16),
"R_MIPS_GOT_DISP": reflect.ValueOf(elf.R_MIPS_GOT_DISP),
"R_MIPS_GOT_HI16": reflect.ValueOf(elf.R_MIPS_GOT_HI16),
"R_MIPS_GOT_LO16": reflect.ValueOf(elf.R_MIPS_GOT_LO16),
"R_MIPS_GOT_OFST": reflect.ValueOf(elf.R_MIPS_GOT_OFST),
"R_MIPS_GOT_PAGE": reflect.ValueOf(elf.R_MIPS_GOT_PAGE),
"R_MIPS_GPREL16": reflect.ValueOf(elf.R_MIPS_GPREL16),
"R_MIPS_GPREL32": reflect.ValueOf(elf.R_MIPS_GPREL32),
"R_MIPS_HI16": reflect.ValueOf(elf.R_MIPS_HI16),
"R_MIPS_HIGHER": reflect.ValueOf(elf.R_MIPS_HIGHER),
"R_MIPS_HIGHEST": reflect.ValueOf(elf.R_MIPS_HIGHEST),
"R_MIPS_INSERT_A": reflect.ValueOf(elf.R_MIPS_INSERT_A),
"R_MIPS_INSERT_B": reflect.ValueOf(elf.R_MIPS_INSERT_B),
"R_MIPS_JALR": reflect.ValueOf(elf.R_MIPS_JALR),
"R_MIPS_LITERAL": reflect.ValueOf(elf.R_MIPS_LITERAL),
"R_MIPS_LO16": reflect.ValueOf(elf.R_MIPS_LO16),
"R_MIPS_NONE": reflect.ValueOf(elf.R_MIPS_NONE),
"R_MIPS_PC16": reflect.ValueOf(elf.R_MIPS_PC16),
"R_MIPS_PC32": reflect.ValueOf(elf.R_MIPS_PC32),
"R_MIPS_PJUMP": reflect.ValueOf(elf.R_MIPS_PJUMP),
"R_MIPS_REL16": reflect.ValueOf(elf.R_MIPS_REL16),
"R_MIPS_REL32": reflect.ValueOf(elf.R_MIPS_REL32),
"R_MIPS_RELGOT": reflect.ValueOf(elf.R_MIPS_RELGOT),
"R_MIPS_SCN_DISP": reflect.ValueOf(elf.R_MIPS_SCN_DISP),
"R_MIPS_SHIFT5": reflect.ValueOf(elf.R_MIPS_SHIFT5),
"R_MIPS_SHIFT6": reflect.ValueOf(elf.R_MIPS_SHIFT6),
"R_MIPS_SUB": reflect.ValueOf(elf.R_MIPS_SUB),
"R_MIPS_TLS_DTPMOD32": reflect.ValueOf(elf.R_MIPS_TLS_DTPMOD32),
"R_MIPS_TLS_DTPMOD64": reflect.ValueOf(elf.R_MIPS_TLS_DTPMOD64),
"R_MIPS_TLS_DTPREL32": reflect.ValueOf(elf.R_MIPS_TLS_DTPREL32),
"R_MIPS_TLS_DTPREL64": reflect.ValueOf(elf.R_MIPS_TLS_DTPREL64),
"R_MIPS_TLS_DTPREL_HI16": reflect.ValueOf(elf.R_MIPS_TLS_DTPREL_HI16),
"R_MIPS_TLS_DTPREL_LO16": reflect.ValueOf(elf.R_MIPS_TLS_DTPREL_LO16),
"R_MIPS_TLS_GD": reflect.ValueOf(elf.R_MIPS_TLS_GD),
"R_MIPS_TLS_GOTTPREL": reflect.ValueOf(elf.R_MIPS_TLS_GOTTPREL),
"R_MIPS_TLS_LDM": reflect.ValueOf(elf.R_MIPS_TLS_LDM),
"R_MIPS_TLS_TPREL32": reflect.ValueOf(elf.R_MIPS_TLS_TPREL32),
"R_MIPS_TLS_TPREL64": reflect.ValueOf(elf.R_MIPS_TLS_TPREL64),
"R_MIPS_TLS_TPREL_HI16": reflect.ValueOf(elf.R_MIPS_TLS_TPREL_HI16),
"R_MIPS_TLS_TPREL_LO16": reflect.ValueOf(elf.R_MIPS_TLS_TPREL_LO16),
"R_PPC64_ADDR14": reflect.ValueOf(elf.R_PPC64_ADDR14),
"R_PPC64_ADDR14_BRNTAKEN": reflect.ValueOf(elf.R_PPC64_ADDR14_BRNTAKEN),
"R_PPC64_ADDR14_BRTAKEN": reflect.ValueOf(elf.R_PPC64_ADDR14_BRTAKEN),
"R_PPC64_ADDR16": reflect.ValueOf(elf.R_PPC64_ADDR16),
"R_PPC64_ADDR16_DS": reflect.ValueOf(elf.R_PPC64_ADDR16_DS),
"R_PPC64_ADDR16_HA": reflect.ValueOf(elf.R_PPC64_ADDR16_HA),
"R_PPC64_ADDR16_HI": reflect.ValueOf(elf.R_PPC64_ADDR16_HI),
"R_PPC64_ADDR16_HIGH": reflect.ValueOf(elf.R_PPC64_ADDR16_HIGH),
"R_PPC64_ADDR16_HIGHA": reflect.ValueOf(elf.R_PPC64_ADDR16_HIGHA),
"R_PPC64_ADDR16_HIGHER": reflect.ValueOf(elf.R_PPC64_ADDR16_HIGHER),
"R_PPC64_ADDR16_HIGHER34": reflect.ValueOf(elf.R_PPC64_ADDR16_HIGHER34),
"R_PPC64_ADDR16_HIGHERA": reflect.ValueOf(elf.R_PPC64_ADDR16_HIGHERA),
"R_PPC64_ADDR16_HIGHERA34": reflect.ValueOf(elf.R_PPC64_ADDR16_HIGHERA34),
"R_PPC64_ADDR16_HIGHEST": reflect.ValueOf(elf.R_PPC64_ADDR16_HIGHEST),
"R_PPC64_ADDR16_HIGHEST34": reflect.ValueOf(elf.R_PPC64_ADDR16_HIGHEST34),
"R_PPC64_ADDR16_HIGHESTA": reflect.ValueOf(elf.R_PPC64_ADDR16_HIGHESTA),
"R_PPC64_ADDR16_HIGHESTA34": reflect.ValueOf(elf.R_PPC64_ADDR16_HIGHESTA34),
"R_PPC64_ADDR16_LO": reflect.ValueOf(elf.R_PPC64_ADDR16_LO),
"R_PPC64_ADDR16_LO_DS": reflect.ValueOf(elf.R_PPC64_ADDR16_LO_DS),
"R_PPC64_ADDR24": reflect.ValueOf(elf.R_PPC64_ADDR24),
"R_PPC64_ADDR32": reflect.ValueOf(elf.R_PPC64_ADDR32),
"R_PPC64_ADDR64": reflect.ValueOf(elf.R_PPC64_ADDR64),
"R_PPC64_ADDR64_LOCAL": reflect.ValueOf(elf.R_PPC64_ADDR64_LOCAL),
"R_PPC64_COPY": reflect.ValueOf(elf.R_PPC64_COPY),
"R_PPC64_D28": reflect.ValueOf(elf.R_PPC64_D28),
"R_PPC64_D34": reflect.ValueOf(elf.R_PPC64_D34),
"R_PPC64_D34_HA30": reflect.ValueOf(elf.R_PPC64_D34_HA30),
"R_PPC64_D34_HI30": reflect.ValueOf(elf.R_PPC64_D34_HI30),
"R_PPC64_D34_LO": reflect.ValueOf(elf.R_PPC64_D34_LO),
"R_PPC64_DTPMOD64": reflect.ValueOf(elf.R_PPC64_DTPMOD64),
"R_PPC64_DTPREL16": reflect.ValueOf(elf.R_PPC64_DTPREL16),
"R_PPC64_DTPREL16_DS": reflect.ValueOf(elf.R_PPC64_DTPREL16_DS),
"R_PPC64_DTPREL16_HA": reflect.ValueOf(elf.R_PPC64_DTPREL16_HA),
"R_PPC64_DTPREL16_HI": reflect.ValueOf(elf.R_PPC64_DTPREL16_HI),
"R_PPC64_DTPREL16_HIGH": reflect.ValueOf(elf.R_PPC64_DTPREL16_HIGH),
"R_PPC64_DTPREL16_HIGHA": reflect.ValueOf(elf.R_PPC64_DTPREL16_HIGHA),
"R_PPC64_DTPREL16_HIGHER": reflect.ValueOf(elf.R_PPC64_DTPREL16_HIGHER),
"R_PPC64_DTPREL16_HIGHERA": reflect.ValueOf(elf.R_PPC64_DTPREL16_HIGHERA),
"R_PPC64_DTPREL16_HIGHEST": reflect.ValueOf(elf.R_PPC64_DTPREL16_HIGHEST),
"R_PPC64_DTPREL16_HIGHESTA": reflect.ValueOf(elf.R_PPC64_DTPREL16_HIGHESTA),
"R_PPC64_DTPREL16_LO": reflect.ValueOf(elf.R_PPC64_DTPREL16_LO),
"R_PPC64_DTPREL16_LO_DS": reflect.ValueOf(elf.R_PPC64_DTPREL16_LO_DS),
"R_PPC64_DTPREL34": reflect.ValueOf(elf.R_PPC64_DTPREL34),
"R_PPC64_DTPREL64": reflect.ValueOf(elf.R_PPC64_DTPREL64),
"R_PPC64_ENTRY": reflect.ValueOf(elf.R_PPC64_ENTRY),
"R_PPC64_GLOB_DAT": reflect.ValueOf(elf.R_PPC64_GLOB_DAT),
"R_PPC64_GNU_VTENTRY": reflect.ValueOf(elf.R_PPC64_GNU_VTENTRY),
"R_PPC64_GNU_VTINHERIT": reflect.ValueOf(elf.R_PPC64_GNU_VTINHERIT),
"R_PPC64_GOT16": reflect.ValueOf(elf.R_PPC64_GOT16),
"R_PPC64_GOT16_DS": reflect.ValueOf(elf.R_PPC64_GOT16_DS),
"R_PPC64_GOT16_HA": reflect.ValueOf(elf.R_PPC64_GOT16_HA),
"R_PPC64_GOT16_HI": reflect.ValueOf(elf.R_PPC64_GOT16_HI),
"R_PPC64_GOT16_LO": reflect.ValueOf(elf.R_PPC64_GOT16_LO),
"R_PPC64_GOT16_LO_DS": reflect.ValueOf(elf.R_PPC64_GOT16_LO_DS),
"R_PPC64_GOT_DTPREL16_DS": reflect.ValueOf(elf.R_PPC64_GOT_DTPREL16_DS),
"R_PPC64_GOT_DTPREL16_HA": reflect.ValueOf(elf.R_PPC64_GOT_DTPREL16_HA),
"R_PPC64_GOT_DTPREL16_HI": reflect.ValueOf(elf.R_PPC64_GOT_DTPREL16_HI),
"R_PPC64_GOT_DTPREL16_LO_DS": reflect.ValueOf(elf.R_PPC64_GOT_DTPREL16_LO_DS),
"R_PPC64_GOT_DTPREL_PCREL34": reflect.ValueOf(elf.R_PPC64_GOT_DTPREL_PCREL34),
"R_PPC64_GOT_PCREL34": reflect.ValueOf(elf.R_PPC64_GOT_PCREL34),
"R_PPC64_GOT_TLSGD16": reflect.ValueOf(elf.R_PPC64_GOT_TLSGD16),
"R_PPC64_GOT_TLSGD16_HA": reflect.ValueOf(elf.R_PPC64_GOT_TLSGD16_HA),
"R_PPC64_GOT_TLSGD16_HI": reflect.ValueOf(elf.R_PPC64_GOT_TLSGD16_HI),
"R_PPC64_GOT_TLSGD16_LO": reflect.ValueOf(elf.R_PPC64_GOT_TLSGD16_LO),
"R_PPC64_GOT_TLSGD_PCREL34": reflect.ValueOf(elf.R_PPC64_GOT_TLSGD_PCREL34),
"R_PPC64_GOT_TLSLD16": reflect.ValueOf(elf.R_PPC64_GOT_TLSLD16),
"R_PPC64_GOT_TLSLD16_HA": reflect.ValueOf(elf.R_PPC64_GOT_TLSLD16_HA),
"R_PPC64_GOT_TLSLD16_HI": reflect.ValueOf(elf.R_PPC64_GOT_TLSLD16_HI),
"R_PPC64_GOT_TLSLD16_LO": reflect.ValueOf(elf.R_PPC64_GOT_TLSLD16_LO),
"R_PPC64_GOT_TLSLD_PCREL34": reflect.ValueOf(elf.R_PPC64_GOT_TLSLD_PCREL34),
"R_PPC64_GOT_TPREL16_DS": reflect.ValueOf(elf.R_PPC64_GOT_TPREL16_DS),
"R_PPC64_GOT_TPREL16_HA": reflect.ValueOf(elf.R_PPC64_GOT_TPREL16_HA),
"R_PPC64_GOT_TPREL16_HI": reflect.ValueOf(elf.R_PPC64_GOT_TPREL16_HI),
"R_PPC64_GOT_TPREL16_LO_DS": reflect.ValueOf(elf.R_PPC64_GOT_TPREL16_LO_DS),
"R_PPC64_GOT_TPREL_PCREL34": reflect.ValueOf(elf.R_PPC64_GOT_TPREL_PCREL34),
"R_PPC64_IRELATIVE": reflect.ValueOf(elf.R_PPC64_IRELATIVE),
"R_PPC64_JMP_IREL": reflect.ValueOf(elf.R_PPC64_JMP_IREL),
"R_PPC64_JMP_SLOT": reflect.ValueOf(elf.R_PPC64_JMP_SLOT),
"R_PPC64_NONE": reflect.ValueOf(elf.R_PPC64_NONE),
"R_PPC64_PCREL28": reflect.ValueOf(elf.R_PPC64_PCREL28),
"R_PPC64_PCREL34": reflect.ValueOf(elf.R_PPC64_PCREL34),
"R_PPC64_PCREL_OPT": reflect.ValueOf(elf.R_PPC64_PCREL_OPT),
"R_PPC64_PLT16_HA": reflect.ValueOf(elf.R_PPC64_PLT16_HA),
"R_PPC64_PLT16_HI": reflect.ValueOf(elf.R_PPC64_PLT16_HI),
"R_PPC64_PLT16_LO": reflect.ValueOf(elf.R_PPC64_PLT16_LO),
"R_PPC64_PLT16_LO_DS": reflect.ValueOf(elf.R_PPC64_PLT16_LO_DS),
"R_PPC64_PLT32": reflect.ValueOf(elf.R_PPC64_PLT32),
"R_PPC64_PLT64": reflect.ValueOf(elf.R_PPC64_PLT64),
"R_PPC64_PLTCALL": reflect.ValueOf(elf.R_PPC64_PLTCALL),
"R_PPC64_PLTCALL_NOTOC": reflect.ValueOf(elf.R_PPC64_PLTCALL_NOTOC),
"R_PPC64_PLTGOT16": reflect.ValueOf(elf.R_PPC64_PLTGOT16),
"R_PPC64_PLTGOT16_DS": reflect.ValueOf(elf.R_PPC64_PLTGOT16_DS),
"R_PPC64_PLTGOT16_HA": reflect.ValueOf(elf.R_PPC64_PLTGOT16_HA),
"R_PPC64_PLTGOT16_HI": reflect.ValueOf(elf.R_PPC64_PLTGOT16_HI),
"R_PPC64_PLTGOT16_LO": reflect.ValueOf(elf.R_PPC64_PLTGOT16_LO),
"R_PPC64_PLTGOT_LO_DS": reflect.ValueOf(elf.R_PPC64_PLTGOT_LO_DS),
"R_PPC64_PLTREL32": reflect.ValueOf(elf.R_PPC64_PLTREL32),
"R_PPC64_PLTREL64": reflect.ValueOf(elf.R_PPC64_PLTREL64),
"R_PPC64_PLTSEQ": reflect.ValueOf(elf.R_PPC64_PLTSEQ),
"R_PPC64_PLTSEQ_NOTOC": reflect.ValueOf(elf.R_PPC64_PLTSEQ_NOTOC),
"R_PPC64_PLT_PCREL34": reflect.ValueOf(elf.R_PPC64_PLT_PCREL34),
"R_PPC64_PLT_PCREL34_NOTOC": reflect.ValueOf(elf.R_PPC64_PLT_PCREL34_NOTOC),
"R_PPC64_REL14": reflect.ValueOf(elf.R_PPC64_REL14),
"R_PPC64_REL14_BRNTAKEN": reflect.ValueOf(elf.R_PPC64_REL14_BRNTAKEN),
"R_PPC64_REL14_BRTAKEN": reflect.ValueOf(elf.R_PPC64_REL14_BRTAKEN),
"R_PPC64_REL16": reflect.ValueOf(elf.R_PPC64_REL16),
"R_PPC64_REL16DX_HA": reflect.ValueOf(elf.R_PPC64_REL16DX_HA),
"R_PPC64_REL16_HA": reflect.ValueOf(elf.R_PPC64_REL16_HA),
"R_PPC64_REL16_HI": reflect.ValueOf(elf.R_PPC64_REL16_HI),
"R_PPC64_REL16_HIGH": reflect.ValueOf(elf.R_PPC64_REL16_HIGH),
"R_PPC64_REL16_HIGHA": reflect.ValueOf(elf.R_PPC64_REL16_HIGHA),
"R_PPC64_REL16_HIGHER": reflect.ValueOf(elf.R_PPC64_REL16_HIGHER),
"R_PPC64_REL16_HIGHER34": reflect.ValueOf(elf.R_PPC64_REL16_HIGHER34),
"R_PPC64_REL16_HIGHERA": reflect.ValueOf(elf.R_PPC64_REL16_HIGHERA),
"R_PPC64_REL16_HIGHERA34": reflect.ValueOf(elf.R_PPC64_REL16_HIGHERA34),
"R_PPC64_REL16_HIGHEST": reflect.ValueOf(elf.R_PPC64_REL16_HIGHEST),
"R_PPC64_REL16_HIGHEST34": reflect.ValueOf(elf.R_PPC64_REL16_HIGHEST34),
"R_PPC64_REL16_HIGHESTA": reflect.ValueOf(elf.R_PPC64_REL16_HIGHESTA),
"R_PPC64_REL16_HIGHESTA34": reflect.ValueOf(elf.R_PPC64_REL16_HIGHESTA34),
"R_PPC64_REL16_LO": reflect.ValueOf(elf.R_PPC64_REL16_LO),
"R_PPC64_REL24": reflect.ValueOf(elf.R_PPC64_REL24),
"R_PPC64_REL24_NOTOC": reflect.ValueOf(elf.R_PPC64_REL24_NOTOC),
"R_PPC64_REL24_P9NOTOC": reflect.ValueOf(elf.R_PPC64_REL24_P9NOTOC),
"R_PPC64_REL30": reflect.ValueOf(elf.R_PPC64_REL30),
"R_PPC64_REL32": reflect.ValueOf(elf.R_PPC64_REL32),
"R_PPC64_REL64": reflect.ValueOf(elf.R_PPC64_REL64),
"R_PPC64_RELATIVE": reflect.ValueOf(elf.R_PPC64_RELATIVE),
"R_PPC64_SECTOFF": reflect.ValueOf(elf.R_PPC64_SECTOFF),
"R_PPC64_SECTOFF_DS": reflect.ValueOf(elf.R_PPC64_SECTOFF_DS),
"R_PPC64_SECTOFF_HA": reflect.ValueOf(elf.R_PPC64_SECTOFF_HA),
"R_PPC64_SECTOFF_HI": reflect.ValueOf(elf.R_PPC64_SECTOFF_HI),
"R_PPC64_SECTOFF_LO": reflect.ValueOf(elf.R_PPC64_SECTOFF_LO),
"R_PPC64_SECTOFF_LO_DS": reflect.ValueOf(elf.R_PPC64_SECTOFF_LO_DS),
"R_PPC64_TLS": reflect.ValueOf(elf.R_PPC64_TLS),
"R_PPC64_TLSGD": reflect.ValueOf(elf.R_PPC64_TLSGD),
"R_PPC64_TLSLD": reflect.ValueOf(elf.R_PPC64_TLSLD),
"R_PPC64_TOC": reflect.ValueOf(elf.R_PPC64_TOC),
"R_PPC64_TOC16": reflect.ValueOf(elf.R_PPC64_TOC16),
"R_PPC64_TOC16_DS": reflect.ValueOf(elf.R_PPC64_TOC16_DS),
"R_PPC64_TOC16_HA": reflect.ValueOf(elf.R_PPC64_TOC16_HA),
"R_PPC64_TOC16_HI": reflect.ValueOf(elf.R_PPC64_TOC16_HI),
"R_PPC64_TOC16_LO": reflect.ValueOf(elf.R_PPC64_TOC16_LO),
"R_PPC64_TOC16_LO_DS": reflect.ValueOf(elf.R_PPC64_TOC16_LO_DS),
"R_PPC64_TOCSAVE": reflect.ValueOf(elf.R_PPC64_TOCSAVE),
"R_PPC64_TPREL16": reflect.ValueOf(elf.R_PPC64_TPREL16),
"R_PPC64_TPREL16_DS": reflect.ValueOf(elf.R_PPC64_TPREL16_DS),
"R_PPC64_TPREL16_HA": reflect.ValueOf(elf.R_PPC64_TPREL16_HA),
"R_PPC64_TPREL16_HI": reflect.ValueOf(elf.R_PPC64_TPREL16_HI),
"R_PPC64_TPREL16_HIGH": reflect.ValueOf(elf.R_PPC64_TPREL16_HIGH),
"R_PPC64_TPREL16_HIGHA": reflect.ValueOf(elf.R_PPC64_TPREL16_HIGHA),
"R_PPC64_TPREL16_HIGHER": reflect.ValueOf(elf.R_PPC64_TPREL16_HIGHER),
"R_PPC64_TPREL16_HIGHERA": reflect.ValueOf(elf.R_PPC64_TPREL16_HIGHERA),
"R_PPC64_TPREL16_HIGHEST": reflect.ValueOf(elf.R_PPC64_TPREL16_HIGHEST),
"R_PPC64_TPREL16_HIGHESTA": reflect.ValueOf(elf.R_PPC64_TPREL16_HIGHESTA),
"R_PPC64_TPREL16_LO": reflect.ValueOf(elf.R_PPC64_TPREL16_LO),
"R_PPC64_TPREL16_LO_DS": reflect.ValueOf(elf.R_PPC64_TPREL16_LO_DS),
"R_PPC64_TPREL34": reflect.ValueOf(elf.R_PPC64_TPREL34),
"R_PPC64_TPREL64": reflect.ValueOf(elf.R_PPC64_TPREL64),
"R_PPC64_UADDR16": reflect.ValueOf(elf.R_PPC64_UADDR16),
"R_PPC64_UADDR32": reflect.ValueOf(elf.R_PPC64_UADDR32),
"R_PPC64_UADDR64": reflect.ValueOf(elf.R_PPC64_UADDR64),
"R_PPC_ADDR14": reflect.ValueOf(elf.R_PPC_ADDR14),
"R_PPC_ADDR14_BRNTAKEN": reflect.ValueOf(elf.R_PPC_ADDR14_BRNTAKEN),
"R_PPC_ADDR14_BRTAKEN": reflect.ValueOf(elf.R_PPC_ADDR14_BRTAKEN),
"R_PPC_ADDR16": reflect.ValueOf(elf.R_PPC_ADDR16),
"R_PPC_ADDR16_HA": reflect.ValueOf(elf.R_PPC_ADDR16_HA),
"R_PPC_ADDR16_HI": reflect.ValueOf(elf.R_PPC_ADDR16_HI),
"R_PPC_ADDR16_LO": reflect.ValueOf(elf.R_PPC_ADDR16_LO),
"R_PPC_ADDR24": reflect.ValueOf(elf.R_PPC_ADDR24),
"R_PPC_ADDR32": reflect.ValueOf(elf.R_PPC_ADDR32),
"R_PPC_COPY": reflect.ValueOf(elf.R_PPC_COPY),
"R_PPC_DTPMOD32": reflect.ValueOf(elf.R_PPC_DTPMOD32),
"R_PPC_DTPREL16": reflect.ValueOf(elf.R_PPC_DTPREL16),
"R_PPC_DTPREL16_HA": reflect.ValueOf(elf.R_PPC_DTPREL16_HA),
"R_PPC_DTPREL16_HI": reflect.ValueOf(elf.R_PPC_DTPREL16_HI),
"R_PPC_DTPREL16_LO": reflect.ValueOf(elf.R_PPC_DTPREL16_LO),
"R_PPC_DTPREL32": reflect.ValueOf(elf.R_PPC_DTPREL32),
"R_PPC_EMB_BIT_FLD": reflect.ValueOf(elf.R_PPC_EMB_BIT_FLD),
"R_PPC_EMB_MRKREF": reflect.ValueOf(elf.R_PPC_EMB_MRKREF),
"R_PPC_EMB_NADDR16": reflect.ValueOf(elf.R_PPC_EMB_NADDR16),
"R_PPC_EMB_NADDR16_HA": reflect.ValueOf(elf.R_PPC_EMB_NADDR16_HA),
"R_PPC_EMB_NADDR16_HI": reflect.ValueOf(elf.R_PPC_EMB_NADDR16_HI),
"R_PPC_EMB_NADDR16_LO": reflect.ValueOf(elf.R_PPC_EMB_NADDR16_LO),
"R_PPC_EMB_NADDR32": reflect.ValueOf(elf.R_PPC_EMB_NADDR32),
"R_PPC_EMB_RELSDA": reflect.ValueOf(elf.R_PPC_EMB_RELSDA),
"R_PPC_EMB_RELSEC16": reflect.ValueOf(elf.R_PPC_EMB_RELSEC16),
"R_PPC_EMB_RELST_HA": reflect.ValueOf(elf.R_PPC_EMB_RELST_HA),
"R_PPC_EMB_RELST_HI": reflect.ValueOf(elf.R_PPC_EMB_RELST_HI),
"R_PPC_EMB_RELST_LO": reflect.ValueOf(elf.R_PPC_EMB_RELST_LO),
"R_PPC_EMB_SDA21": reflect.ValueOf(elf.R_PPC_EMB_SDA21),
"R_PPC_EMB_SDA2I16": reflect.ValueOf(elf.R_PPC_EMB_SDA2I16),
"R_PPC_EMB_SDA2REL": reflect.ValueOf(elf.R_PPC_EMB_SDA2REL),
"R_PPC_EMB_SDAI16": reflect.ValueOf(elf.R_PPC_EMB_SDAI16),
"R_PPC_GLOB_DAT": reflect.ValueOf(elf.R_PPC_GLOB_DAT),
"R_PPC_GOT16": reflect.ValueOf(elf.R_PPC_GOT16),
"R_PPC_GOT16_HA": reflect.ValueOf(elf.R_PPC_GOT16_HA),
"R_PPC_GOT16_HI": reflect.ValueOf(elf.R_PPC_GOT16_HI),
"R_PPC_GOT16_LO": reflect.ValueOf(elf.R_PPC_GOT16_LO),
"R_PPC_GOT_TLSGD16": reflect.ValueOf(elf.R_PPC_GOT_TLSGD16),
"R_PPC_GOT_TLSGD16_HA": reflect.ValueOf(elf.R_PPC_GOT_TLSGD16_HA),
"R_PPC_GOT_TLSGD16_HI": reflect.ValueOf(elf.R_PPC_GOT_TLSGD16_HI),
"R_PPC_GOT_TLSGD16_LO": reflect.ValueOf(elf.R_PPC_GOT_TLSGD16_LO),
"R_PPC_GOT_TLSLD16": reflect.ValueOf(elf.R_PPC_GOT_TLSLD16),
"R_PPC_GOT_TLSLD16_HA": reflect.ValueOf(elf.R_PPC_GOT_TLSLD16_HA),
"R_PPC_GOT_TLSLD16_HI": reflect.ValueOf(elf.R_PPC_GOT_TLSLD16_HI),
"R_PPC_GOT_TLSLD16_LO": reflect.ValueOf(elf.R_PPC_GOT_TLSLD16_LO),
"R_PPC_GOT_TPREL16": reflect.ValueOf(elf.R_PPC_GOT_TPREL16),
"R_PPC_GOT_TPREL16_HA": reflect.ValueOf(elf.R_PPC_GOT_TPREL16_HA),
"R_PPC_GOT_TPREL16_HI": reflect.ValueOf(elf.R_PPC_GOT_TPREL16_HI),
"R_PPC_GOT_TPREL16_LO": reflect.ValueOf(elf.R_PPC_GOT_TPREL16_LO),
"R_PPC_JMP_SLOT": reflect.ValueOf(elf.R_PPC_JMP_SLOT),
"R_PPC_LOCAL24PC": reflect.ValueOf(elf.R_PPC_LOCAL24PC),
"R_PPC_NONE": reflect.ValueOf(elf.R_PPC_NONE),
"R_PPC_PLT16_HA": reflect.ValueOf(elf.R_PPC_PLT16_HA),
"R_PPC_PLT16_HI": reflect.ValueOf(elf.R_PPC_PLT16_HI),
"R_PPC_PLT16_LO": reflect.ValueOf(elf.R_PPC_PLT16_LO),
"R_PPC_PLT32": reflect.ValueOf(elf.R_PPC_PLT32),
"R_PPC_PLTREL24": reflect.ValueOf(elf.R_PPC_PLTREL24),
"R_PPC_PLTREL32": reflect.ValueOf(elf.R_PPC_PLTREL32),
"R_PPC_REL14": reflect.ValueOf(elf.R_PPC_REL14),
"R_PPC_REL14_BRNTAKEN": reflect.ValueOf(elf.R_PPC_REL14_BRNTAKEN),
"R_PPC_REL14_BRTAKEN": reflect.ValueOf(elf.R_PPC_REL14_BRTAKEN),
"R_PPC_REL24": reflect.ValueOf(elf.R_PPC_REL24),
"R_PPC_REL32": reflect.ValueOf(elf.R_PPC_REL32),
"R_PPC_RELATIVE": reflect.ValueOf(elf.R_PPC_RELATIVE),
"R_PPC_SDAREL16": reflect.ValueOf(elf.R_PPC_SDAREL16),
"R_PPC_SECTOFF": reflect.ValueOf(elf.R_PPC_SECTOFF),
"R_PPC_SECTOFF_HA": reflect.ValueOf(elf.R_PPC_SECTOFF_HA),
"R_PPC_SECTOFF_HI": reflect.ValueOf(elf.R_PPC_SECTOFF_HI),
"R_PPC_SECTOFF_LO": reflect.ValueOf(elf.R_PPC_SECTOFF_LO),
"R_PPC_TLS": reflect.ValueOf(elf.R_PPC_TLS),
"R_PPC_TPREL16": reflect.ValueOf(elf.R_PPC_TPREL16),
"R_PPC_TPREL16_HA": reflect.ValueOf(elf.R_PPC_TPREL16_HA),
"R_PPC_TPREL16_HI": reflect.ValueOf(elf.R_PPC_TPREL16_HI),
"R_PPC_TPREL16_LO": reflect.ValueOf(elf.R_PPC_TPREL16_LO),
"R_PPC_TPREL32": reflect.ValueOf(elf.R_PPC_TPREL32),
"R_PPC_UADDR16": reflect.ValueOf(elf.R_PPC_UADDR16),
"R_PPC_UADDR32": reflect.ValueOf(elf.R_PPC_UADDR32),
"R_RISCV_32": reflect.ValueOf(elf.R_RISCV_32),
"R_RISCV_32_PCREL": reflect.ValueOf(elf.R_RISCV_32_PCREL),
"R_RISCV_64": reflect.ValueOf(elf.R_RISCV_64),
"R_RISCV_ADD16": reflect.ValueOf(elf.R_RISCV_ADD16),
"R_RISCV_ADD32": reflect.ValueOf(elf.R_RISCV_ADD32),
"R_RISCV_ADD64": reflect.ValueOf(elf.R_RISCV_ADD64),
"R_RISCV_ADD8": reflect.ValueOf(elf.R_RISCV_ADD8),
"R_RISCV_ALIGN": reflect.ValueOf(elf.R_RISCV_ALIGN),
"R_RISCV_BRANCH": reflect.ValueOf(elf.R_RISCV_BRANCH),
"R_RISCV_CALL": reflect.ValueOf(elf.R_RISCV_CALL),
"R_RISCV_CALL_PLT": reflect.ValueOf(elf.R_RISCV_CALL_PLT),
"R_RISCV_COPY": reflect.ValueOf(elf.R_RISCV_COPY),
"R_RISCV_GNU_VTENTRY": reflect.ValueOf(elf.R_RISCV_GNU_VTENTRY),
"R_RISCV_GNU_VTINHERIT": reflect.ValueOf(elf.R_RISCV_GNU_VTINHERIT),
"R_RISCV_GOT_HI20": reflect.ValueOf(elf.R_RISCV_GOT_HI20),
"R_RISCV_GPREL_I": reflect.ValueOf(elf.R_RISCV_GPREL_I),
"R_RISCV_GPREL_S": reflect.ValueOf(elf.R_RISCV_GPREL_S),
"R_RISCV_HI20": reflect.ValueOf(elf.R_RISCV_HI20),
"R_RISCV_JAL": reflect.ValueOf(elf.R_RISCV_JAL),
"R_RISCV_JUMP_SLOT": reflect.ValueOf(elf.R_RISCV_JUMP_SLOT),
"R_RISCV_LO12_I": reflect.ValueOf(elf.R_RISCV_LO12_I),
"R_RISCV_LO12_S": reflect.ValueOf(elf.R_RISCV_LO12_S),
"R_RISCV_NONE": reflect.ValueOf(elf.R_RISCV_NONE),
"R_RISCV_PCREL_HI20": reflect.ValueOf(elf.R_RISCV_PCREL_HI20),
"R_RISCV_PCREL_LO12_I": reflect.ValueOf(elf.R_RISCV_PCREL_LO12_I),
"R_RISCV_PCREL_LO12_S": reflect.ValueOf(elf.R_RISCV_PCREL_LO12_S),
"R_RISCV_RELATIVE": reflect.ValueOf(elf.R_RISCV_RELATIVE),
"R_RISCV_RELAX": reflect.ValueOf(elf.R_RISCV_RELAX),
"R_RISCV_RVC_BRANCH": reflect.ValueOf(elf.R_RISCV_RVC_BRANCH),
"R_RISCV_RVC_JUMP": reflect.ValueOf(elf.R_RISCV_RVC_JUMP),
"R_RISCV_RVC_LUI": reflect.ValueOf(elf.R_RISCV_RVC_LUI),
"R_RISCV_SET16": reflect.ValueOf(elf.R_RISCV_SET16),
"R_RISCV_SET32": reflect.ValueOf(elf.R_RISCV_SET32),
"R_RISCV_SET6": reflect.ValueOf(elf.R_RISCV_SET6),
"R_RISCV_SET8": reflect.ValueOf(elf.R_RISCV_SET8),
"R_RISCV_SUB16": reflect.ValueOf(elf.R_RISCV_SUB16),
"R_RISCV_SUB32": reflect.ValueOf(elf.R_RISCV_SUB32),
"R_RISCV_SUB6": reflect.ValueOf(elf.R_RISCV_SUB6),
"R_RISCV_SUB64": reflect.ValueOf(elf.R_RISCV_SUB64),
"R_RISCV_SUB8": reflect.ValueOf(elf.R_RISCV_SUB8),
"R_RISCV_TLS_DTPMOD32": reflect.ValueOf(elf.R_RISCV_TLS_DTPMOD32),
"R_RISCV_TLS_DTPMOD64": reflect.ValueOf(elf.R_RISCV_TLS_DTPMOD64),
"R_RISCV_TLS_DTPREL32": reflect.ValueOf(elf.R_RISCV_TLS_DTPREL32),
"R_RISCV_TLS_DTPREL64": reflect.ValueOf(elf.R_RISCV_TLS_DTPREL64),
"R_RISCV_TLS_GD_HI20": reflect.ValueOf(elf.R_RISCV_TLS_GD_HI20),
"R_RISCV_TLS_GOT_HI20": reflect.ValueOf(elf.R_RISCV_TLS_GOT_HI20),
"R_RISCV_TLS_TPREL32": reflect.ValueOf(elf.R_RISCV_TLS_TPREL32),
"R_RISCV_TLS_TPREL64": reflect.ValueOf(elf.R_RISCV_TLS_TPREL64),
"R_RISCV_TPREL_ADD": reflect.ValueOf(elf.R_RISCV_TPREL_ADD),
"R_RISCV_TPREL_HI20": reflect.ValueOf(elf.R_RISCV_TPREL_HI20),
"R_RISCV_TPREL_I": reflect.ValueOf(elf.R_RISCV_TPREL_I),
"R_RISCV_TPREL_LO12_I": reflect.ValueOf(elf.R_RISCV_TPREL_LO12_I),
"R_RISCV_TPREL_LO12_S": reflect.ValueOf(elf.R_RISCV_TPREL_LO12_S),
"R_RISCV_TPREL_S": reflect.ValueOf(elf.R_RISCV_TPREL_S),
"R_SPARC_10": reflect.ValueOf(elf.R_SPARC_10),
"R_SPARC_11": reflect.ValueOf(elf.R_SPARC_11),
"R_SPARC_13": reflect.ValueOf(elf.R_SPARC_13),
"R_SPARC_16": reflect.ValueOf(elf.R_SPARC_16),
"R_SPARC_22": reflect.ValueOf(elf.R_SPARC_22),
"R_SPARC_32": reflect.ValueOf(elf.R_SPARC_32),
"R_SPARC_5": reflect.ValueOf(elf.R_SPARC_5),
"R_SPARC_6": reflect.ValueOf(elf.R_SPARC_6),
"R_SPARC_64": reflect.ValueOf(elf.R_SPARC_64),
"R_SPARC_7": reflect.ValueOf(elf.R_SPARC_7),
"R_SPARC_8": reflect.ValueOf(elf.R_SPARC_8),
"R_SPARC_COPY": reflect.ValueOf(elf.R_SPARC_COPY),
"R_SPARC_DISP16": reflect.ValueOf(elf.R_SPARC_DISP16),
"R_SPARC_DISP32": reflect.ValueOf(elf.R_SPARC_DISP32),
"R_SPARC_DISP64": reflect.ValueOf(elf.R_SPARC_DISP64),
"R_SPARC_DISP8": reflect.ValueOf(elf.R_SPARC_DISP8),
"R_SPARC_GLOB_DAT": reflect.ValueOf(elf.R_SPARC_GLOB_DAT),
"R_SPARC_GLOB_JMP": reflect.ValueOf(elf.R_SPARC_GLOB_JMP),
"R_SPARC_GOT10": reflect.ValueOf(elf.R_SPARC_GOT10),
"R_SPARC_GOT13": reflect.ValueOf(elf.R_SPARC_GOT13),
"R_SPARC_GOT22": reflect.ValueOf(elf.R_SPARC_GOT22),
"R_SPARC_H44": reflect.ValueOf(elf.R_SPARC_H44),
"R_SPARC_HH22": reflect.ValueOf(elf.R_SPARC_HH22),
"R_SPARC_HI22": reflect.ValueOf(elf.R_SPARC_HI22),
"R_SPARC_HIPLT22": reflect.ValueOf(elf.R_SPARC_HIPLT22),
"R_SPARC_HIX22": reflect.ValueOf(elf.R_SPARC_HIX22),
"R_SPARC_HM10": reflect.ValueOf(elf.R_SPARC_HM10),
"R_SPARC_JMP_SLOT": reflect.ValueOf(elf.R_SPARC_JMP_SLOT),
"R_SPARC_L44": reflect.ValueOf(elf.R_SPARC_L44),
"R_SPARC_LM22": reflect.ValueOf(elf.R_SPARC_LM22),
"R_SPARC_LO10": reflect.ValueOf(elf.R_SPARC_LO10),
"R_SPARC_LOPLT10": reflect.ValueOf(elf.R_SPARC_LOPLT10),
"R_SPARC_LOX10": reflect.ValueOf(elf.R_SPARC_LOX10),
"R_SPARC_M44": reflect.ValueOf(elf.R_SPARC_M44),
"R_SPARC_NONE": reflect.ValueOf(elf.R_SPARC_NONE),
"R_SPARC_OLO10": reflect.ValueOf(elf.R_SPARC_OLO10),
"R_SPARC_PC10": reflect.ValueOf(elf.R_SPARC_PC10),
"R_SPARC_PC22": reflect.ValueOf(elf.R_SPARC_PC22),
"R_SPARC_PCPLT10": reflect.ValueOf(elf.R_SPARC_PCPLT10),
"R_SPARC_PCPLT22": reflect.ValueOf(elf.R_SPARC_PCPLT22),
"R_SPARC_PCPLT32": reflect.ValueOf(elf.R_SPARC_PCPLT32),
"R_SPARC_PC_HH22": reflect.ValueOf(elf.R_SPARC_PC_HH22),
"R_SPARC_PC_HM10": reflect.ValueOf(elf.R_SPARC_PC_HM10),
"R_SPARC_PC_LM22": reflect.ValueOf(elf.R_SPARC_PC_LM22),
"R_SPARC_PLT32": reflect.ValueOf(elf.R_SPARC_PLT32),
"R_SPARC_PLT64": reflect.ValueOf(elf.R_SPARC_PLT64),
"R_SPARC_REGISTER": reflect.ValueOf(elf.R_SPARC_REGISTER),
"R_SPARC_RELATIVE": reflect.ValueOf(elf.R_SPARC_RELATIVE),
"R_SPARC_UA16": reflect.ValueOf(elf.R_SPARC_UA16),
"R_SPARC_UA32": reflect.ValueOf(elf.R_SPARC_UA32),
"R_SPARC_UA64": reflect.ValueOf(elf.R_SPARC_UA64),
"R_SPARC_WDISP16": reflect.ValueOf(elf.R_SPARC_WDISP16),
"R_SPARC_WDISP19": reflect.ValueOf(elf.R_SPARC_WDISP19),
"R_SPARC_WDISP22": reflect.ValueOf(elf.R_SPARC_WDISP22),
"R_SPARC_WDISP30": reflect.ValueOf(elf.R_SPARC_WDISP30),
"R_SPARC_WPLT30": reflect.ValueOf(elf.R_SPARC_WPLT30),
"R_SYM32": reflect.ValueOf(elf.R_SYM32),
"R_SYM64": reflect.ValueOf(elf.R_SYM64),
"R_TYPE32": reflect.ValueOf(elf.R_TYPE32),
"R_TYPE64": reflect.ValueOf(elf.R_TYPE64),
"R_X86_64_16": reflect.ValueOf(elf.R_X86_64_16),
"R_X86_64_32": reflect.ValueOf(elf.R_X86_64_32),
"R_X86_64_32S": reflect.ValueOf(elf.R_X86_64_32S),
"R_X86_64_64": reflect.ValueOf(elf.R_X86_64_64),
"R_X86_64_8": reflect.ValueOf(elf.R_X86_64_8),
"R_X86_64_COPY": reflect.ValueOf(elf.R_X86_64_COPY),
"R_X86_64_DTPMOD64": reflect.ValueOf(elf.R_X86_64_DTPMOD64),
"R_X86_64_DTPOFF32": reflect.ValueOf(elf.R_X86_64_DTPOFF32),
"R_X86_64_DTPOFF64": reflect.ValueOf(elf.R_X86_64_DTPOFF64),
"R_X86_64_GLOB_DAT": reflect.ValueOf(elf.R_X86_64_GLOB_DAT),
"R_X86_64_GOT32": reflect.ValueOf(elf.R_X86_64_GOT32),
"R_X86_64_GOT64": reflect.ValueOf(elf.R_X86_64_GOT64),
"R_X86_64_GOTOFF64": reflect.ValueOf(elf.R_X86_64_GOTOFF64),
"R_X86_64_GOTPC32": reflect.ValueOf(elf.R_X86_64_GOTPC32),
"R_X86_64_GOTPC32_TLSDESC": reflect.ValueOf(elf.R_X86_64_GOTPC32_TLSDESC),
"R_X86_64_GOTPC64": reflect.ValueOf(elf.R_X86_64_GOTPC64),
"R_X86_64_GOTPCREL": reflect.ValueOf(elf.R_X86_64_GOTPCREL),
"R_X86_64_GOTPCREL64": reflect.ValueOf(elf.R_X86_64_GOTPCREL64),
"R_X86_64_GOTPCRELX": reflect.ValueOf(elf.R_X86_64_GOTPCRELX),
"R_X86_64_GOTPLT64": reflect.ValueOf(elf.R_X86_64_GOTPLT64),
"R_X86_64_GOTTPOFF": reflect.ValueOf(elf.R_X86_64_GOTTPOFF),
"R_X86_64_IRELATIVE": reflect.ValueOf(elf.R_X86_64_IRELATIVE),
"R_X86_64_JMP_SLOT": reflect.ValueOf(elf.R_X86_64_JMP_SLOT),
"R_X86_64_NONE": reflect.ValueOf(elf.R_X86_64_NONE),
"R_X86_64_PC16": reflect.ValueOf(elf.R_X86_64_PC16),
"R_X86_64_PC32": reflect.ValueOf(elf.R_X86_64_PC32),
"R_X86_64_PC32_BND": reflect.ValueOf(elf.R_X86_64_PC32_BND),
"R_X86_64_PC64": reflect.ValueOf(elf.R_X86_64_PC64),
"R_X86_64_PC8": reflect.ValueOf(elf.R_X86_64_PC8),
"R_X86_64_PLT32": reflect.ValueOf(elf.R_X86_64_PLT32),
"R_X86_64_PLT32_BND": reflect.ValueOf(elf.R_X86_64_PLT32_BND),
"R_X86_64_PLTOFF64": reflect.ValueOf(elf.R_X86_64_PLTOFF64),
"R_X86_64_RELATIVE": reflect.ValueOf(elf.R_X86_64_RELATIVE),
"R_X86_64_RELATIVE64": reflect.ValueOf(elf.R_X86_64_RELATIVE64),
"R_X86_64_REX_GOTPCRELX": reflect.ValueOf(elf.R_X86_64_REX_GOTPCRELX),
"R_X86_64_SIZE32": reflect.ValueOf(elf.R_X86_64_SIZE32),
"R_X86_64_SIZE64": reflect.ValueOf(elf.R_X86_64_SIZE64),
"R_X86_64_TLSDESC": reflect.ValueOf(elf.R_X86_64_TLSDESC),
"R_X86_64_TLSDESC_CALL": reflect.ValueOf(elf.R_X86_64_TLSDESC_CALL),
"R_X86_64_TLSGD": reflect.ValueOf(elf.R_X86_64_TLSGD),
"R_X86_64_TLSLD": reflect.ValueOf(elf.R_X86_64_TLSLD),
"R_X86_64_TPOFF32": reflect.ValueOf(elf.R_X86_64_TPOFF32),
"R_X86_64_TPOFF64": reflect.ValueOf(elf.R_X86_64_TPOFF64),
"SHF_ALLOC": reflect.ValueOf(elf.SHF_ALLOC),
"SHF_COMPRESSED": reflect.ValueOf(elf.SHF_COMPRESSED),
"SHF_EXECINSTR": reflect.ValueOf(elf.SHF_EXECINSTR),
"SHF_GROUP": reflect.ValueOf(elf.SHF_GROUP),
"SHF_INFO_LINK": reflect.ValueOf(elf.SHF_INFO_LINK),
"SHF_LINK_ORDER": reflect.ValueOf(elf.SHF_LINK_ORDER),
"SHF_MASKOS": reflect.ValueOf(elf.SHF_MASKOS),
"SHF_MASKPROC": reflect.ValueOf(elf.SHF_MASKPROC),
"SHF_MERGE": reflect.ValueOf(elf.SHF_MERGE),
"SHF_OS_NONCONFORMING": reflect.ValueOf(elf.SHF_OS_NONCONFORMING),
"SHF_STRINGS": reflect.ValueOf(elf.SHF_STRINGS),
"SHF_TLS": reflect.ValueOf(elf.SHF_TLS),
"SHF_WRITE": reflect.ValueOf(elf.SHF_WRITE),
"SHN_ABS": reflect.ValueOf(elf.SHN_ABS),
"SHN_COMMON": reflect.ValueOf(elf.SHN_COMMON),
"SHN_HIOS": reflect.ValueOf(elf.SHN_HIOS),
"SHN_HIPROC": reflect.ValueOf(elf.SHN_HIPROC),
"SHN_HIRESERVE": reflect.ValueOf(elf.SHN_HIRESERVE),
"SHN_LOOS": reflect.ValueOf(elf.SHN_LOOS),
"SHN_LOPROC": reflect.ValueOf(elf.SHN_LOPROC),
"SHN_LORESERVE": reflect.ValueOf(elf.SHN_LORESERVE),
"SHN_UNDEF": reflect.ValueOf(elf.SHN_UNDEF),
"SHN_XINDEX": reflect.ValueOf(elf.SHN_XINDEX),
"SHT_DYNAMIC": reflect.ValueOf(elf.SHT_DYNAMIC),
"SHT_DYNSYM": reflect.ValueOf(elf.SHT_DYNSYM),
"SHT_FINI_ARRAY": reflect.ValueOf(elf.SHT_FINI_ARRAY),
"SHT_GNU_ATTRIBUTES": reflect.ValueOf(elf.SHT_GNU_ATTRIBUTES),
"SHT_GNU_HASH": reflect.ValueOf(elf.SHT_GNU_HASH),
"SHT_GNU_LIBLIST": reflect.ValueOf(elf.SHT_GNU_LIBLIST),
"SHT_GNU_VERDEF": reflect.ValueOf(elf.SHT_GNU_VERDEF),
"SHT_GNU_VERNEED": reflect.ValueOf(elf.SHT_GNU_VERNEED),
"SHT_GNU_VERSYM": reflect.ValueOf(elf.SHT_GNU_VERSYM),
"SHT_GROUP": reflect.ValueOf(elf.SHT_GROUP),
"SHT_HASH": reflect.ValueOf(elf.SHT_HASH),
"SHT_HIOS": reflect.ValueOf(elf.SHT_HIOS),
"SHT_HIPROC": reflect.ValueOf(elf.SHT_HIPROC),
"SHT_HIUSER": reflect.ValueOf(elf.SHT_HIUSER),
"SHT_INIT_ARRAY": reflect.ValueOf(elf.SHT_INIT_ARRAY),
"SHT_LOOS": reflect.ValueOf(elf.SHT_LOOS),
"SHT_LOPROC": reflect.ValueOf(elf.SHT_LOPROC),
"SHT_LOUSER": reflect.ValueOf(elf.SHT_LOUSER),
"SHT_MIPS_ABIFLAGS": reflect.ValueOf(elf.SHT_MIPS_ABIFLAGS),
"SHT_NOBITS": reflect.ValueOf(elf.SHT_NOBITS),
"SHT_NOTE": reflect.ValueOf(elf.SHT_NOTE),
"SHT_NULL": reflect.ValueOf(elf.SHT_NULL),
"SHT_PREINIT_ARRAY": reflect.ValueOf(elf.SHT_PREINIT_ARRAY),
"SHT_PROGBITS": reflect.ValueOf(elf.SHT_PROGBITS),
"SHT_REL": reflect.ValueOf(elf.SHT_REL),
"SHT_RELA": reflect.ValueOf(elf.SHT_RELA),
"SHT_SHLIB": reflect.ValueOf(elf.SHT_SHLIB),
"SHT_STRTAB": reflect.ValueOf(elf.SHT_STRTAB),
"SHT_SYMTAB": reflect.ValueOf(elf.SHT_SYMTAB),
"SHT_SYMTAB_SHNDX": reflect.ValueOf(elf.SHT_SYMTAB_SHNDX),
"STB_GLOBAL": reflect.ValueOf(elf.STB_GLOBAL),
"STB_HIOS": reflect.ValueOf(elf.STB_HIOS),
"STB_HIPROC": reflect.ValueOf(elf.STB_HIPROC),
"STB_LOCAL": reflect.ValueOf(elf.STB_LOCAL),
"STB_LOOS": reflect.ValueOf(elf.STB_LOOS),
"STB_LOPROC": reflect.ValueOf(elf.STB_LOPROC),
"STB_WEAK": reflect.ValueOf(elf.STB_WEAK),
"STT_COMMON": reflect.ValueOf(elf.STT_COMMON),
"STT_FILE": reflect.ValueOf(elf.STT_FILE),
"STT_FUNC": reflect.ValueOf(elf.STT_FUNC),
"STT_HIOS": reflect.ValueOf(elf.STT_HIOS),
"STT_HIPROC": reflect.ValueOf(elf.STT_HIPROC),
"STT_LOOS": reflect.ValueOf(elf.STT_LOOS),
"STT_LOPROC": reflect.ValueOf(elf.STT_LOPROC),
"STT_NOTYPE": reflect.ValueOf(elf.STT_NOTYPE),
"STT_OBJECT": reflect.ValueOf(elf.STT_OBJECT),
"STT_SECTION": reflect.ValueOf(elf.STT_SECTION),
"STT_TLS": reflect.ValueOf(elf.STT_TLS),
"STV_DEFAULT": reflect.ValueOf(elf.STV_DEFAULT),
"STV_HIDDEN": reflect.ValueOf(elf.STV_HIDDEN),
"STV_INTERNAL": reflect.ValueOf(elf.STV_INTERNAL),
"STV_PROTECTED": reflect.ValueOf(elf.STV_PROTECTED),
"ST_BIND": reflect.ValueOf(elf.ST_BIND),
"ST_INFO": reflect.ValueOf(elf.ST_INFO),
"ST_TYPE": reflect.ValueOf(elf.ST_TYPE),
"ST_VISIBILITY": reflect.ValueOf(elf.ST_VISIBILITY),
"Sym32Size": reflect.ValueOf(constant.MakeFromLiteral("16", token.INT, 0)),
"Sym64Size": reflect.ValueOf(constant.MakeFromLiteral("24", token.INT, 0)),
// type definitions
"Chdr32": reflect.ValueOf((*elf.Chdr32)(nil)),
"Chdr64": reflect.ValueOf((*elf.Chdr64)(nil)),
"Class": reflect.ValueOf((*elf.Class)(nil)),
"CompressionType": reflect.ValueOf((*elf.CompressionType)(nil)),
"Data": reflect.ValueOf((*elf.Data)(nil)),
"Dyn32": reflect.ValueOf((*elf.Dyn32)(nil)),
"Dyn64": reflect.ValueOf((*elf.Dyn64)(nil)),
"DynFlag": reflect.ValueOf((*elf.DynFlag)(nil)),
"DynFlag1": reflect.ValueOf((*elf.DynFlag1)(nil)),
"DynTag": reflect.ValueOf((*elf.DynTag)(nil)),
"File": reflect.ValueOf((*elf.File)(nil)),
"FileHeader": reflect.ValueOf((*elf.FileHeader)(nil)),
"FormatError": reflect.ValueOf((*elf.FormatError)(nil)),
"Header32": reflect.ValueOf((*elf.Header32)(nil)),
"Header64": reflect.ValueOf((*elf.Header64)(nil)),
"ImportedSymbol": reflect.ValueOf((*elf.ImportedSymbol)(nil)),
"Machine": reflect.ValueOf((*elf.Machine)(nil)),
"NType": reflect.ValueOf((*elf.NType)(nil)),
"OSABI": reflect.ValueOf((*elf.OSABI)(nil)),
"Prog": reflect.ValueOf((*elf.Prog)(nil)),
"Prog32": reflect.ValueOf((*elf.Prog32)(nil)),
"Prog64": reflect.ValueOf((*elf.Prog64)(nil)),
"ProgFlag": reflect.ValueOf((*elf.ProgFlag)(nil)),
"ProgHeader": reflect.ValueOf((*elf.ProgHeader)(nil)),
"ProgType": reflect.ValueOf((*elf.ProgType)(nil)),
"R_386": reflect.ValueOf((*elf.R_386)(nil)),
"R_390": reflect.ValueOf((*elf.R_390)(nil)),
"R_AARCH64": reflect.ValueOf((*elf.R_AARCH64)(nil)),
"R_ALPHA": reflect.ValueOf((*elf.R_ALPHA)(nil)),
"R_ARM": reflect.ValueOf((*elf.R_ARM)(nil)),
"R_LARCH": reflect.ValueOf((*elf.R_LARCH)(nil)),
"R_MIPS": reflect.ValueOf((*elf.R_MIPS)(nil)),
"R_PPC": reflect.ValueOf((*elf.R_PPC)(nil)),
"R_PPC64": reflect.ValueOf((*elf.R_PPC64)(nil)),
"R_RISCV": reflect.ValueOf((*elf.R_RISCV)(nil)),
"R_SPARC": reflect.ValueOf((*elf.R_SPARC)(nil)),
"R_X86_64": reflect.ValueOf((*elf.R_X86_64)(nil)),
"Rel32": reflect.ValueOf((*elf.Rel32)(nil)),
"Rel64": reflect.ValueOf((*elf.Rel64)(nil)),
"Rela32": reflect.ValueOf((*elf.Rela32)(nil)),
"Rela64": reflect.ValueOf((*elf.Rela64)(nil)),
"Section": reflect.ValueOf((*elf.Section)(nil)),
"Section32": reflect.ValueOf((*elf.Section32)(nil)),
"Section64": reflect.ValueOf((*elf.Section64)(nil)),
"SectionFlag": reflect.ValueOf((*elf.SectionFlag)(nil)),
"SectionHeader": reflect.ValueOf((*elf.SectionHeader)(nil)),
"SectionIndex": reflect.ValueOf((*elf.SectionIndex)(nil)),
"SectionType": reflect.ValueOf((*elf.SectionType)(nil)),
"Sym32": reflect.ValueOf((*elf.Sym32)(nil)),
"Sym64": reflect.ValueOf((*elf.Sym64)(nil)),
"SymBind": reflect.ValueOf((*elf.SymBind)(nil)),
"SymType": reflect.ValueOf((*elf.SymType)(nil)),
"SymVis": reflect.ValueOf((*elf.SymVis)(nil)),
"Symbol": reflect.ValueOf((*elf.Symbol)(nil)),
"Type": reflect.ValueOf((*elf.Type)(nil)),
"Version": reflect.ValueOf((*elf.Version)(nil)),
}
}
================================================
FILE: stdlib/go1_22_debug_gosym.go
================================================
// Code generated by 'yaegi extract debug/gosym'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"debug/gosym"
"reflect"
)
func init() {
Symbols["debug/gosym/gosym"] = map[string]reflect.Value{
// function, constant and variable definitions
"NewLineTable": reflect.ValueOf(gosym.NewLineTable),
"NewTable": reflect.ValueOf(gosym.NewTable),
// type definitions
"DecodingError": reflect.ValueOf((*gosym.DecodingError)(nil)),
"Func": reflect.ValueOf((*gosym.Func)(nil)),
"LineTable": reflect.ValueOf((*gosym.LineTable)(nil)),
"Obj": reflect.ValueOf((*gosym.Obj)(nil)),
"Sym": reflect.ValueOf((*gosym.Sym)(nil)),
"Table": reflect.ValueOf((*gosym.Table)(nil)),
"UnknownFileError": reflect.ValueOf((*gosym.UnknownFileError)(nil)),
"UnknownLineError": reflect.ValueOf((*gosym.UnknownLineError)(nil)),
}
}
================================================
FILE: stdlib/go1_22_debug_macho.go
================================================
// Code generated by 'yaegi extract debug/macho'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"debug/macho"
"reflect"
)
func init() {
Symbols["debug/macho/macho"] = map[string]reflect.Value{
// function, constant and variable definitions
"ARM64_RELOC_ADDEND": reflect.ValueOf(macho.ARM64_RELOC_ADDEND),
"ARM64_RELOC_BRANCH26": reflect.ValueOf(macho.ARM64_RELOC_BRANCH26),
"ARM64_RELOC_GOT_LOAD_PAGE21": reflect.ValueOf(macho.ARM64_RELOC_GOT_LOAD_PAGE21),
"ARM64_RELOC_GOT_LOAD_PAGEOFF12": reflect.ValueOf(macho.ARM64_RELOC_GOT_LOAD_PAGEOFF12),
"ARM64_RELOC_PAGE21": reflect.ValueOf(macho.ARM64_RELOC_PAGE21),
"ARM64_RELOC_PAGEOFF12": reflect.ValueOf(macho.ARM64_RELOC_PAGEOFF12),
"ARM64_RELOC_POINTER_TO_GOT": reflect.ValueOf(macho.ARM64_RELOC_POINTER_TO_GOT),
"ARM64_RELOC_SUBTRACTOR": reflect.ValueOf(macho.ARM64_RELOC_SUBTRACTOR),
"ARM64_RELOC_TLVP_LOAD_PAGE21": reflect.ValueOf(macho.ARM64_RELOC_TLVP_LOAD_PAGE21),
"ARM64_RELOC_TLVP_LOAD_PAGEOFF12": reflect.ValueOf(macho.ARM64_RELOC_TLVP_LOAD_PAGEOFF12),
"ARM64_RELOC_UNSIGNED": reflect.ValueOf(macho.ARM64_RELOC_UNSIGNED),
"ARM_RELOC_BR24": reflect.ValueOf(macho.ARM_RELOC_BR24),
"ARM_RELOC_HALF": reflect.ValueOf(macho.ARM_RELOC_HALF),
"ARM_RELOC_HALF_SECTDIFF": reflect.ValueOf(macho.ARM_RELOC_HALF_SECTDIFF),
"ARM_RELOC_LOCAL_SECTDIFF": reflect.ValueOf(macho.ARM_RELOC_LOCAL_SECTDIFF),
"ARM_RELOC_PAIR": reflect.ValueOf(macho.ARM_RELOC_PAIR),
"ARM_RELOC_PB_LA_PTR": reflect.ValueOf(macho.ARM_RELOC_PB_LA_PTR),
"ARM_RELOC_SECTDIFF": reflect.ValueOf(macho.ARM_RELOC_SECTDIFF),
"ARM_RELOC_VANILLA": reflect.ValueOf(macho.ARM_RELOC_VANILLA),
"ARM_THUMB_32BIT_BRANCH": reflect.ValueOf(macho.ARM_THUMB_32BIT_BRANCH),
"ARM_THUMB_RELOC_BR22": reflect.ValueOf(macho.ARM_THUMB_RELOC_BR22),
"Cpu386": reflect.ValueOf(macho.Cpu386),
"CpuAmd64": reflect.ValueOf(macho.CpuAmd64),
"CpuArm": reflect.ValueOf(macho.CpuArm),
"CpuArm64": reflect.ValueOf(macho.CpuArm64),
"CpuPpc": reflect.ValueOf(macho.CpuPpc),
"CpuPpc64": reflect.ValueOf(macho.CpuPpc64),
"ErrNotFat": reflect.ValueOf(&macho.ErrNotFat).Elem(),
"FlagAllModsBound": reflect.ValueOf(macho.FlagAllModsBound),
"FlagAllowStackExecution": reflect.ValueOf(macho.FlagAllowStackExecution),
"FlagAppExtensionSafe": reflect.ValueOf(macho.FlagAppExtensionSafe),
"FlagBindAtLoad": reflect.ValueOf(macho.FlagBindAtLoad),
"FlagBindsToWeak": reflect.ValueOf(macho.FlagBindsToWeak),
"FlagCanonical": reflect.ValueOf(macho.FlagCanonical),
"FlagDeadStrippableDylib": reflect.ValueOf(macho.FlagDeadStrippableDylib),
"FlagDyldLink": reflect.ValueOf(macho.FlagDyldLink),
"FlagForceFlat": reflect.ValueOf(macho.FlagForceFlat),
"FlagHasTLVDescriptors": reflect.ValueOf(macho.FlagHasTLVDescriptors),
"FlagIncrLink": reflect.ValueOf(macho.FlagIncrLink),
"FlagLazyInit": reflect.ValueOf(macho.FlagLazyInit),
"FlagNoFixPrebinding": reflect.ValueOf(macho.FlagNoFixPrebinding),
"FlagNoHeapExecution": reflect.ValueOf(macho.FlagNoHeapExecution),
"FlagNoMultiDefs": reflect.ValueOf(macho.FlagNoMultiDefs),
"FlagNoReexportedDylibs": reflect.ValueOf(macho.FlagNoReexportedDylibs),
"FlagNoUndefs": reflect.ValueOf(macho.FlagNoUndefs),
"FlagPIE": reflect.ValueOf(macho.FlagPIE),
"FlagPrebindable": reflect.ValueOf(macho.FlagPrebindable),
"FlagPrebound": reflect.ValueOf(macho.FlagPrebound),
"FlagRootSafe": reflect.ValueOf(macho.FlagRootSafe),
"FlagSetuidSafe": reflect.ValueOf(macho.FlagSetuidSafe),
"FlagSplitSegs": reflect.ValueOf(macho.FlagSplitSegs),
"FlagSubsectionsViaSymbols": reflect.ValueOf(macho.FlagSubsectionsViaSymbols),
"FlagTwoLevel": reflect.ValueOf(macho.FlagTwoLevel),
"FlagWeakDefines": reflect.ValueOf(macho.FlagWeakDefines),
"GENERIC_RELOC_LOCAL_SECTDIFF": reflect.ValueOf(macho.GENERIC_RELOC_LOCAL_SECTDIFF),
"GENERIC_RELOC_PAIR": reflect.ValueOf(macho.GENERIC_RELOC_PAIR),
"GENERIC_RELOC_PB_LA_PTR": reflect.ValueOf(macho.GENERIC_RELOC_PB_LA_PTR),
"GENERIC_RELOC_SECTDIFF": reflect.ValueOf(macho.GENERIC_RELOC_SECTDIFF),
"GENERIC_RELOC_TLV": reflect.ValueOf(macho.GENERIC_RELOC_TLV),
"GENERIC_RELOC_VANILLA": reflect.ValueOf(macho.GENERIC_RELOC_VANILLA),
"LoadCmdDylib": reflect.ValueOf(macho.LoadCmdDylib),
"LoadCmdDylinker": reflect.ValueOf(macho.LoadCmdDylinker),
"LoadCmdDysymtab": reflect.ValueOf(macho.LoadCmdDysymtab),
"LoadCmdRpath": reflect.ValueOf(macho.LoadCmdRpath),
"LoadCmdSegment": reflect.ValueOf(macho.LoadCmdSegment),
"LoadCmdSegment64": reflect.ValueOf(macho.LoadCmdSegment64),
"LoadCmdSymtab": reflect.ValueOf(macho.LoadCmdSymtab),
"LoadCmdThread": reflect.ValueOf(macho.LoadCmdThread),
"LoadCmdUnixThread": reflect.ValueOf(macho.LoadCmdUnixThread),
"Magic32": reflect.ValueOf(macho.Magic32),
"Magic64": reflect.ValueOf(macho.Magic64),
"MagicFat": reflect.ValueOf(macho.MagicFat),
"NewFatFile": reflect.ValueOf(macho.NewFatFile),
"NewFile": reflect.ValueOf(macho.NewFile),
"Open": reflect.ValueOf(macho.Open),
"OpenFat": reflect.ValueOf(macho.OpenFat),
"TypeBundle": reflect.ValueOf(macho.TypeBundle),
"TypeDylib": reflect.ValueOf(macho.TypeDylib),
"TypeExec": reflect.ValueOf(macho.TypeExec),
"TypeObj": reflect.ValueOf(macho.TypeObj),
"X86_64_RELOC_BRANCH": reflect.ValueOf(macho.X86_64_RELOC_BRANCH),
"X86_64_RELOC_GOT": reflect.ValueOf(macho.X86_64_RELOC_GOT),
"X86_64_RELOC_GOT_LOAD": reflect.ValueOf(macho.X86_64_RELOC_GOT_LOAD),
"X86_64_RELOC_SIGNED": reflect.ValueOf(macho.X86_64_RELOC_SIGNED),
"X86_64_RELOC_SIGNED_1": reflect.ValueOf(macho.X86_64_RELOC_SIGNED_1),
"X86_64_RELOC_SIGNED_2": reflect.ValueOf(macho.X86_64_RELOC_SIGNED_2),
"X86_64_RELOC_SIGNED_4": reflect.ValueOf(macho.X86_64_RELOC_SIGNED_4),
"X86_64_RELOC_SUBTRACTOR": reflect.ValueOf(macho.X86_64_RELOC_SUBTRACTOR),
"X86_64_RELOC_TLV": reflect.ValueOf(macho.X86_64_RELOC_TLV),
"X86_64_RELOC_UNSIGNED": reflect.ValueOf(macho.X86_64_RELOC_UNSIGNED),
// type definitions
"Cpu": reflect.ValueOf((*macho.Cpu)(nil)),
"Dylib": reflect.ValueOf((*macho.Dylib)(nil)),
"DylibCmd": reflect.ValueOf((*macho.DylibCmd)(nil)),
"Dysymtab": reflect.ValueOf((*macho.Dysymtab)(nil)),
"DysymtabCmd": reflect.ValueOf((*macho.DysymtabCmd)(nil)),
"FatArch": reflect.ValueOf((*macho.FatArch)(nil)),
"FatArchHeader": reflect.ValueOf((*macho.FatArchHeader)(nil)),
"FatFile": reflect.ValueOf((*macho.FatFile)(nil)),
"File": reflect.ValueOf((*macho.File)(nil)),
"FileHeader": reflect.ValueOf((*macho.FileHeader)(nil)),
"FormatError": reflect.ValueOf((*macho.FormatError)(nil)),
"Load": reflect.ValueOf((*macho.Load)(nil)),
"LoadBytes": reflect.ValueOf((*macho.LoadBytes)(nil)),
"LoadCmd": reflect.ValueOf((*macho.LoadCmd)(nil)),
"Nlist32": reflect.ValueOf((*macho.Nlist32)(nil)),
"Nlist64": reflect.ValueOf((*macho.Nlist64)(nil)),
"Regs386": reflect.ValueOf((*macho.Regs386)(nil)),
"RegsAMD64": reflect.ValueOf((*macho.RegsAMD64)(nil)),
"Reloc": reflect.ValueOf((*macho.Reloc)(nil)),
"RelocTypeARM": reflect.ValueOf((*macho.RelocTypeARM)(nil)),
"RelocTypeARM64": reflect.ValueOf((*macho.RelocTypeARM64)(nil)),
"RelocTypeGeneric": reflect.ValueOf((*macho.RelocTypeGeneric)(nil)),
"RelocTypeX86_64": reflect.ValueOf((*macho.RelocTypeX86_64)(nil)),
"Rpath": reflect.ValueOf((*macho.Rpath)(nil)),
"RpathCmd": reflect.ValueOf((*macho.RpathCmd)(nil)),
"Section": reflect.ValueOf((*macho.Section)(nil)),
"Section32": reflect.ValueOf((*macho.Section32)(nil)),
"Section64": reflect.ValueOf((*macho.Section64)(nil)),
"SectionHeader": reflect.ValueOf((*macho.SectionHeader)(nil)),
"Segment": reflect.ValueOf((*macho.Segment)(nil)),
"Segment32": reflect.ValueOf((*macho.Segment32)(nil)),
"Segment64": reflect.ValueOf((*macho.Segment64)(nil)),
"SegmentHeader": reflect.ValueOf((*macho.SegmentHeader)(nil)),
"Symbol": reflect.ValueOf((*macho.Symbol)(nil)),
"Symtab": reflect.ValueOf((*macho.Symtab)(nil)),
"SymtabCmd": reflect.ValueOf((*macho.SymtabCmd)(nil)),
"Thread": reflect.ValueOf((*macho.Thread)(nil)),
"Type": reflect.ValueOf((*macho.Type)(nil)),
// interface wrapper definitions
"_Load": reflect.ValueOf((*_debug_macho_Load)(nil)),
}
}
// _debug_macho_Load is an interface wrapper for Load type
type _debug_macho_Load struct {
IValue interface{}
WRaw func() []byte
}
func (W _debug_macho_Load) Raw() []byte { return W.WRaw() }
================================================
FILE: stdlib/go1_22_debug_pe.go
================================================
// Code generated by 'yaegi extract debug/pe'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"debug/pe"
"go/constant"
"go/token"
"reflect"
)
func init() {
Symbols["debug/pe/pe"] = map[string]reflect.Value{
// function, constant and variable definitions
"COFFSymbolSize": reflect.ValueOf(constant.MakeFromLiteral("18", token.INT, 0)),
"IMAGE_COMDAT_SELECT_ANY": reflect.ValueOf(constant.MakeFromLiteral("2", token.INT, 0)),
"IMAGE_COMDAT_SELECT_ASSOCIATIVE": reflect.ValueOf(constant.MakeFromLiteral("5", token.INT, 0)),
"IMAGE_COMDAT_SELECT_EXACT_MATCH": reflect.ValueOf(constant.MakeFromLiteral("4", token.INT, 0)),
"IMAGE_COMDAT_SELECT_LARGEST": reflect.ValueOf(constant.MakeFromLiteral("6", token.INT, 0)),
"IMAGE_COMDAT_SELECT_NODUPLICATES": reflect.ValueOf(constant.MakeFromLiteral("1", token.INT, 0)),
"IMAGE_COMDAT_SELECT_SAME_SIZE": reflect.ValueOf(constant.MakeFromLiteral("3", token.INT, 0)),
"IMAGE_DIRECTORY_ENTRY_ARCHITECTURE": reflect.ValueOf(constant.MakeFromLiteral("7", token.INT, 0)),
"IMAGE_DIRECTORY_ENTRY_BASERELOC": reflect.ValueOf(constant.MakeFromLiteral("5", token.INT, 0)),
"IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT": reflect.ValueOf(constant.MakeFromLiteral("11", token.INT, 0)),
"IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR": reflect.ValueOf(constant.MakeFromLiteral("14", token.INT, 0)),
"IMAGE_DIRECTORY_ENTRY_DEBUG": reflect.ValueOf(constant.MakeFromLiteral("6", token.INT, 0)),
"IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT": reflect.ValueOf(constant.MakeFromLiteral("13", token.INT, 0)),
"IMAGE_DIRECTORY_ENTRY_EXCEPTION": reflect.ValueOf(constant.MakeFromLiteral("3", token.INT, 0)),
"IMAGE_DIRECTORY_ENTRY_EXPORT": reflect.ValueOf(constant.MakeFromLiteral("0", token.INT, 0)),
"IMAGE_DIRECTORY_ENTRY_GLOBALPTR": reflect.ValueOf(constant.MakeFromLiteral("8", token.INT, 0)),
"IMAGE_DIRECTORY_ENTRY_IAT": reflect.ValueOf(constant.MakeFromLiteral("12", token.INT, 0)),
"IMAGE_DIRECTORY_ENTRY_IMPORT": reflect.ValueOf(constant.MakeFromLiteral("1", token.INT, 0)),
"IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG": reflect.ValueOf(constant.MakeFromLiteral("10", token.INT, 0)),
"IMAGE_DIRECTORY_ENTRY_RESOURCE": reflect.ValueOf(constant.MakeFromLiteral("2", token.INT, 0)),
"IMAGE_DIRECTORY_ENTRY_SECURITY": reflect.ValueOf(constant.MakeFromLiteral("4", token.INT, 0)),
"IMAGE_DIRECTORY_ENTRY_TLS": reflect.ValueOf(constant.MakeFromLiteral("9", token.INT, 0)),
"IMAGE_DLLCHARACTERISTICS_APPCONTAINER": reflect.ValueOf(constant.MakeFromLiteral("4096", token.INT, 0)),
"IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE": reflect.ValueOf(constant.MakeFromLiteral("64", token.INT, 0)),
"IMAGE_DLLCHARACTERISTICS_FORCE_INTEGRITY": reflect.ValueOf(constant.MakeFromLiteral("128", token.INT, 0)),
"IMAGE_DLLCHARACTERISTICS_GUARD_CF": reflect.ValueOf(constant.MakeFromLiteral("16384", token.INT, 0)),
"IMAGE_DLLCHARACTERISTICS_HIGH_ENTROPY_VA": reflect.ValueOf(constant.MakeFromLiteral("32", token.INT, 0)),
"IMAGE_DLLCHARACTERISTICS_NO_BIND": reflect.ValueOf(constant.MakeFromLiteral("2048", token.INT, 0)),
"IMAGE_DLLCHARACTERISTICS_NO_ISOLATION": reflect.ValueOf(constant.MakeFromLiteral("512", token.INT, 0)),
"IMAGE_DLLCHARACTERISTICS_NO_SEH": reflect.ValueOf(constant.MakeFromLiteral("1024", token.INT, 0)),
"IMAGE_DLLCHARACTERISTICS_NX_COMPAT": reflect.ValueOf(constant.MakeFromLiteral("256", token.INT, 0)),
"IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE": reflect.ValueOf(constant.MakeFromLiteral("32768", token.INT, 0)),
"IMAGE_DLLCHARACTERISTICS_WDM_DRIVER": reflect.ValueOf(constant.MakeFromLiteral("8192", token.INT, 0)),
"IMAGE_FILE_32BIT_MACHINE": reflect.ValueOf(constant.MakeFromLiteral("256", token.INT, 0)),
"IMAGE_FILE_AGGRESIVE_WS_TRIM": reflect.ValueOf(constant.MakeFromLiteral("16", token.INT, 0)),
"IMAGE_FILE_BYTES_REVERSED_HI": reflect.ValueOf(constant.MakeFromLiteral("32768", token.INT, 0)),
"IMAGE_FILE_BYTES_REVERSED_LO": reflect.ValueOf(constant.MakeFromLiteral("128", token.INT, 0)),
"IMAGE_FILE_DEBUG_STRIPPED": reflect.ValueOf(constant.MakeFromLiteral("512", token.INT, 0)),
"IMAGE_FILE_DLL": reflect.ValueOf(constant.MakeFromLiteral("8192", token.INT, 0)),
"IMAGE_FILE_EXECUTABLE_IMAGE": reflect.ValueOf(constant.MakeFromLiteral("2", token.INT, 0)),
"IMAGE_FILE_LARGE_ADDRESS_AWARE": reflect.ValueOf(constant.MakeFromLiteral("32", token.INT, 0)),
"IMAGE_FILE_LINE_NUMS_STRIPPED": reflect.ValueOf(constant.MakeFromLiteral("4", token.INT, 0)),
"IMAGE_FILE_LOCAL_SYMS_STRIPPED": reflect.ValueOf(constant.MakeFromLiteral("8", token.INT, 0)),
"IMAGE_FILE_MACHINE_AM33": reflect.ValueOf(constant.MakeFromLiteral("467", token.INT, 0)),
"IMAGE_FILE_MACHINE_AMD64": reflect.ValueOf(constant.MakeFromLiteral("34404", token.INT, 0)),
"IMAGE_FILE_MACHINE_ARM": reflect.ValueOf(constant.MakeFromLiteral("448", token.INT, 0)),
"IMAGE_FILE_MACHINE_ARM64": reflect.ValueOf(constant.MakeFromLiteral("43620", token.INT, 0)),
"IMAGE_FILE_MACHINE_ARMNT": reflect.ValueOf(constant.MakeFromLiteral("452", token.INT, 0)),
"IMAGE_FILE_MACHINE_EBC": reflect.ValueOf(constant.MakeFromLiteral("3772", token.INT, 0)),
"IMAGE_FILE_MACHINE_I386": reflect.ValueOf(constant.MakeFromLiteral("332", token.INT, 0)),
"IMAGE_FILE_MACHINE_IA64": reflect.ValueOf(constant.MakeFromLiteral("512", token.INT, 0)),
"IMAGE_FILE_MACHINE_LOONGARCH32": reflect.ValueOf(constant.MakeFromLiteral("25138", token.INT, 0)),
"IMAGE_FILE_MACHINE_LOONGARCH64": reflect.ValueOf(constant.MakeFromLiteral("25188", token.INT, 0)),
"IMAGE_FILE_MACHINE_M32R": reflect.ValueOf(constant.MakeFromLiteral("36929", token.INT, 0)),
"IMAGE_FILE_MACHINE_MIPS16": reflect.ValueOf(constant.MakeFromLiteral("614", token.INT, 0)),
"IMAGE_FILE_MACHINE_MIPSFPU": reflect.ValueOf(constant.MakeFromLiteral("870", token.INT, 0)),
"IMAGE_FILE_MACHINE_MIPSFPU16": reflect.ValueOf(constant.MakeFromLiteral("1126", token.INT, 0)),
"IMAGE_FILE_MACHINE_POWERPC": reflect.ValueOf(constant.MakeFromLiteral("496", token.INT, 0)),
"IMAGE_FILE_MACHINE_POWERPCFP": reflect.ValueOf(constant.MakeFromLiteral("497", token.INT, 0)),
"IMAGE_FILE_MACHINE_R4000": reflect.ValueOf(constant.MakeFromLiteral("358", token.INT, 0)),
"IMAGE_FILE_MACHINE_RISCV128": reflect.ValueOf(constant.MakeFromLiteral("20776", token.INT, 0)),
"IMAGE_FILE_MACHINE_RISCV32": reflect.ValueOf(constant.MakeFromLiteral("20530", token.INT, 0)),
"IMAGE_FILE_MACHINE_RISCV64": reflect.ValueOf(constant.MakeFromLiteral("20580", token.INT, 0)),
"IMAGE_FILE_MACHINE_SH3": reflect.ValueOf(constant.MakeFromLiteral("418", token.INT, 0)),
"IMAGE_FILE_MACHINE_SH3DSP": reflect.ValueOf(constant.MakeFromLiteral("419", token.INT, 0)),
"IMAGE_FILE_MACHINE_SH4": reflect.ValueOf(constant.MakeFromLiteral("422", token.INT, 0)),
"IMAGE_FILE_MACHINE_SH5": reflect.ValueOf(constant.MakeFromLiteral("424", token.INT, 0)),
"IMAGE_FILE_MACHINE_THUMB": reflect.ValueOf(constant.MakeFromLiteral("450", token.INT, 0)),
"IMAGE_FILE_MACHINE_UNKNOWN": reflect.ValueOf(constant.MakeFromLiteral("0", token.INT, 0)),
"IMAGE_FILE_MACHINE_WCEMIPSV2": reflect.ValueOf(constant.MakeFromLiteral("361", token.INT, 0)),
"IMAGE_FILE_NET_RUN_FROM_SWAP": reflect.ValueOf(constant.MakeFromLiteral("2048", token.INT, 0)),
"IMAGE_FILE_RELOCS_STRIPPED": reflect.ValueOf(constant.MakeFromLiteral("1", token.INT, 0)),
"IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP": reflect.ValueOf(constant.MakeFromLiteral("1024", token.INT, 0)),
"IMAGE_FILE_SYSTEM": reflect.ValueOf(constant.MakeFromLiteral("4096", token.INT, 0)),
"IMAGE_FILE_UP_SYSTEM_ONLY": reflect.ValueOf(constant.MakeFromLiteral("16384", token.INT, 0)),
"IMAGE_SCN_CNT_CODE": reflect.ValueOf(constant.MakeFromLiteral("32", token.INT, 0)),
"IMAGE_SCN_CNT_INITIALIZED_DATA": reflect.ValueOf(constant.MakeFromLiteral("64", token.INT, 0)),
"IMAGE_SCN_CNT_UNINITIALIZED_DATA": reflect.ValueOf(constant.MakeFromLiteral("128", token.INT, 0)),
"IMAGE_SCN_LNK_COMDAT": reflect.ValueOf(constant.MakeFromLiteral("4096", token.INT, 0)),
"IMAGE_SCN_MEM_DISCARDABLE": reflect.ValueOf(constant.MakeFromLiteral("33554432", token.INT, 0)),
"IMAGE_SCN_MEM_EXECUTE": reflect.ValueOf(constant.MakeFromLiteral("536870912", token.INT, 0)),
"IMAGE_SCN_MEM_READ": reflect.ValueOf(constant.MakeFromLiteral("1073741824", token.INT, 0)),
"IMAGE_SCN_MEM_WRITE": reflect.ValueOf(constant.MakeFromLiteral("2147483648", token.INT, 0)),
"IMAGE_SUBSYSTEM_EFI_APPLICATION": reflect.ValueOf(constant.MakeFromLiteral("10", token.INT, 0)),
"IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER": reflect.ValueOf(constant.MakeFromLiteral("11", token.INT, 0)),
"IMAGE_SUBSYSTEM_EFI_ROM": reflect.ValueOf(constant.MakeFromLiteral("13", token.INT, 0)),
"IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER": reflect.ValueOf(constant.MakeFromLiteral("12", token.INT, 0)),
"IMAGE_SUBSYSTEM_NATIVE": reflect.ValueOf(constant.MakeFromLiteral("1", token.INT, 0)),
"IMAGE_SUBSYSTEM_NATIVE_WINDOWS": reflect.ValueOf(constant.MakeFromLiteral("8", token.INT, 0)),
"IMAGE_SUBSYSTEM_OS2_CUI": reflect.ValueOf(constant.MakeFromLiteral("5", token.INT, 0)),
"IMAGE_SUBSYSTEM_POSIX_CUI": reflect.ValueOf(constant.MakeFromLiteral("7", token.INT, 0)),
"IMAGE_SUBSYSTEM_UNKNOWN": reflect.ValueOf(constant.MakeFromLiteral("0", token.INT, 0)),
"IMAGE_SUBSYSTEM_WINDOWS_BOOT_APPLICATION": reflect.ValueOf(constant.MakeFromLiteral("16", token.INT, 0)),
"IMAGE_SUBSYSTEM_WINDOWS_CE_GUI": reflect.ValueOf(constant.MakeFromLiteral("9", token.INT, 0)),
"IMAGE_SUBSYSTEM_WINDOWS_CUI": reflect.ValueOf(constant.MakeFromLiteral("3", token.INT, 0)),
"IMAGE_SUBSYSTEM_WINDOWS_GUI": reflect.ValueOf(constant.MakeFromLiteral("2", token.INT, 0)),
"IMAGE_SUBSYSTEM_XBOX": reflect.ValueOf(constant.MakeFromLiteral("14", token.INT, 0)),
"NewFile": reflect.ValueOf(pe.NewFile),
"Open": reflect.ValueOf(pe.Open),
// type definitions
"COFFSymbol": reflect.ValueOf((*pe.COFFSymbol)(nil)),
"COFFSymbolAuxFormat5": reflect.ValueOf((*pe.COFFSymbolAuxFormat5)(nil)),
"DataDirectory": reflect.ValueOf((*pe.DataDirectory)(nil)),
"File": reflect.ValueOf((*pe.File)(nil)),
"FileHeader": reflect.ValueOf((*pe.FileHeader)(nil)),
"FormatError": reflect.ValueOf((*pe.FormatError)(nil)),
"ImportDirectory": reflect.ValueOf((*pe.ImportDirectory)(nil)),
"OptionalHeader32": reflect.ValueOf((*pe.OptionalHeader32)(nil)),
"OptionalHeader64": reflect.ValueOf((*pe.OptionalHeader64)(nil)),
"Reloc": reflect.ValueOf((*pe.Reloc)(nil)),
"Section": reflect.ValueOf((*pe.Section)(nil)),
"SectionHeader": reflect.ValueOf((*pe.SectionHeader)(nil)),
"SectionHeader32": reflect.ValueOf((*pe.SectionHeader32)(nil)),
"StringTable": reflect.ValueOf((*pe.StringTable)(nil)),
"Symbol": reflect.ValueOf((*pe.Symbol)(nil)),
}
}
================================================
FILE: stdlib/go1_22_debug_plan9obj.go
================================================
// Code generated by 'yaegi extract debug/plan9obj'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"debug/plan9obj"
"go/constant"
"go/token"
"reflect"
)
func init() {
Symbols["debug/plan9obj/plan9obj"] = map[string]reflect.Value{
// function, constant and variable definitions
"ErrNoSymbols": reflect.ValueOf(&plan9obj.ErrNoSymbols).Elem(),
"Magic386": reflect.ValueOf(constant.MakeFromLiteral("491", token.INT, 0)),
"Magic64": reflect.ValueOf(constant.MakeFromLiteral("32768", token.INT, 0)),
"MagicAMD64": reflect.ValueOf(constant.MakeFromLiteral("35479", token.INT, 0)),
"MagicARM": reflect.ValueOf(constant.MakeFromLiteral("1607", token.INT, 0)),
"NewFile": reflect.ValueOf(plan9obj.NewFile),
"Open": reflect.ValueOf(plan9obj.Open),
// type definitions
"File": reflect.ValueOf((*plan9obj.File)(nil)),
"FileHeader": reflect.ValueOf((*plan9obj.FileHeader)(nil)),
"Section": reflect.ValueOf((*plan9obj.Section)(nil)),
"SectionHeader": reflect.ValueOf((*plan9obj.SectionHeader)(nil)),
"Sym": reflect.ValueOf((*plan9obj.Sym)(nil)),
}
}
================================================
FILE: stdlib/go1_22_encoding.go
================================================
// Code generated by 'yaegi extract encoding'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"encoding"
"reflect"
)
func init() {
Symbols["encoding/encoding"] = map[string]reflect.Value{
// type definitions
"BinaryMarshaler": reflect.ValueOf((*encoding.BinaryMarshaler)(nil)),
"BinaryUnmarshaler": reflect.ValueOf((*encoding.BinaryUnmarshaler)(nil)),
"TextMarshaler": reflect.ValueOf((*encoding.TextMarshaler)(nil)),
"TextUnmarshaler": reflect.ValueOf((*encoding.TextUnmarshaler)(nil)),
// interface wrapper definitions
"_BinaryMarshaler": reflect.ValueOf((*_encoding_BinaryMarshaler)(nil)),
"_BinaryUnmarshaler": reflect.ValueOf((*_encoding_BinaryUnmarshaler)(nil)),
"_TextMarshaler": reflect.ValueOf((*_encoding_TextMarshaler)(nil)),
"_TextUnmarshaler": reflect.ValueOf((*_encoding_TextUnmarshaler)(nil)),
}
}
// _encoding_BinaryMarshaler is an interface wrapper for BinaryMarshaler type
type _encoding_BinaryMarshaler struct {
IValue interface{}
WMarshalBinary func() (data []byte, err error)
}
func (W _encoding_BinaryMarshaler) MarshalBinary() (data []byte, err error) {
return W.WMarshalBinary()
}
// _encoding_BinaryUnmarshaler is an interface wrapper for BinaryUnmarshaler type
type _encoding_BinaryUnmarshaler struct {
IValue interface{}
WUnmarshalBinary func(data []byte) error
}
func (W _encoding_BinaryUnmarshaler) UnmarshalBinary(data []byte) error {
return W.WUnmarshalBinary(data)
}
// _encoding_TextMarshaler is an interface wrapper for TextMarshaler type
type _encoding_TextMarshaler struct {
IValue interface{}
WMarshalText func() (text []byte, err error)
}
func (W _encoding_TextMarshaler) MarshalText() (text []byte, err error) { return W.WMarshalText() }
// _encoding_TextUnmarshaler is an interface wrapper for TextUnmarshaler type
type _encoding_TextUnmarshaler struct {
IValue interface{}
WUnmarshalText func(text []byte) error
}
func (W _encoding_TextUnmarshaler) UnmarshalText(text []byte) error { return W.WUnmarshalText(text) }
================================================
FILE: stdlib/go1_22_encoding_ascii85.go
================================================
// Code generated by 'yaegi extract encoding/ascii85'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"encoding/ascii85"
"reflect"
)
func init() {
Symbols["encoding/ascii85/ascii85"] = map[string]reflect.Value{
// function, constant and variable definitions
"Decode": reflect.ValueOf(ascii85.Decode),
"Encode": reflect.ValueOf(ascii85.Encode),
"MaxEncodedLen": reflect.ValueOf(ascii85.MaxEncodedLen),
"NewDecoder": reflect.ValueOf(ascii85.NewDecoder),
"NewEncoder": reflect.ValueOf(ascii85.NewEncoder),
// type definitions
"CorruptInputError": reflect.ValueOf((*ascii85.CorruptInputError)(nil)),
}
}
================================================
FILE: stdlib/go1_22_encoding_asn1.go
================================================
// Code generated by 'yaegi extract encoding/asn1'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"encoding/asn1"
"go/constant"
"go/token"
"reflect"
)
func init() {
Symbols["encoding/asn1/asn1"] = map[string]reflect.Value{
// function, constant and variable definitions
"ClassApplication": reflect.ValueOf(constant.MakeFromLiteral("1", token.INT, 0)),
"ClassContextSpecific": reflect.ValueOf(constant.MakeFromLiteral("2", token.INT, 0)),
"ClassPrivate": reflect.ValueOf(constant.MakeFromLiteral("3", token.INT, 0)),
"ClassUniversal": reflect.ValueOf(constant.MakeFromLiteral("0", token.INT, 0)),
"Marshal": reflect.ValueOf(asn1.Marshal),
"MarshalWithParams": reflect.ValueOf(asn1.MarshalWithParams),
"NullBytes": reflect.ValueOf(&asn1.NullBytes).Elem(),
"NullRawValue": reflect.ValueOf(&asn1.NullRawValue).Elem(),
"TagBMPString": reflect.ValueOf(constant.MakeFromLiteral("30", token.INT, 0)),
"TagBitString": reflect.ValueOf(constant.MakeFromLiteral("3", token.INT, 0)),
"TagBoolean": reflect.ValueOf(constant.MakeFromLiteral("1", token.INT, 0)),
"TagEnum": reflect.ValueOf(constant.MakeFromLiteral("10", token.INT, 0)),
"TagGeneralString": reflect.ValueOf(constant.MakeFromLiteral("27", token.INT, 0)),
"TagGeneralizedTime": reflect.ValueOf(constant.MakeFromLiteral("24", token.INT, 0)),
"TagIA5String": reflect.ValueOf(constant.MakeFromLiteral("22", token.INT, 0)),
"TagInteger": reflect.ValueOf(constant.MakeFromLiteral("2", token.INT, 0)),
"TagNull": reflect.ValueOf(constant.MakeFromLiteral("5", token.INT, 0)),
"TagNumericString": reflect.ValueOf(constant.MakeFromLiteral("18", token.INT, 0)),
"TagOID": reflect.ValueOf(constant.MakeFromLiteral("6", token.INT, 0)),
"TagOctetString": reflect.ValueOf(constant.MakeFromLiteral("4", token.INT, 0)),
"TagPrintableString": reflect.ValueOf(constant.MakeFromLiteral("19", token.INT, 0)),
"TagSequence": reflect.ValueOf(constant.MakeFromLiteral("16", token.INT, 0)),
"TagSet": reflect.ValueOf(constant.MakeFromLiteral("17", token.INT, 0)),
"TagT61String": reflect.ValueOf(constant.MakeFromLiteral("20", token.INT, 0)),
"TagUTCTime": reflect.ValueOf(constant.MakeFromLiteral("23", token.INT, 0)),
"TagUTF8String": reflect.ValueOf(constant.MakeFromLiteral("12", token.INT, 0)),
"Unmarshal": reflect.ValueOf(asn1.Unmarshal),
"UnmarshalWithParams": reflect.ValueOf(asn1.UnmarshalWithParams),
// type definitions
"BitString": reflect.ValueOf((*asn1.BitString)(nil)),
"Enumerated": reflect.ValueOf((*asn1.Enumerated)(nil)),
"Flag": reflect.ValueOf((*asn1.Flag)(nil)),
"ObjectIdentifier": reflect.ValueOf((*asn1.ObjectIdentifier)(nil)),
"RawContent": reflect.ValueOf((*asn1.RawContent)(nil)),
"RawValue": reflect.ValueOf((*asn1.RawValue)(nil)),
"StructuralError": reflect.ValueOf((*asn1.StructuralError)(nil)),
"SyntaxError": reflect.ValueOf((*asn1.SyntaxError)(nil)),
}
}
================================================
FILE: stdlib/go1_22_encoding_base32.go
================================================
// Code generated by 'yaegi extract encoding/base32'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"encoding/base32"
"reflect"
)
func init() {
Symbols["encoding/base32/base32"] = map[string]reflect.Value{
// function, constant and variable definitions
"HexEncoding": reflect.ValueOf(&base32.HexEncoding).Elem(),
"NewDecoder": reflect.ValueOf(base32.NewDecoder),
"NewEncoder": reflect.ValueOf(base32.NewEncoder),
"NewEncoding": reflect.ValueOf(base32.NewEncoding),
"NoPadding": reflect.ValueOf(base32.NoPadding),
"StdEncoding": reflect.ValueOf(&base32.StdEncoding).Elem(),
"StdPadding": reflect.ValueOf(base32.StdPadding),
// type definitions
"CorruptInputError": reflect.ValueOf((*base32.CorruptInputError)(nil)),
"Encoding": reflect.ValueOf((*base32.Encoding)(nil)),
}
}
================================================
FILE: stdlib/go1_22_encoding_base64.go
================================================
// Code generated by 'yaegi extract encoding/base64'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"encoding/base64"
"reflect"
)
func init() {
Symbols["encoding/base64/base64"] = map[string]reflect.Value{
// function, constant and variable definitions
"NewDecoder": reflect.ValueOf(base64.NewDecoder),
"NewEncoder": reflect.ValueOf(base64.NewEncoder),
"NewEncoding": reflect.ValueOf(base64.NewEncoding),
"NoPadding": reflect.ValueOf(base64.NoPadding),
"RawStdEncoding": reflect.ValueOf(&base64.RawStdEncoding).Elem(),
"RawURLEncoding": reflect.ValueOf(&base64.RawURLEncoding).Elem(),
"StdEncoding": reflect.ValueOf(&base64.StdEncoding).Elem(),
"StdPadding": reflect.ValueOf(base64.StdPadding),
"URLEncoding": reflect.ValueOf(&base64.URLEncoding).Elem(),
// type definitions
"CorruptInputError": reflect.ValueOf((*base64.CorruptInputError)(nil)),
"Encoding": reflect.ValueOf((*base64.Encoding)(nil)),
}
}
================================================
FILE: stdlib/go1_22_encoding_binary.go
================================================
// Code generated by 'yaegi extract encoding/binary'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"encoding/binary"
"go/constant"
"go/token"
"reflect"
)
func init() {
Symbols["encoding/binary/binary"] = map[string]reflect.Value{
// function, constant and variable definitions
"AppendUvarint": reflect.ValueOf(binary.AppendUvarint),
"AppendVarint": reflect.ValueOf(binary.AppendVarint),
"BigEndian": reflect.ValueOf(&binary.BigEndian).Elem(),
"LittleEndian": reflect.ValueOf(&binary.LittleEndian).Elem(),
"MaxVarintLen16": reflect.ValueOf(constant.MakeFromLiteral("3", token.INT, 0)),
"MaxVarintLen32": reflect.ValueOf(constant.MakeFromLiteral("5", token.INT, 0)),
"MaxVarintLen64": reflect.ValueOf(constant.MakeFromLiteral("10", token.INT, 0)),
"NativeEndian": reflect.ValueOf(&binary.NativeEndian).Elem(),
"PutUvarint": reflect.ValueOf(binary.PutUvarint),
"PutVarint": reflect.ValueOf(binary.PutVarint),
"Read": reflect.ValueOf(binary.Read),
"ReadUvarint": reflect.ValueOf(binary.ReadUvarint),
"ReadVarint": reflect.ValueOf(binary.ReadVarint),
"Size": reflect.ValueOf(binary.Size),
"Uvarint": reflect.ValueOf(binary.Uvarint),
"Varint": reflect.ValueOf(binary.Varint),
"Write": reflect.ValueOf(binary.Write),
// type definitions
"AppendByteOrder": reflect.ValueOf((*binary.AppendByteOrder)(nil)),
"ByteOrder": reflect.ValueOf((*binary.ByteOrder)(nil)),
// interface wrapper definitions
"_AppendByteOrder": reflect.ValueOf((*_encoding_binary_AppendByteOrder)(nil)),
"_ByteOrder": reflect.ValueOf((*_encoding_binary_ByteOrder)(nil)),
}
}
// _encoding_binary_AppendByteOrder is an interface wrapper for AppendByteOrder type
type _encoding_binary_AppendByteOrder struct {
IValue interface{}
WAppendUint16 func(a0 []byte, a1 uint16) []byte
WAppendUint32 func(a0 []byte, a1 uint32) []byte
WAppendUint64 func(a0 []byte, a1 uint64) []byte
WString func() string
}
func (W _encoding_binary_AppendByteOrder) AppendUint16(a0 []byte, a1 uint16) []byte {
return W.WAppendUint16(a0, a1)
}
func (W _encoding_binary_AppendByteOrder) AppendUint32(a0 []byte, a1 uint32) []byte {
return W.WAppendUint32(a0, a1)
}
func (W _encoding_binary_AppendByteOrder) AppendUint64(a0 []byte, a1 uint64) []byte {
return W.WAppendUint64(a0, a1)
}
func (W _encoding_binary_AppendByteOrder) String() string {
if W.WString == nil {
return ""
}
return W.WString()
}
// _encoding_binary_ByteOrder is an interface wrapper for ByteOrder type
type _encoding_binary_ByteOrder struct {
IValue interface{}
WPutUint16 func(a0 []byte, a1 uint16)
WPutUint32 func(a0 []byte, a1 uint32)
WPutUint64 func(a0 []byte, a1 uint64)
WString func() string
WUint16 func(a0 []byte) uint16
WUint32 func(a0 []byte) uint32
WUint64 func(a0 []byte) uint64
}
func (W _encoding_binary_ByteOrder) PutUint16(a0 []byte, a1 uint16) { W.WPutUint16(a0, a1) }
func (W _encoding_binary_ByteOrder) PutUint32(a0 []byte, a1 uint32) { W.WPutUint32(a0, a1) }
func (W _encoding_binary_ByteOrder) PutUint64(a0 []byte, a1 uint64) { W.WPutUint64(a0, a1) }
func (W _encoding_binary_ByteOrder) String() string {
if W.WString == nil {
return ""
}
return W.WString()
}
func (W _encoding_binary_ByteOrder) Uint16(a0 []byte) uint16 { return W.WUint16(a0) }
func (W _encoding_binary_ByteOrder) Uint32(a0 []byte) uint32 { return W.WUint32(a0) }
func (W _encoding_binary_ByteOrder) Uint64(a0 []byte) uint64 { return W.WUint64(a0) }
================================================
FILE: stdlib/go1_22_encoding_csv.go
================================================
// Code generated by 'yaegi extract encoding/csv'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"encoding/csv"
"reflect"
)
func init() {
Symbols["encoding/csv/csv"] = map[string]reflect.Value{
// function, constant and variable definitions
"ErrBareQuote": reflect.ValueOf(&csv.ErrBareQuote).Elem(),
"ErrFieldCount": reflect.ValueOf(&csv.ErrFieldCount).Elem(),
"ErrQuote": reflect.ValueOf(&csv.ErrQuote).Elem(),
"ErrTrailingComma": reflect.ValueOf(&csv.ErrTrailingComma).Elem(),
"NewReader": reflect.ValueOf(csv.NewReader),
"NewWriter": reflect.ValueOf(csv.NewWriter),
// type definitions
"ParseError": reflect.ValueOf((*csv.ParseError)(nil)),
"Reader": reflect.ValueOf((*csv.Reader)(nil)),
"Writer": reflect.ValueOf((*csv.Writer)(nil)),
}
}
================================================
FILE: stdlib/go1_22_encoding_gob.go
================================================
// Code generated by 'yaegi extract encoding/gob'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"encoding/gob"
"reflect"
)
func init() {
Symbols["encoding/gob/gob"] = map[string]reflect.Value{
// function, constant and variable definitions
"NewDecoder": reflect.ValueOf(gob.NewDecoder),
"NewEncoder": reflect.ValueOf(gob.NewEncoder),
"Register": reflect.ValueOf(gob.Register),
"RegisterName": reflect.ValueOf(gob.RegisterName),
// type definitions
"CommonType": reflect.ValueOf((*gob.CommonType)(nil)),
"Decoder": reflect.ValueOf((*gob.Decoder)(nil)),
"Encoder": reflect.ValueOf((*gob.Encoder)(nil)),
"GobDecoder": reflect.ValueOf((*gob.GobDecoder)(nil)),
"GobEncoder": reflect.ValueOf((*gob.GobEncoder)(nil)),
// interface wrapper definitions
"_GobDecoder": reflect.ValueOf((*_encoding_gob_GobDecoder)(nil)),
"_GobEncoder": reflect.ValueOf((*_encoding_gob_GobEncoder)(nil)),
}
}
// _encoding_gob_GobDecoder is an interface wrapper for GobDecoder type
type _encoding_gob_GobDecoder struct {
IValue interface{}
WGobDecode func(a0 []byte) error
}
func (W _encoding_gob_GobDecoder) GobDecode(a0 []byte) error { return W.WGobDecode(a0) }
// _encoding_gob_GobEncoder is an interface wrapper for GobEncoder type
type _encoding_gob_GobEncoder struct {
IValue interface{}
WGobEncode func() ([]byte, error)
}
func (W _encoding_gob_GobEncoder) GobEncode() ([]byte, error) { return W.WGobEncode() }
================================================
FILE: stdlib/go1_22_encoding_hex.go
================================================
// Code generated by 'yaegi extract encoding/hex'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"encoding/hex"
"reflect"
)
func init() {
Symbols["encoding/hex/hex"] = map[string]reflect.Value{
// function, constant and variable definitions
"AppendDecode": reflect.ValueOf(hex.AppendDecode),
"AppendEncode": reflect.ValueOf(hex.AppendEncode),
"Decode": reflect.ValueOf(hex.Decode),
"DecodeString": reflect.ValueOf(hex.DecodeString),
"DecodedLen": reflect.ValueOf(hex.DecodedLen),
"Dump": reflect.ValueOf(hex.Dump),
"Dumper": reflect.ValueOf(hex.Dumper),
"Encode": reflect.ValueOf(hex.Encode),
"EncodeToString": reflect.ValueOf(hex.EncodeToString),
"EncodedLen": reflect.ValueOf(hex.EncodedLen),
"ErrLength": reflect.ValueOf(&hex.ErrLength).Elem(),
"NewDecoder": reflect.ValueOf(hex.NewDecoder),
"NewEncoder": reflect.ValueOf(hex.NewEncoder),
// type definitions
"InvalidByteError": reflect.ValueOf((*hex.InvalidByteError)(nil)),
}
}
================================================
FILE: stdlib/go1_22_encoding_json.go
================================================
// Code generated by 'yaegi extract encoding/json'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"encoding/json"
"reflect"
)
func init() {
Symbols["encoding/json/json"] = map[string]reflect.Value{
// function, constant and variable definitions
"Compact": reflect.ValueOf(json.Compact),
"HTMLEscape": reflect.ValueOf(json.HTMLEscape),
"Indent": reflect.ValueOf(json.Indent),
"Marshal": reflect.ValueOf(json.Marshal),
"MarshalIndent": reflect.ValueOf(json.MarshalIndent),
"NewDecoder": reflect.ValueOf(json.NewDecoder),
"NewEncoder": reflect.ValueOf(json.NewEncoder),
"Unmarshal": reflect.ValueOf(json.Unmarshal),
"Valid": reflect.ValueOf(json.Valid),
// type definitions
"Decoder": reflect.ValueOf((*json.Decoder)(nil)),
"Delim": reflect.ValueOf((*json.Delim)(nil)),
"Encoder": reflect.ValueOf((*json.Encoder)(nil)),
"InvalidUTF8Error": reflect.ValueOf((*json.InvalidUTF8Error)(nil)),
"InvalidUnmarshalError": reflect.ValueOf((*json.InvalidUnmarshalError)(nil)),
"Marshaler": reflect.ValueOf((*json.Marshaler)(nil)),
"MarshalerError": reflect.ValueOf((*json.MarshalerError)(nil)),
"Number": reflect.ValueOf((*json.Number)(nil)),
"RawMessage": reflect.ValueOf((*json.RawMessage)(nil)),
"SyntaxError": reflect.ValueOf((*json.SyntaxError)(nil)),
"Token": reflect.ValueOf((*json.Token)(nil)),
"UnmarshalFieldError": reflect.ValueOf((*json.UnmarshalFieldError)(nil)),
"UnmarshalTypeError": reflect.ValueOf((*json.UnmarshalTypeError)(nil)),
"Unmarshaler": reflect.ValueOf((*json.Unmarshaler)(nil)),
"UnsupportedTypeError": reflect.ValueOf((*json.UnsupportedTypeError)(nil)),
"UnsupportedValueError": reflect.ValueOf((*json.UnsupportedValueError)(nil)),
// interface wrapper definitions
"_Marshaler": reflect.ValueOf((*_encoding_json_Marshaler)(nil)),
"_Token": reflect.ValueOf((*_encoding_json_Token)(nil)),
"_Unmarshaler": reflect.ValueOf((*_encoding_json_Unmarshaler)(nil)),
}
}
// _encoding_json_Marshaler is an interface wrapper for Marshaler type
type _encoding_json_Marshaler struct {
IValue interface{}
WMarshalJSON func() ([]byte, error)
}
func (W _encoding_json_Marshaler) MarshalJSON() ([]byte, error) { return W.WMarshalJSON() }
// _encoding_json_Token is an interface wrapper for Token type
type _encoding_json_Token struct {
IValue interface{}
}
// _encoding_json_Unmarshaler is an interface wrapper for Unmarshaler type
type _encoding_json_Unmarshaler struct {
IValue interface{}
WUnmarshalJSON func(a0 []byte) error
}
func (W _encoding_json_Unmarshaler) UnmarshalJSON(a0 []byte) error { return W.WUnmarshalJSON(a0) }
================================================
FILE: stdlib/go1_22_encoding_pem.go
================================================
// Code generated by 'yaegi extract encoding/pem'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"encoding/pem"
"reflect"
)
func init() {
Symbols["encoding/pem/pem"] = map[string]reflect.Value{
// function, constant and variable definitions
"Decode": reflect.ValueOf(pem.Decode),
"Encode": reflect.ValueOf(pem.Encode),
"EncodeToMemory": reflect.ValueOf(pem.EncodeToMemory),
// type definitions
"Block": reflect.ValueOf((*pem.Block)(nil)),
}
}
================================================
FILE: stdlib/go1_22_encoding_xml.go
================================================
// Code generated by 'yaegi extract encoding/xml'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"encoding/xml"
"go/constant"
"go/token"
"reflect"
)
func init() {
Symbols["encoding/xml/xml"] = map[string]reflect.Value{
// function, constant and variable definitions
"CopyToken": reflect.ValueOf(xml.CopyToken),
"Escape": reflect.ValueOf(xml.Escape),
"EscapeText": reflect.ValueOf(xml.EscapeText),
"HTMLAutoClose": reflect.ValueOf(&xml.HTMLAutoClose).Elem(),
"HTMLEntity": reflect.ValueOf(&xml.HTMLEntity).Elem(),
"Header": reflect.ValueOf(constant.MakeFromLiteral("\"\\n\"", token.STRING, 0)),
"Marshal": reflect.ValueOf(xml.Marshal),
"MarshalIndent": reflect.ValueOf(xml.MarshalIndent),
"NewDecoder": reflect.ValueOf(xml.NewDecoder),
"NewEncoder": reflect.ValueOf(xml.NewEncoder),
"NewTokenDecoder": reflect.ValueOf(xml.NewTokenDecoder),
"Unmarshal": reflect.ValueOf(xml.Unmarshal),
// type definitions
"Attr": reflect.ValueOf((*xml.Attr)(nil)),
"CharData": reflect.ValueOf((*xml.CharData)(nil)),
"Comment": reflect.ValueOf((*xml.Comment)(nil)),
"Decoder": reflect.ValueOf((*xml.Decoder)(nil)),
"Directive": reflect.ValueOf((*xml.Directive)(nil)),
"Encoder": reflect.ValueOf((*xml.Encoder)(nil)),
"EndElement": reflect.ValueOf((*xml.EndElement)(nil)),
"Marshaler": reflect.ValueOf((*xml.Marshaler)(nil)),
"MarshalerAttr": reflect.ValueOf((*xml.MarshalerAttr)(nil)),
"Name": reflect.ValueOf((*xml.Name)(nil)),
"ProcInst": reflect.ValueOf((*xml.ProcInst)(nil)),
"StartElement": reflect.ValueOf((*xml.StartElement)(nil)),
"SyntaxError": reflect.ValueOf((*xml.SyntaxError)(nil)),
"TagPathError": reflect.ValueOf((*xml.TagPathError)(nil)),
"Token": reflect.ValueOf((*xml.Token)(nil)),
"TokenReader": reflect.ValueOf((*xml.TokenReader)(nil)),
"UnmarshalError": reflect.ValueOf((*xml.UnmarshalError)(nil)),
"Unmarshaler": reflect.ValueOf((*xml.Unmarshaler)(nil)),
"UnmarshalerAttr": reflect.ValueOf((*xml.UnmarshalerAttr)(nil)),
"UnsupportedTypeError": reflect.ValueOf((*xml.UnsupportedTypeError)(nil)),
// interface wrapper definitions
"_Marshaler": reflect.ValueOf((*_encoding_xml_Marshaler)(nil)),
"_MarshalerAttr": reflect.ValueOf((*_encoding_xml_MarshalerAttr)(nil)),
"_Token": reflect.ValueOf((*_encoding_xml_Token)(nil)),
"_TokenReader": reflect.ValueOf((*_encoding_xml_TokenReader)(nil)),
"_Unmarshaler": reflect.ValueOf((*_encoding_xml_Unmarshaler)(nil)),
"_UnmarshalerAttr": reflect.ValueOf((*_encoding_xml_UnmarshalerAttr)(nil)),
}
}
// _encoding_xml_Marshaler is an interface wrapper for Marshaler type
type _encoding_xml_Marshaler struct {
IValue interface{}
WMarshalXML func(e *xml.Encoder, start xml.StartElement) error
}
func (W _encoding_xml_Marshaler) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
return W.WMarshalXML(e, start)
}
// _encoding_xml_MarshalerAttr is an interface wrapper for MarshalerAttr type
type _encoding_xml_MarshalerAttr struct {
IValue interface{}
WMarshalXMLAttr func(name xml.Name) (xml.Attr, error)
}
func (W _encoding_xml_MarshalerAttr) MarshalXMLAttr(name xml.Name) (xml.Attr, error) {
return W.WMarshalXMLAttr(name)
}
// _encoding_xml_Token is an interface wrapper for Token type
type _encoding_xml_Token struct {
IValue interface{}
}
// _encoding_xml_TokenReader is an interface wrapper for TokenReader type
type _encoding_xml_TokenReader struct {
IValue interface{}
WToken func() (xml.Token, error)
}
func (W _encoding_xml_TokenReader) Token() (xml.Token, error) { return W.WToken() }
// _encoding_xml_Unmarshaler is an interface wrapper for Unmarshaler type
type _encoding_xml_Unmarshaler struct {
IValue interface{}
WUnmarshalXML func(d *xml.Decoder, start xml.StartElement) error
}
func (W _encoding_xml_Unmarshaler) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
return W.WUnmarshalXML(d, start)
}
// _encoding_xml_UnmarshalerAttr is an interface wrapper for UnmarshalerAttr type
type _encoding_xml_UnmarshalerAttr struct {
IValue interface{}
WUnmarshalXMLAttr func(attr xml.Attr) error
}
func (W _encoding_xml_UnmarshalerAttr) UnmarshalXMLAttr(attr xml.Attr) error {
return W.WUnmarshalXMLAttr(attr)
}
================================================
FILE: stdlib/go1_22_errors.go
================================================
// Code generated by 'yaegi extract errors'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"errors"
"reflect"
)
func init() {
Symbols["errors/errors"] = map[string]reflect.Value{
// function, constant and variable definitions
"As": reflect.ValueOf(errors.As),
"ErrUnsupported": reflect.ValueOf(&errors.ErrUnsupported).Elem(),
"Is": reflect.ValueOf(errors.Is),
"Join": reflect.ValueOf(errors.Join),
"New": reflect.ValueOf(errors.New),
"Unwrap": reflect.ValueOf(errors.Unwrap),
}
}
================================================
FILE: stdlib/go1_22_expvar.go
================================================
// Code generated by 'yaegi extract expvar'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"expvar"
"reflect"
)
func init() {
Symbols["expvar/expvar"] = map[string]reflect.Value{
// function, constant and variable definitions
"Do": reflect.ValueOf(expvar.Do),
"Get": reflect.ValueOf(expvar.Get),
"Handler": reflect.ValueOf(expvar.Handler),
"NewFloat": reflect.ValueOf(expvar.NewFloat),
"NewInt": reflect.ValueOf(expvar.NewInt),
"NewMap": reflect.ValueOf(expvar.NewMap),
"NewString": reflect.ValueOf(expvar.NewString),
"Publish": reflect.ValueOf(expvar.Publish),
// type definitions
"Float": reflect.ValueOf((*expvar.Float)(nil)),
"Func": reflect.ValueOf((*expvar.Func)(nil)),
"Int": reflect.ValueOf((*expvar.Int)(nil)),
"KeyValue": reflect.ValueOf((*expvar.KeyValue)(nil)),
"Map": reflect.ValueOf((*expvar.Map)(nil)),
"String": reflect.ValueOf((*expvar.String)(nil)),
"Var": reflect.ValueOf((*expvar.Var)(nil)),
// interface wrapper definitions
"_Var": reflect.ValueOf((*_expvar_Var)(nil)),
}
}
// _expvar_Var is an interface wrapper for Var type
type _expvar_Var struct {
IValue interface{}
WString func() string
}
func (W _expvar_Var) String() string {
if W.WString == nil {
return ""
}
return W.WString()
}
================================================
FILE: stdlib/go1_22_flag.go
================================================
// Code generated by 'yaegi extract flag'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"flag"
"reflect"
)
func init() {
Symbols["flag/flag"] = map[string]reflect.Value{
// function, constant and variable definitions
"Arg": reflect.ValueOf(flag.Arg),
"Args": reflect.ValueOf(flag.Args),
"Bool": reflect.ValueOf(flag.Bool),
"BoolFunc": reflect.ValueOf(flag.BoolFunc),
"BoolVar": reflect.ValueOf(flag.BoolVar),
"CommandLine": reflect.ValueOf(&flag.CommandLine).Elem(),
"ContinueOnError": reflect.ValueOf(flag.ContinueOnError),
"Duration": reflect.ValueOf(flag.Duration),
"DurationVar": reflect.ValueOf(flag.DurationVar),
"ErrHelp": reflect.ValueOf(&flag.ErrHelp).Elem(),
"ExitOnError": reflect.ValueOf(flag.ExitOnError),
"Float64": reflect.ValueOf(flag.Float64),
"Float64Var": reflect.ValueOf(flag.Float64Var),
"Func": reflect.ValueOf(flag.Func),
"Int": reflect.ValueOf(flag.Int),
"Int64": reflect.ValueOf(flag.Int64),
"Int64Var": reflect.ValueOf(flag.Int64Var),
"IntVar": reflect.ValueOf(flag.IntVar),
"Lookup": reflect.ValueOf(flag.Lookup),
"NArg": reflect.ValueOf(flag.NArg),
"NFlag": reflect.ValueOf(flag.NFlag),
"NewFlagSet": reflect.ValueOf(flag.NewFlagSet),
"PanicOnError": reflect.ValueOf(flag.PanicOnError),
"Parse": reflect.ValueOf(flag.Parse),
"Parsed": reflect.ValueOf(flag.Parsed),
"PrintDefaults": reflect.ValueOf(flag.PrintDefaults),
"Set": reflect.ValueOf(flag.Set),
"String": reflect.ValueOf(flag.String),
"StringVar": reflect.ValueOf(flag.StringVar),
"TextVar": reflect.ValueOf(flag.TextVar),
"Uint": reflect.ValueOf(flag.Uint),
"Uint64": reflect.ValueOf(flag.Uint64),
"Uint64Var": reflect.ValueOf(flag.Uint64Var),
"UintVar": reflect.ValueOf(flag.UintVar),
"UnquoteUsage": reflect.ValueOf(flag.UnquoteUsage),
"Usage": reflect.ValueOf(&flag.Usage).Elem(),
"Var": reflect.ValueOf(flag.Var),
"Visit": reflect.ValueOf(flag.Visit),
"VisitAll": reflect.ValueOf(flag.VisitAll),
// type definitions
"ErrorHandling": reflect.ValueOf((*flag.ErrorHandling)(nil)),
"Flag": reflect.ValueOf((*flag.Flag)(nil)),
"FlagSet": reflect.ValueOf((*flag.FlagSet)(nil)),
"Getter": reflect.ValueOf((*flag.Getter)(nil)),
"Value": reflect.ValueOf((*flag.Value)(nil)),
// interface wrapper definitions
"_Getter": reflect.ValueOf((*_flag_Getter)(nil)),
"_Value": reflect.ValueOf((*_flag_Value)(nil)),
}
}
// _flag_Getter is an interface wrapper for Getter type
type _flag_Getter struct {
IValue interface{}
WGet func() any
WSet func(a0 string) error
WString func() string
}
func (W _flag_Getter) Get() any { return W.WGet() }
func (W _flag_Getter) Set(a0 string) error { return W.WSet(a0) }
func (W _flag_Getter) String() string {
if W.WString == nil {
return ""
}
return W.WString()
}
// _flag_Value is an interface wrapper for Value type
type _flag_Value struct {
IValue interface{}
WSet func(a0 string) error
WString func() string
}
func (W _flag_Value) Set(a0 string) error { return W.WSet(a0) }
func (W _flag_Value) String() string {
if W.WString == nil {
return ""
}
return W.WString()
}
================================================
FILE: stdlib/go1_22_fmt.go
================================================
// Code generated by 'yaegi extract fmt'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"fmt"
"reflect"
)
func init() {
Symbols["fmt/fmt"] = map[string]reflect.Value{
// function, constant and variable definitions
"Append": reflect.ValueOf(fmt.Append),
"Appendf": reflect.ValueOf(fmt.Appendf),
"Appendln": reflect.ValueOf(fmt.Appendln),
"Errorf": reflect.ValueOf(fmt.Errorf),
"FormatString": reflect.ValueOf(fmt.FormatString),
"Fprint": reflect.ValueOf(fmt.Fprint),
"Fprintf": reflect.ValueOf(fmt.Fprintf),
"Fprintln": reflect.ValueOf(fmt.Fprintln),
"Fscan": reflect.ValueOf(fmt.Fscan),
"Fscanf": reflect.ValueOf(fmt.Fscanf),
"Fscanln": reflect.ValueOf(fmt.Fscanln),
"Print": reflect.ValueOf(fmt.Print),
"Printf": reflect.ValueOf(fmt.Printf),
"Println": reflect.ValueOf(fmt.Println),
"Scan": reflect.ValueOf(fmt.Scan),
"Scanf": reflect.ValueOf(fmt.Scanf),
"Scanln": reflect.ValueOf(fmt.Scanln),
"Sprint": reflect.ValueOf(fmt.Sprint),
"Sprintf": reflect.ValueOf(fmt.Sprintf),
"Sprintln": reflect.ValueOf(fmt.Sprintln),
"Sscan": reflect.ValueOf(fmt.Sscan),
"Sscanf": reflect.ValueOf(fmt.Sscanf),
"Sscanln": reflect.ValueOf(fmt.Sscanln),
// type definitions
"Formatter": reflect.ValueOf((*fmt.Formatter)(nil)),
"GoStringer": reflect.ValueOf((*fmt.GoStringer)(nil)),
"ScanState": reflect.ValueOf((*fmt.ScanState)(nil)),
"Scanner": reflect.ValueOf((*fmt.Scanner)(nil)),
"State": reflect.ValueOf((*fmt.State)(nil)),
"Stringer": reflect.ValueOf((*fmt.Stringer)(nil)),
// interface wrapper definitions
"_Formatter": reflect.ValueOf((*_fmt_Formatter)(nil)),
"_GoStringer": reflect.ValueOf((*_fmt_GoStringer)(nil)),
"_ScanState": reflect.ValueOf((*_fmt_ScanState)(nil)),
"_Scanner": reflect.ValueOf((*_fmt_Scanner)(nil)),
"_State": reflect.ValueOf((*_fmt_State)(nil)),
"_Stringer": reflect.ValueOf((*_fmt_Stringer)(nil)),
}
}
// _fmt_Formatter is an interface wrapper for Formatter type
type _fmt_Formatter struct {
IValue interface{}
WFormat func(f fmt.State, verb rune)
}
func (W _fmt_Formatter) Format(f fmt.State, verb rune) { W.WFormat(f, verb) }
// _fmt_GoStringer is an interface wrapper for GoStringer type
type _fmt_GoStringer struct {
IValue interface{}
WGoString func() string
}
func (W _fmt_GoStringer) GoString() string { return W.WGoString() }
// _fmt_ScanState is an interface wrapper for ScanState type
type _fmt_ScanState struct {
IValue interface{}
WRead func(buf []byte) (n int, err error)
WReadRune func() (r rune, size int, err error)
WSkipSpace func()
WToken func(skipSpace bool, f func(rune) bool) (token []byte, err error)
WUnreadRune func() error
WWidth func() (wid int, ok bool)
}
func (W _fmt_ScanState) Read(buf []byte) (n int, err error) { return W.WRead(buf) }
func (W _fmt_ScanState) ReadRune() (r rune, size int, err error) { return W.WReadRune() }
func (W _fmt_ScanState) SkipSpace() { W.WSkipSpace() }
func (W _fmt_ScanState) Token(skipSpace bool, f func(rune) bool) (token []byte, err error) {
return W.WToken(skipSpace, f)
}
func (W _fmt_ScanState) UnreadRune() error { return W.WUnreadRune() }
func (W _fmt_ScanState) Width() (wid int, ok bool) { return W.WWidth() }
// _fmt_Scanner is an interface wrapper for Scanner type
type _fmt_Scanner struct {
IValue interface{}
WScan func(state fmt.ScanState, verb rune) error
}
func (W _fmt_Scanner) Scan(state fmt.ScanState, verb rune) error { return W.WScan(state, verb) }
// _fmt_State is an interface wrapper for State type
type _fmt_State struct {
IValue interface{}
WFlag func(c int) bool
WPrecision func() (prec int, ok bool)
WWidth func() (wid int, ok bool)
WWrite func(b []byte) (n int, err error)
}
func (W _fmt_State) Flag(c int) bool { return W.WFlag(c) }
func (W _fmt_State) Precision() (prec int, ok bool) { return W.WPrecision() }
func (W _fmt_State) Width() (wid int, ok bool) { return W.WWidth() }
func (W _fmt_State) Write(b []byte) (n int, err error) { return W.WWrite(b) }
// _fmt_Stringer is an interface wrapper for Stringer type
type _fmt_Stringer struct {
IValue interface{}
WString func() string
}
func (W _fmt_Stringer) String() string {
if W.WString == nil {
return ""
}
return W.WString()
}
================================================
FILE: stdlib/go1_22_go_ast.go
================================================
// Code generated by 'yaegi extract go/ast'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"go/ast"
"go/token"
"reflect"
)
func init() {
Symbols["go/ast/ast"] = map[string]reflect.Value{
// function, constant and variable definitions
"Bad": reflect.ValueOf(ast.Bad),
"Con": reflect.ValueOf(ast.Con),
"FileExports": reflect.ValueOf(ast.FileExports),
"FilterDecl": reflect.ValueOf(ast.FilterDecl),
"FilterFile": reflect.ValueOf(ast.FilterFile),
"FilterFuncDuplicates": reflect.ValueOf(ast.FilterFuncDuplicates),
"FilterImportDuplicates": reflect.ValueOf(ast.FilterImportDuplicates),
"FilterPackage": reflect.ValueOf(ast.FilterPackage),
"FilterUnassociatedComments": reflect.ValueOf(ast.FilterUnassociatedComments),
"Fprint": reflect.ValueOf(ast.Fprint),
"Fun": reflect.ValueOf(ast.Fun),
"Inspect": reflect.ValueOf(ast.Inspect),
"IsExported": reflect.ValueOf(ast.IsExported),
"IsGenerated": reflect.ValueOf(ast.IsGenerated),
"Lbl": reflect.ValueOf(ast.Lbl),
"MergePackageFiles": reflect.ValueOf(ast.MergePackageFiles),
"NewCommentMap": reflect.ValueOf(ast.NewCommentMap),
"NewIdent": reflect.ValueOf(ast.NewIdent),
"NewObj": reflect.ValueOf(ast.NewObj),
"NewPackage": reflect.ValueOf(ast.NewPackage),
"NewScope": reflect.ValueOf(ast.NewScope),
"NotNilFilter": reflect.ValueOf(ast.NotNilFilter),
"PackageExports": reflect.ValueOf(ast.PackageExports),
"Pkg": reflect.ValueOf(ast.Pkg),
"Print": reflect.ValueOf(ast.Print),
"RECV": reflect.ValueOf(ast.RECV),
"SEND": reflect.ValueOf(ast.SEND),
"SortImports": reflect.ValueOf(ast.SortImports),
"Typ": reflect.ValueOf(ast.Typ),
"Unparen": reflect.ValueOf(ast.Unparen),
"Var": reflect.ValueOf(ast.Var),
"Walk": reflect.ValueOf(ast.Walk),
// type definitions
"ArrayType": reflect.ValueOf((*ast.ArrayType)(nil)),
"AssignStmt": reflect.ValueOf((*ast.AssignStmt)(nil)),
"BadDecl": reflect.ValueOf((*ast.BadDecl)(nil)),
"BadExpr": reflect.ValueOf((*ast.BadExpr)(nil)),
"BadStmt": reflect.ValueOf((*ast.BadStmt)(nil)),
"BasicLit": reflect.ValueOf((*ast.BasicLit)(nil)),
"BinaryExpr": reflect.ValueOf((*ast.BinaryExpr)(nil)),
"BlockStmt": reflect.ValueOf((*ast.BlockStmt)(nil)),
"BranchStmt": reflect.ValueOf((*ast.BranchStmt)(nil)),
"CallExpr": reflect.ValueOf((*ast.CallExpr)(nil)),
"CaseClause": reflect.ValueOf((*ast.CaseClause)(nil)),
"ChanDir": reflect.ValueOf((*ast.ChanDir)(nil)),
"ChanType": reflect.ValueOf((*ast.ChanType)(nil)),
"CommClause": reflect.ValueOf((*ast.CommClause)(nil)),
"Comment": reflect.ValueOf((*ast.Comment)(nil)),
"CommentGroup": reflect.ValueOf((*ast.CommentGroup)(nil)),
"CommentMap": reflect.ValueOf((*ast.CommentMap)(nil)),
"CompositeLit": reflect.ValueOf((*ast.CompositeLit)(nil)),
"Decl": reflect.ValueOf((*ast.Decl)(nil)),
"DeclStmt": reflect.ValueOf((*ast.DeclStmt)(nil)),
"DeferStmt": reflect.ValueOf((*ast.DeferStmt)(nil)),
"Ellipsis": reflect.ValueOf((*ast.Ellipsis)(nil)),
"EmptyStmt": reflect.ValueOf((*ast.EmptyStmt)(nil)),
"Expr": reflect.ValueOf((*ast.Expr)(nil)),
"ExprStmt": reflect.ValueOf((*ast.ExprStmt)(nil)),
"Field": reflect.ValueOf((*ast.Field)(nil)),
"FieldFilter": reflect.ValueOf((*ast.FieldFilter)(nil)),
"FieldList": reflect.ValueOf((*ast.FieldList)(nil)),
"File": reflect.ValueOf((*ast.File)(nil)),
"Filter": reflect.ValueOf((*ast.Filter)(nil)),
"ForStmt": reflect.ValueOf((*ast.ForStmt)(nil)),
"FuncDecl": reflect.ValueOf((*ast.FuncDecl)(nil)),
"FuncLit": reflect.ValueOf((*ast.FuncLit)(nil)),
"FuncType": reflect.ValueOf((*ast.FuncType)(nil)),
"GenDecl": reflect.ValueOf((*ast.GenDecl)(nil)),
"GoStmt": reflect.ValueOf((*ast.GoStmt)(nil)),
"Ident": reflect.ValueOf((*ast.Ident)(nil)),
"IfStmt": reflect.ValueOf((*ast.IfStmt)(nil)),
"ImportSpec": reflect.ValueOf((*ast.ImportSpec)(nil)),
"Importer": reflect.ValueOf((*ast.Importer)(nil)),
"IncDecStmt": reflect.ValueOf((*ast.IncDecStmt)(nil)),
"IndexExpr": reflect.ValueOf((*ast.IndexExpr)(nil)),
"IndexListExpr": reflect.ValueOf((*ast.IndexListExpr)(nil)),
"InterfaceType": reflect.ValueOf((*ast.InterfaceType)(nil)),
"KeyValueExpr": reflect.ValueOf((*ast.KeyValueExpr)(nil)),
"LabeledStmt": reflect.ValueOf((*ast.LabeledStmt)(nil)),
"MapType": reflect.ValueOf((*ast.MapType)(nil)),
"MergeMode": reflect.ValueOf((*ast.MergeMode)(nil)),
"Node": reflect.ValueOf((*ast.Node)(nil)),
"ObjKind": reflect.ValueOf((*ast.ObjKind)(nil)),
"Object": reflect.ValueOf((*ast.Object)(nil)),
"Package": reflect.ValueOf((*ast.Package)(nil)),
"ParenExpr": reflect.ValueOf((*ast.ParenExpr)(nil)),
"RangeStmt": reflect.ValueOf((*ast.RangeStmt)(nil)),
"ReturnStmt": reflect.ValueOf((*ast.ReturnStmt)(nil)),
"Scope": reflect.ValueOf((*ast.Scope)(nil)),
"SelectStmt": reflect.ValueOf((*ast.SelectStmt)(nil)),
"SelectorExpr": reflect.ValueOf((*ast.SelectorExpr)(nil)),
"SendStmt": reflect.ValueOf((*ast.SendStmt)(nil)),
"SliceExpr": reflect.ValueOf((*ast.SliceExpr)(nil)),
"Spec": reflect.ValueOf((*ast.Spec)(nil)),
"StarExpr": reflect.ValueOf((*ast.StarExpr)(nil)),
"Stmt": reflect.ValueOf((*ast.Stmt)(nil)),
"StructType": reflect.ValueOf((*ast.StructType)(nil)),
"SwitchStmt": reflect.ValueOf((*ast.SwitchStmt)(nil)),
"TypeAssertExpr": reflect.ValueOf((*ast.TypeAssertExpr)(nil)),
"TypeSpec": reflect.ValueOf((*ast.TypeSpec)(nil)),
"TypeSwitchStmt": reflect.ValueOf((*ast.TypeSwitchStmt)(nil)),
"UnaryExpr": reflect.ValueOf((*ast.UnaryExpr)(nil)),
"ValueSpec": reflect.ValueOf((*ast.ValueSpec)(nil)),
"Visitor": reflect.ValueOf((*ast.Visitor)(nil)),
// interface wrapper definitions
"_Decl": reflect.ValueOf((*_go_ast_Decl)(nil)),
"_Expr": reflect.ValueOf((*_go_ast_Expr)(nil)),
"_Node": reflect.ValueOf((*_go_ast_Node)(nil)),
"_Spec": reflect.ValueOf((*_go_ast_Spec)(nil)),
"_Stmt": reflect.ValueOf((*_go_ast_Stmt)(nil)),
"_Visitor": reflect.ValueOf((*_go_ast_Visitor)(nil)),
}
}
// _go_ast_Decl is an interface wrapper for Decl type
type _go_ast_Decl struct {
IValue interface{}
WEnd func() token.Pos
WPos func() token.Pos
}
func (W _go_ast_Decl) End() token.Pos { return W.WEnd() }
func (W _go_ast_Decl) Pos() token.Pos { return W.WPos() }
// _go_ast_Expr is an interface wrapper for Expr type
type _go_ast_Expr struct {
IValue interface{}
WEnd func() token.Pos
WPos func() token.Pos
}
func (W _go_ast_Expr) End() token.Pos { return W.WEnd() }
func (W _go_ast_Expr) Pos() token.Pos { return W.WPos() }
// _go_ast_Node is an interface wrapper for Node type
type _go_ast_Node struct {
IValue interface{}
WEnd func() token.Pos
WPos func() token.Pos
}
func (W _go_ast_Node) End() token.Pos { return W.WEnd() }
func (W _go_ast_Node) Pos() token.Pos { return W.WPos() }
// _go_ast_Spec is an interface wrapper for Spec type
type _go_ast_Spec struct {
IValue interface{}
WEnd func() token.Pos
WPos func() token.Pos
}
func (W _go_ast_Spec) End() token.Pos { return W.WEnd() }
func (W _go_ast_Spec) Pos() token.Pos { return W.WPos() }
// _go_ast_Stmt is an interface wrapper for Stmt type
type _go_ast_Stmt struct {
IValue interface{}
WEnd func() token.Pos
WPos func() token.Pos
}
func (W _go_ast_Stmt) End() token.Pos { return W.WEnd() }
func (W _go_ast_Stmt) Pos() token.Pos { return W.WPos() }
// _go_ast_Visitor is an interface wrapper for Visitor type
type _go_ast_Visitor struct {
IValue interface{}
WVisit func(node ast.Node) (w ast.Visitor)
}
func (W _go_ast_Visitor) Visit(node ast.Node) (w ast.Visitor) { return W.WVisit(node) }
================================================
FILE: stdlib/go1_22_go_build.go
================================================
// Code generated by 'yaegi extract go/build'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"go/build"
"reflect"
)
func init() {
Symbols["go/build/build"] = map[string]reflect.Value{
// function, constant and variable definitions
"AllowBinary": reflect.ValueOf(build.AllowBinary),
"ArchChar": reflect.ValueOf(build.ArchChar),
"Default": reflect.ValueOf(&build.Default).Elem(),
"FindOnly": reflect.ValueOf(build.FindOnly),
"IgnoreVendor": reflect.ValueOf(build.IgnoreVendor),
"Import": reflect.ValueOf(build.Import),
"ImportComment": reflect.ValueOf(build.ImportComment),
"ImportDir": reflect.ValueOf(build.ImportDir),
"IsLocalImport": reflect.ValueOf(build.IsLocalImport),
"ToolDir": reflect.ValueOf(&build.ToolDir).Elem(),
// type definitions
"Context": reflect.ValueOf((*build.Context)(nil)),
"Directive": reflect.ValueOf((*build.Directive)(nil)),
"ImportMode": reflect.ValueOf((*build.ImportMode)(nil)),
"MultiplePackageError": reflect.ValueOf((*build.MultiplePackageError)(nil)),
"NoGoError": reflect.ValueOf((*build.NoGoError)(nil)),
"Package": reflect.ValueOf((*build.Package)(nil)),
}
}
================================================
FILE: stdlib/go1_22_go_build_constraint.go
================================================
// Code generated by 'yaegi extract go/build/constraint'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"go/build/constraint"
"reflect"
)
func init() {
Symbols["go/build/constraint/constraint"] = map[string]reflect.Value{
// function, constant and variable definitions
"GoVersion": reflect.ValueOf(constraint.GoVersion),
"IsGoBuild": reflect.ValueOf(constraint.IsGoBuild),
"IsPlusBuild": reflect.ValueOf(constraint.IsPlusBuild),
"Parse": reflect.ValueOf(constraint.Parse),
"PlusBuildLines": reflect.ValueOf(constraint.PlusBuildLines),
// type definitions
"AndExpr": reflect.ValueOf((*constraint.AndExpr)(nil)),
"Expr": reflect.ValueOf((*constraint.Expr)(nil)),
"NotExpr": reflect.ValueOf((*constraint.NotExpr)(nil)),
"OrExpr": reflect.ValueOf((*constraint.OrExpr)(nil)),
"SyntaxError": reflect.ValueOf((*constraint.SyntaxError)(nil)),
"TagExpr": reflect.ValueOf((*constraint.TagExpr)(nil)),
// interface wrapper definitions
"_Expr": reflect.ValueOf((*_go_build_constraint_Expr)(nil)),
}
}
// _go_build_constraint_Expr is an interface wrapper for Expr type
type _go_build_constraint_Expr struct {
IValue interface{}
WEval func(ok func(tag string) bool) bool
WString func() string
}
func (W _go_build_constraint_Expr) Eval(ok func(tag string) bool) bool { return W.WEval(ok) }
func (W _go_build_constraint_Expr) String() string {
if W.WString == nil {
return ""
}
return W.WString()
}
================================================
FILE: stdlib/go1_22_go_constant.go
================================================
// Code generated by 'yaegi extract go/constant'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"go/constant"
"reflect"
)
func init() {
Symbols["go/constant/constant"] = map[string]reflect.Value{
// function, constant and variable definitions
"BinaryOp": reflect.ValueOf(constant.BinaryOp),
"BitLen": reflect.ValueOf(constant.BitLen),
"Bool": reflect.ValueOf(constant.Bool),
"BoolVal": reflect.ValueOf(constant.BoolVal),
"Bytes": reflect.ValueOf(constant.Bytes),
"Compare": reflect.ValueOf(constant.Compare),
"Complex": reflect.ValueOf(constant.Complex),
"Denom": reflect.ValueOf(constant.Denom),
"Float": reflect.ValueOf(constant.Float),
"Float32Val": reflect.ValueOf(constant.Float32Val),
"Float64Val": reflect.ValueOf(constant.Float64Val),
"Imag": reflect.ValueOf(constant.Imag),
"Int": reflect.ValueOf(constant.Int),
"Int64Val": reflect.ValueOf(constant.Int64Val),
"Make": reflect.ValueOf(constant.Make),
"MakeBool": reflect.ValueOf(constant.MakeBool),
"MakeFloat64": reflect.ValueOf(constant.MakeFloat64),
"MakeFromBytes": reflect.ValueOf(constant.MakeFromBytes),
"MakeFromLiteral": reflect.ValueOf(constant.MakeFromLiteral),
"MakeImag": reflect.ValueOf(constant.MakeImag),
"MakeInt64": reflect.ValueOf(constant.MakeInt64),
"MakeString": reflect.ValueOf(constant.MakeString),
"MakeUint64": reflect.ValueOf(constant.MakeUint64),
"MakeUnknown": reflect.ValueOf(constant.MakeUnknown),
"Num": reflect.ValueOf(constant.Num),
"Real": reflect.ValueOf(constant.Real),
"Shift": reflect.ValueOf(constant.Shift),
"Sign": reflect.ValueOf(constant.Sign),
"String": reflect.ValueOf(constant.String),
"StringVal": reflect.ValueOf(constant.StringVal),
"ToComplex": reflect.ValueOf(constant.ToComplex),
"ToFloat": reflect.ValueOf(constant.ToFloat),
"ToInt": reflect.ValueOf(constant.ToInt),
"Uint64Val": reflect.ValueOf(constant.Uint64Val),
"UnaryOp": reflect.ValueOf(constant.UnaryOp),
"Unknown": reflect.ValueOf(constant.Unknown),
"Val": reflect.ValueOf(constant.Val),
// type definitions
"Kind": reflect.ValueOf((*constant.Kind)(nil)),
"Value": reflect.ValueOf((*constant.Value)(nil)),
// interface wrapper definitions
"_Value": reflect.ValueOf((*_go_constant_Value)(nil)),
}
}
// _go_constant_Value is an interface wrapper for Value type
type _go_constant_Value struct {
IValue interface{}
WExactString func() string
WKind func() constant.Kind
WString func() string
}
func (W _go_constant_Value) ExactString() string { return W.WExactString() }
func (W _go_constant_Value) Kind() constant.Kind { return W.WKind() }
func (W _go_constant_Value) String() string {
if W.WString == nil {
return ""
}
return W.WString()
}
================================================
FILE: stdlib/go1_22_go_doc.go
================================================
// Code generated by 'yaegi extract go/doc'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"go/doc"
"reflect"
)
func init() {
Symbols["go/doc/doc"] = map[string]reflect.Value{
// function, constant and variable definitions
"AllDecls": reflect.ValueOf(doc.AllDecls),
"AllMethods": reflect.ValueOf(doc.AllMethods),
"Examples": reflect.ValueOf(doc.Examples),
"IllegalPrefixes": reflect.ValueOf(&doc.IllegalPrefixes).Elem(),
"IsPredeclared": reflect.ValueOf(doc.IsPredeclared),
"New": reflect.ValueOf(doc.New),
"NewFromFiles": reflect.ValueOf(doc.NewFromFiles),
"PreserveAST": reflect.ValueOf(doc.PreserveAST),
"Synopsis": reflect.ValueOf(doc.Synopsis),
"ToHTML": reflect.ValueOf(doc.ToHTML),
"ToText": reflect.ValueOf(doc.ToText),
// type definitions
"Example": reflect.ValueOf((*doc.Example)(nil)),
"Filter": reflect.ValueOf((*doc.Filter)(nil)),
"Func": reflect.ValueOf((*doc.Func)(nil)),
"Mode": reflect.ValueOf((*doc.Mode)(nil)),
"Note": reflect.ValueOf((*doc.Note)(nil)),
"Package": reflect.ValueOf((*doc.Package)(nil)),
"Type": reflect.ValueOf((*doc.Type)(nil)),
"Value": reflect.ValueOf((*doc.Value)(nil)),
}
}
================================================
FILE: stdlib/go1_22_go_doc_comment.go
================================================
// Code generated by 'yaegi extract go/doc/comment'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"go/doc/comment"
"reflect"
)
func init() {
Symbols["go/doc/comment/comment"] = map[string]reflect.Value{
// function, constant and variable definitions
"DefaultLookupPackage": reflect.ValueOf(comment.DefaultLookupPackage),
// type definitions
"Block": reflect.ValueOf((*comment.Block)(nil)),
"Code": reflect.ValueOf((*comment.Code)(nil)),
"Doc": reflect.ValueOf((*comment.Doc)(nil)),
"DocLink": reflect.ValueOf((*comment.DocLink)(nil)),
"Heading": reflect.ValueOf((*comment.Heading)(nil)),
"Italic": reflect.ValueOf((*comment.Italic)(nil)),
"Link": reflect.ValueOf((*comment.Link)(nil)),
"LinkDef": reflect.ValueOf((*comment.LinkDef)(nil)),
"List": reflect.ValueOf((*comment.List)(nil)),
"ListItem": reflect.ValueOf((*comment.ListItem)(nil)),
"Paragraph": reflect.ValueOf((*comment.Paragraph)(nil)),
"Parser": reflect.ValueOf((*comment.Parser)(nil)),
"Plain": reflect.ValueOf((*comment.Plain)(nil)),
"Printer": reflect.ValueOf((*comment.Printer)(nil)),
"Text": reflect.ValueOf((*comment.Text)(nil)),
// interface wrapper definitions
"_Block": reflect.ValueOf((*_go_doc_comment_Block)(nil)),
"_Text": reflect.ValueOf((*_go_doc_comment_Text)(nil)),
}
}
// _go_doc_comment_Block is an interface wrapper for Block type
type _go_doc_comment_Block struct {
IValue interface{}
}
// _go_doc_comment_Text is an interface wrapper for Text type
type _go_doc_comment_Text struct {
IValue interface{}
}
================================================
FILE: stdlib/go1_22_go_format.go
================================================
// Code generated by 'yaegi extract go/format'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"go/format"
"reflect"
)
func init() {
Symbols["go/format/format"] = map[string]reflect.Value{
// function, constant and variable definitions
"Node": reflect.ValueOf(format.Node),
"Source": reflect.ValueOf(format.Source),
}
}
================================================
FILE: stdlib/go1_22_go_importer.go
================================================
// Code generated by 'yaegi extract go/importer'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"go/importer"
"reflect"
)
func init() {
Symbols["go/importer/importer"] = map[string]reflect.Value{
// function, constant and variable definitions
"Default": reflect.ValueOf(importer.Default),
"For": reflect.ValueOf(importer.For),
"ForCompiler": reflect.ValueOf(importer.ForCompiler),
// type definitions
"Lookup": reflect.ValueOf((*importer.Lookup)(nil)),
}
}
================================================
FILE: stdlib/go1_22_go_parser.go
================================================
// Code generated by 'yaegi extract go/parser'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"go/parser"
"reflect"
)
func init() {
Symbols["go/parser/parser"] = map[string]reflect.Value{
// function, constant and variable definitions
"AllErrors": reflect.ValueOf(parser.AllErrors),
"DeclarationErrors": reflect.ValueOf(parser.DeclarationErrors),
"ImportsOnly": reflect.ValueOf(parser.ImportsOnly),
"PackageClauseOnly": reflect.ValueOf(parser.PackageClauseOnly),
"ParseComments": reflect.ValueOf(parser.ParseComments),
"ParseDir": reflect.ValueOf(parser.ParseDir),
"ParseExpr": reflect.ValueOf(parser.ParseExpr),
"ParseExprFrom": reflect.ValueOf(parser.ParseExprFrom),
"ParseFile": reflect.ValueOf(parser.ParseFile),
"SkipObjectResolution": reflect.ValueOf(parser.SkipObjectResolution),
"SpuriousErrors": reflect.ValueOf(parser.SpuriousErrors),
"Trace": reflect.ValueOf(parser.Trace),
// type definitions
"Mode": reflect.ValueOf((*parser.Mode)(nil)),
}
}
================================================
FILE: stdlib/go1_22_go_printer.go
================================================
// Code generated by 'yaegi extract go/printer'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"go/printer"
"reflect"
)
func init() {
Symbols["go/printer/printer"] = map[string]reflect.Value{
// function, constant and variable definitions
"Fprint": reflect.ValueOf(printer.Fprint),
"RawFormat": reflect.ValueOf(printer.RawFormat),
"SourcePos": reflect.ValueOf(printer.SourcePos),
"TabIndent": reflect.ValueOf(printer.TabIndent),
"UseSpaces": reflect.ValueOf(printer.UseSpaces),
// type definitions
"CommentedNode": reflect.ValueOf((*printer.CommentedNode)(nil)),
"Config": reflect.ValueOf((*printer.Config)(nil)),
"Mode": reflect.ValueOf((*printer.Mode)(nil)),
}
}
================================================
FILE: stdlib/go1_22_go_scanner.go
================================================
// Code generated by 'yaegi extract go/scanner'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"go/scanner"
"reflect"
)
func init() {
Symbols["go/scanner/scanner"] = map[string]reflect.Value{
// function, constant and variable definitions
"PrintError": reflect.ValueOf(scanner.PrintError),
"ScanComments": reflect.ValueOf(scanner.ScanComments),
// type definitions
"Error": reflect.ValueOf((*scanner.Error)(nil)),
"ErrorHandler": reflect.ValueOf((*scanner.ErrorHandler)(nil)),
"ErrorList": reflect.ValueOf((*scanner.ErrorList)(nil)),
"Mode": reflect.ValueOf((*scanner.Mode)(nil)),
"Scanner": reflect.ValueOf((*scanner.Scanner)(nil)),
}
}
================================================
FILE: stdlib/go1_22_go_token.go
================================================
// Code generated by 'yaegi extract go/token'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"go/constant"
"go/token"
"reflect"
)
func init() {
Symbols["go/token/token"] = map[string]reflect.Value{
// function, constant and variable definitions
"ADD": reflect.ValueOf(token.ADD),
"ADD_ASSIGN": reflect.ValueOf(token.ADD_ASSIGN),
"AND": reflect.ValueOf(token.AND),
"AND_ASSIGN": reflect.ValueOf(token.AND_ASSIGN),
"AND_NOT": reflect.ValueOf(token.AND_NOT),
"AND_NOT_ASSIGN": reflect.ValueOf(token.AND_NOT_ASSIGN),
"ARROW": reflect.ValueOf(token.ARROW),
"ASSIGN": reflect.ValueOf(token.ASSIGN),
"BREAK": reflect.ValueOf(token.BREAK),
"CASE": reflect.ValueOf(token.CASE),
"CHAN": reflect.ValueOf(token.CHAN),
"CHAR": reflect.ValueOf(token.CHAR),
"COLON": reflect.ValueOf(token.COLON),
"COMMA": reflect.ValueOf(token.COMMA),
"COMMENT": reflect.ValueOf(token.COMMENT),
"CONST": reflect.ValueOf(token.CONST),
"CONTINUE": reflect.ValueOf(token.CONTINUE),
"DEC": reflect.ValueOf(token.DEC),
"DEFAULT": reflect.ValueOf(token.DEFAULT),
"DEFER": reflect.ValueOf(token.DEFER),
"DEFINE": reflect.ValueOf(token.DEFINE),
"ELLIPSIS": reflect.ValueOf(token.ELLIPSIS),
"ELSE": reflect.ValueOf(token.ELSE),
"EOF": reflect.ValueOf(token.EOF),
"EQL": reflect.ValueOf(token.EQL),
"FALLTHROUGH": reflect.ValueOf(token.FALLTHROUGH),
"FLOAT": reflect.ValueOf(token.FLOAT),
"FOR": reflect.ValueOf(token.FOR),
"FUNC": reflect.ValueOf(token.FUNC),
"GEQ": reflect.ValueOf(token.GEQ),
"GO": reflect.ValueOf(token.GO),
"GOTO": reflect.ValueOf(token.GOTO),
"GTR": reflect.ValueOf(token.GTR),
"HighestPrec": reflect.ValueOf(constant.MakeFromLiteral("7", token.INT, 0)),
"IDENT": reflect.ValueOf(token.IDENT),
"IF": reflect.ValueOf(token.IF),
"ILLEGAL": reflect.ValueOf(token.ILLEGAL),
"IMAG": reflect.ValueOf(token.IMAG),
"IMPORT": reflect.ValueOf(token.IMPORT),
"INC": reflect.ValueOf(token.INC),
"INT": reflect.ValueOf(token.INT),
"INTERFACE": reflect.ValueOf(token.INTERFACE),
"IsExported": reflect.ValueOf(token.IsExported),
"IsIdentifier": reflect.ValueOf(token.IsIdentifier),
"IsKeyword": reflect.ValueOf(token.IsKeyword),
"LAND": reflect.ValueOf(token.LAND),
"LBRACE": reflect.ValueOf(token.LBRACE),
"LBRACK": reflect.ValueOf(token.LBRACK),
"LEQ": reflect.ValueOf(token.LEQ),
"LOR": reflect.ValueOf(token.LOR),
"LPAREN": reflect.ValueOf(token.LPAREN),
"LSS": reflect.ValueOf(token.LSS),
"Lookup": reflect.ValueOf(token.Lookup),
"LowestPrec": reflect.ValueOf(constant.MakeFromLiteral("0", token.INT, 0)),
"MAP": reflect.ValueOf(token.MAP),
"MUL": reflect.ValueOf(token.MUL),
"MUL_ASSIGN": reflect.ValueOf(token.MUL_ASSIGN),
"NEQ": reflect.ValueOf(token.NEQ),
"NOT": reflect.ValueOf(token.NOT),
"NewFileSet": reflect.ValueOf(token.NewFileSet),
"NoPos": reflect.ValueOf(token.NoPos),
"OR": reflect.ValueOf(token.OR),
"OR_ASSIGN": reflect.ValueOf(token.OR_ASSIGN),
"PACKAGE": reflect.ValueOf(token.PACKAGE),
"PERIOD": reflect.ValueOf(token.PERIOD),
"QUO": reflect.ValueOf(token.QUO),
"QUO_ASSIGN": reflect.ValueOf(token.QUO_ASSIGN),
"RANGE": reflect.ValueOf(token.RANGE),
"RBRACE": reflect.ValueOf(token.RBRACE),
"RBRACK": reflect.ValueOf(token.RBRACK),
"REM": reflect.ValueOf(token.REM),
"REM_ASSIGN": reflect.ValueOf(token.REM_ASSIGN),
"RETURN": reflect.ValueOf(token.RETURN),
"RPAREN": reflect.ValueOf(token.RPAREN),
"SELECT": reflect.ValueOf(token.SELECT),
"SEMICOLON": reflect.ValueOf(token.SEMICOLON),
"SHL": reflect.ValueOf(token.SHL),
"SHL_ASSIGN": reflect.ValueOf(token.SHL_ASSIGN),
"SHR": reflect.ValueOf(token.SHR),
"SHR_ASSIGN": reflect.ValueOf(token.SHR_ASSIGN),
"STRING": reflect.ValueOf(token.STRING),
"STRUCT": reflect.ValueOf(token.STRUCT),
"SUB": reflect.ValueOf(token.SUB),
"SUB_ASSIGN": reflect.ValueOf(token.SUB_ASSIGN),
"SWITCH": reflect.ValueOf(token.SWITCH),
"TILDE": reflect.ValueOf(token.TILDE),
"TYPE": reflect.ValueOf(token.TYPE),
"UnaryPrec": reflect.ValueOf(constant.MakeFromLiteral("6", token.INT, 0)),
"VAR": reflect.ValueOf(token.VAR),
"XOR": reflect.ValueOf(token.XOR),
"XOR_ASSIGN": reflect.ValueOf(token.XOR_ASSIGN),
// type definitions
"File": reflect.ValueOf((*token.File)(nil)),
"FileSet": reflect.ValueOf((*token.FileSet)(nil)),
"Pos": reflect.ValueOf((*token.Pos)(nil)),
"Position": reflect.ValueOf((*token.Position)(nil)),
"Token": reflect.ValueOf((*token.Token)(nil)),
}
}
================================================
FILE: stdlib/go1_22_go_types.go
================================================
// Code generated by 'yaegi extract go/types'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"go/token"
"go/types"
"reflect"
)
func init() {
Symbols["go/types/types"] = map[string]reflect.Value{
// function, constant and variable definitions
"AssertableTo": reflect.ValueOf(types.AssertableTo),
"AssignableTo": reflect.ValueOf(types.AssignableTo),
"Bool": reflect.ValueOf(types.Bool),
"Byte": reflect.ValueOf(types.Byte),
"CheckExpr": reflect.ValueOf(types.CheckExpr),
"Comparable": reflect.ValueOf(types.Comparable),
"Complex128": reflect.ValueOf(types.Complex128),
"Complex64": reflect.ValueOf(types.Complex64),
"ConvertibleTo": reflect.ValueOf(types.ConvertibleTo),
"DefPredeclaredTestFuncs": reflect.ValueOf(types.DefPredeclaredTestFuncs),
"Default": reflect.ValueOf(types.Default),
"Eval": reflect.ValueOf(types.Eval),
"ExprString": reflect.ValueOf(types.ExprString),
"FieldVal": reflect.ValueOf(types.FieldVal),
"Float32": reflect.ValueOf(types.Float32),
"Float64": reflect.ValueOf(types.Float64),
"Id": reflect.ValueOf(types.Id),
"Identical": reflect.ValueOf(types.Identical),
"IdenticalIgnoreTags": reflect.ValueOf(types.IdenticalIgnoreTags),
"Implements": reflect.ValueOf(types.Implements),
"Instantiate": reflect.ValueOf(types.Instantiate),
"Int": reflect.ValueOf(types.Int),
"Int16": reflect.ValueOf(types.Int16),
"Int32": reflect.ValueOf(types.Int32),
"Int64": reflect.ValueOf(types.Int64),
"Int8": reflect.ValueOf(types.Int8),
"Invalid": reflect.ValueOf(types.Invalid),
"IsBoolean": reflect.ValueOf(types.IsBoolean),
"IsComplex": reflect.ValueOf(types.IsComplex),
"IsConstType": reflect.ValueOf(types.IsConstType),
"IsFloat": reflect.ValueOf(types.IsFloat),
"IsInteger": reflect.ValueOf(types.IsInteger),
"IsInterface": reflect.ValueOf(types.IsInterface),
"IsNumeric": reflect.ValueOf(types.IsNumeric),
"IsOrdered": reflect.ValueOf(types.IsOrdered),
"IsString": reflect.ValueOf(types.IsString),
"IsUnsigned": reflect.ValueOf(types.IsUnsigned),
"IsUntyped": reflect.ValueOf(types.IsUntyped),
"LookupFieldOrMethod": reflect.ValueOf(types.LookupFieldOrMethod),
"MethodExpr": reflect.ValueOf(types.MethodExpr),
"MethodVal": reflect.ValueOf(types.MethodVal),
"MissingMethod": reflect.ValueOf(types.MissingMethod),
"NewAlias": reflect.ValueOf(types.NewAlias),
"NewArray": reflect.ValueOf(types.NewArray),
"NewChan": reflect.ValueOf(types.NewChan),
"NewChecker": reflect.ValueOf(types.NewChecker),
"NewConst": reflect.ValueOf(types.NewConst),
"NewContext": reflect.ValueOf(types.NewContext),
"NewField": reflect.ValueOf(types.NewField),
"NewFunc": reflect.ValueOf(types.NewFunc),
"NewInterface": reflect.ValueOf(types.NewInterface),
"NewInterfaceType": reflect.ValueOf(types.NewInterfaceType),
"NewLabel": reflect.ValueOf(types.NewLabel),
"NewMap": reflect.ValueOf(types.NewMap),
"NewMethodSet": reflect.ValueOf(types.NewMethodSet),
"NewNamed": reflect.ValueOf(types.NewNamed),
"NewPackage": reflect.ValueOf(types.NewPackage),
"NewParam": reflect.ValueOf(types.NewParam),
"NewPkgName": reflect.ValueOf(types.NewPkgName),
"NewPointer": reflect.ValueOf(types.NewPointer),
"NewScope": reflect.ValueOf(types.NewScope),
"NewSignature": reflect.ValueOf(types.NewSignature),
"NewSignatureType": reflect.ValueOf(types.NewSignatureType),
"NewSlice": reflect.ValueOf(types.NewSlice),
"NewStruct": reflect.ValueOf(types.NewStruct),
"NewTerm": reflect.ValueOf(types.NewTerm),
"NewTuple": reflect.ValueOf(types.NewTuple),
"NewTypeName": reflect.ValueOf(types.NewTypeName),
"NewTypeParam": reflect.ValueOf(types.NewTypeParam),
"NewUnion": reflect.ValueOf(types.NewUnion),
"NewVar": reflect.ValueOf(types.NewVar),
"ObjectString": reflect.ValueOf(types.ObjectString),
"RecvOnly": reflect.ValueOf(types.RecvOnly),
"RelativeTo": reflect.ValueOf(types.RelativeTo),
"Rune": reflect.ValueOf(types.Rune),
"Satisfies": reflect.ValueOf(types.Satisfies),
"SelectionString": reflect.ValueOf(types.SelectionString),
"SendOnly": reflect.ValueOf(types.SendOnly),
"SendRecv": reflect.ValueOf(types.SendRecv),
"SizesFor": reflect.ValueOf(types.SizesFor),
"String": reflect.ValueOf(types.String),
"Typ": reflect.ValueOf(&types.Typ).Elem(),
"TypeString": reflect.ValueOf(types.TypeString),
"Uint": reflect.ValueOf(types.Uint),
"Uint16": reflect.ValueOf(types.Uint16),
"Uint32": reflect.ValueOf(types.Uint32),
"Uint64": reflect.ValueOf(types.Uint64),
"Uint8": reflect.ValueOf(types.Uint8),
"Uintptr": reflect.ValueOf(types.Uintptr),
"Unalias": reflect.ValueOf(types.Unalias),
"Universe": reflect.ValueOf(&types.Universe).Elem(),
"Unsafe": reflect.ValueOf(&types.Unsafe).Elem(),
"UnsafePointer": reflect.ValueOf(types.UnsafePointer),
"UntypedBool": reflect.ValueOf(types.UntypedBool),
"UntypedComplex": reflect.ValueOf(types.UntypedComplex),
"UntypedFloat": reflect.ValueOf(types.UntypedFloat),
"UntypedInt": reflect.ValueOf(types.UntypedInt),
"UntypedNil": reflect.ValueOf(types.UntypedNil),
"UntypedRune": reflect.ValueOf(types.UntypedRune),
"UntypedString": reflect.ValueOf(types.UntypedString),
"WriteExpr": reflect.ValueOf(types.WriteExpr),
"WriteSignature": reflect.ValueOf(types.WriteSignature),
"WriteType": reflect.ValueOf(types.WriteType),
// type definitions
"Alias": reflect.ValueOf((*types.Alias)(nil)),
"ArgumentError": reflect.ValueOf((*types.ArgumentError)(nil)),
"Array": reflect.ValueOf((*types.Array)(nil)),
"Basic": reflect.ValueOf((*types.Basic)(nil)),
"BasicInfo": reflect.ValueOf((*types.BasicInfo)(nil)),
"BasicKind": reflect.ValueOf((*types.BasicKind)(nil)),
"Builtin": reflect.ValueOf((*types.Builtin)(nil)),
"Chan": reflect.ValueOf((*types.Chan)(nil)),
"ChanDir": reflect.ValueOf((*types.ChanDir)(nil)),
"Checker": reflect.ValueOf((*types.Checker)(nil)),
"Config": reflect.ValueOf((*types.Config)(nil)),
"Const": reflect.ValueOf((*types.Const)(nil)),
"Context": reflect.ValueOf((*types.Context)(nil)),
"Error": reflect.ValueOf((*types.Error)(nil)),
"Func": reflect.ValueOf((*types.Func)(nil)),
"ImportMode": reflect.ValueOf((*types.ImportMode)(nil)),
"Importer": reflect.ValueOf((*types.Importer)(nil)),
"ImporterFrom": reflect.ValueOf((*types.ImporterFrom)(nil)),
"Info": reflect.ValueOf((*types.Info)(nil)),
"Initializer": reflect.ValueOf((*types.Initializer)(nil)),
"Instance": reflect.ValueOf((*types.Instance)(nil)),
"Interface": reflect.ValueOf((*types.Interface)(nil)),
"Label": reflect.ValueOf((*types.Label)(nil)),
"Map": reflect.ValueOf((*types.Map)(nil)),
"MethodSet": reflect.ValueOf((*types.MethodSet)(nil)),
"Named": reflect.ValueOf((*types.Named)(nil)),
"Nil": reflect.ValueOf((*types.Nil)(nil)),
"Object": reflect.ValueOf((*types.Object)(nil)),
"Package": reflect.ValueOf((*types.Package)(nil)),
"PkgName": reflect.ValueOf((*types.PkgName)(nil)),
"Pointer": reflect.ValueOf((*types.Pointer)(nil)),
"Qualifier": reflect.ValueOf((*types.Qualifier)(nil)),
"Scope": reflect.ValueOf((*types.Scope)(nil)),
"Selection": reflect.ValueOf((*types.Selection)(nil)),
"SelectionKind": reflect.ValueOf((*types.SelectionKind)(nil)),
"Signature": reflect.ValueOf((*types.Signature)(nil)),
"Sizes": reflect.ValueOf((*types.Sizes)(nil)),
"Slice": reflect.ValueOf((*types.Slice)(nil)),
"StdSizes": reflect.ValueOf((*types.StdSizes)(nil)),
"Struct": reflect.ValueOf((*types.Struct)(nil)),
"Term": reflect.ValueOf((*types.Term)(nil)),
"Tuple": reflect.ValueOf((*types.Tuple)(nil)),
"Type": reflect.ValueOf((*types.Type)(nil)),
"TypeAndValue": reflect.ValueOf((*types.TypeAndValue)(nil)),
"TypeList": reflect.ValueOf((*types.TypeList)(nil)),
"TypeName": reflect.ValueOf((*types.TypeName)(nil)),
"TypeParam": reflect.ValueOf((*types.TypeParam)(nil)),
"TypeParamList": reflect.ValueOf((*types.TypeParamList)(nil)),
"Union": reflect.ValueOf((*types.Union)(nil)),
"Var": reflect.ValueOf((*types.Var)(nil)),
// interface wrapper definitions
"_Importer": reflect.ValueOf((*_go_types_Importer)(nil)),
"_ImporterFrom": reflect.ValueOf((*_go_types_ImporterFrom)(nil)),
"_Object": reflect.ValueOf((*_go_types_Object)(nil)),
"_Sizes": reflect.ValueOf((*_go_types_Sizes)(nil)),
"_Type": reflect.ValueOf((*_go_types_Type)(nil)),
}
}
// _go_types_Importer is an interface wrapper for Importer type
type _go_types_Importer struct {
IValue interface{}
WImport func(path string) (*types.Package, error)
}
func (W _go_types_Importer) Import(path string) (*types.Package, error) { return W.WImport(path) }
// _go_types_ImporterFrom is an interface wrapper for ImporterFrom type
type _go_types_ImporterFrom struct {
IValue interface{}
WImport func(path string) (*types.Package, error)
WImportFrom func(path string, dir string, mode types.ImportMode) (*types.Package, error)
}
func (W _go_types_ImporterFrom) Import(path string) (*types.Package, error) { return W.WImport(path) }
func (W _go_types_ImporterFrom) ImportFrom(path string, dir string, mode types.ImportMode) (*types.Package, error) {
return W.WImportFrom(path, dir, mode)
}
// _go_types_Object is an interface wrapper for Object type
type _go_types_Object struct {
IValue interface{}
WExported func() bool
WId func() string
WName func() string
WParent func() *types.Scope
WPkg func() *types.Package
WPos func() token.Pos
WString func() string
WType func() types.Type
}
func (W _go_types_Object) Exported() bool { return W.WExported() }
func (W _go_types_Object) Id() string { return W.WId() }
func (W _go_types_Object) Name() string { return W.WName() }
func (W _go_types_Object) Parent() *types.Scope { return W.WParent() }
func (W _go_types_Object) Pkg() *types.Package { return W.WPkg() }
func (W _go_types_Object) Pos() token.Pos { return W.WPos() }
func (W _go_types_Object) String() string {
if W.WString == nil {
return ""
}
return W.WString()
}
func (W _go_types_Object) Type() types.Type { return W.WType() }
// _go_types_Sizes is an interface wrapper for Sizes type
type _go_types_Sizes struct {
IValue interface{}
WAlignof func(T types.Type) int64
WOffsetsof func(fields []*types.Var) []int64
WSizeof func(T types.Type) int64
}
func (W _go_types_Sizes) Alignof(T types.Type) int64 { return W.WAlignof(T) }
func (W _go_types_Sizes) Offsetsof(fields []*types.Var) []int64 { return W.WOffsetsof(fields) }
func (W _go_types_Sizes) Sizeof(T types.Type) int64 { return W.WSizeof(T) }
// _go_types_Type is an interface wrapper for Type type
type _go_types_Type struct {
IValue interface{}
WString func() string
WUnderlying func() types.Type
}
func (W _go_types_Type) String() string {
if W.WString == nil {
return ""
}
return W.WString()
}
func (W _go_types_Type) Underlying() types.Type { return W.WUnderlying() }
================================================
FILE: stdlib/go1_22_go_version.go
================================================
// Code generated by 'yaegi extract go/version'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"go/version"
"reflect"
)
func init() {
Symbols["go/version/version"] = map[string]reflect.Value{
// function, constant and variable definitions
"Compare": reflect.ValueOf(version.Compare),
"IsValid": reflect.ValueOf(version.IsValid),
"Lang": reflect.ValueOf(version.Lang),
}
}
================================================
FILE: stdlib/go1_22_hash.go
================================================
// Code generated by 'yaegi extract hash'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"hash"
"reflect"
)
func init() {
Symbols["hash/hash"] = map[string]reflect.Value{
// type definitions
"Hash": reflect.ValueOf((*hash.Hash)(nil)),
"Hash32": reflect.ValueOf((*hash.Hash32)(nil)),
"Hash64": reflect.ValueOf((*hash.Hash64)(nil)),
// interface wrapper definitions
"_Hash": reflect.ValueOf((*_hash_Hash)(nil)),
"_Hash32": reflect.ValueOf((*_hash_Hash32)(nil)),
"_Hash64": reflect.ValueOf((*_hash_Hash64)(nil)),
}
}
// _hash_Hash is an interface wrapper for Hash type
type _hash_Hash struct {
IValue interface{}
WBlockSize func() int
WReset func()
WSize func() int
WSum func(b []byte) []byte
WWrite func(p []byte) (n int, err error)
}
func (W _hash_Hash) BlockSize() int { return W.WBlockSize() }
func (W _hash_Hash) Reset() { W.WReset() }
func (W _hash_Hash) Size() int { return W.WSize() }
func (W _hash_Hash) Sum(b []byte) []byte { return W.WSum(b) }
func (W _hash_Hash) Write(p []byte) (n int, err error) { return W.WWrite(p) }
// _hash_Hash32 is an interface wrapper for Hash32 type
type _hash_Hash32 struct {
IValue interface{}
WBlockSize func() int
WReset func()
WSize func() int
WSum func(b []byte) []byte
WSum32 func() uint32
WWrite func(p []byte) (n int, err error)
}
func (W _hash_Hash32) BlockSize() int { return W.WBlockSize() }
func (W _hash_Hash32) Reset() { W.WReset() }
func (W _hash_Hash32) Size() int { return W.WSize() }
func (W _hash_Hash32) Sum(b []byte) []byte { return W.WSum(b) }
func (W _hash_Hash32) Sum32() uint32 { return W.WSum32() }
func (W _hash_Hash32) Write(p []byte) (n int, err error) { return W.WWrite(p) }
// _hash_Hash64 is an interface wrapper for Hash64 type
type _hash_Hash64 struct {
IValue interface{}
WBlockSize func() int
WReset func()
WSize func() int
WSum func(b []byte) []byte
WSum64 func() uint64
WWrite func(p []byte) (n int, err error)
}
func (W _hash_Hash64) BlockSize() int { return W.WBlockSize() }
func (W _hash_Hash64) Reset() { W.WReset() }
func (W _hash_Hash64) Size() int { return W.WSize() }
func (W _hash_Hash64) Sum(b []byte) []byte { return W.WSum(b) }
func (W _hash_Hash64) Sum64() uint64 { return W.WSum64() }
func (W _hash_Hash64) Write(p []byte) (n int, err error) { return W.WWrite(p) }
================================================
FILE: stdlib/go1_22_hash_adler32.go
================================================
// Code generated by 'yaegi extract hash/adler32'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"go/constant"
"go/token"
"hash/adler32"
"reflect"
)
func init() {
Symbols["hash/adler32/adler32"] = map[string]reflect.Value{
// function, constant and variable definitions
"Checksum": reflect.ValueOf(adler32.Checksum),
"New": reflect.ValueOf(adler32.New),
"Size": reflect.ValueOf(constant.MakeFromLiteral("4", token.INT, 0)),
}
}
================================================
FILE: stdlib/go1_22_hash_crc32.go
================================================
// Code generated by 'yaegi extract hash/crc32'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"go/constant"
"go/token"
"hash/crc32"
"reflect"
)
func init() {
Symbols["hash/crc32/crc32"] = map[string]reflect.Value{
// function, constant and variable definitions
"Castagnoli": reflect.ValueOf(constant.MakeFromLiteral("2197175160", token.INT, 0)),
"Checksum": reflect.ValueOf(crc32.Checksum),
"ChecksumIEEE": reflect.ValueOf(crc32.ChecksumIEEE),
"IEEE": reflect.ValueOf(constant.MakeFromLiteral("3988292384", token.INT, 0)),
"IEEETable": reflect.ValueOf(&crc32.IEEETable).Elem(),
"Koopman": reflect.ValueOf(constant.MakeFromLiteral("3945912366", token.INT, 0)),
"MakeTable": reflect.ValueOf(crc32.MakeTable),
"New": reflect.ValueOf(crc32.New),
"NewIEEE": reflect.ValueOf(crc32.NewIEEE),
"Size": reflect.ValueOf(constant.MakeFromLiteral("4", token.INT, 0)),
"Update": reflect.ValueOf(crc32.Update),
// type definitions
"Table": reflect.ValueOf((*crc32.Table)(nil)),
}
}
================================================
FILE: stdlib/go1_22_hash_crc64.go
================================================
// Code generated by 'yaegi extract hash/crc64'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"go/constant"
"go/token"
"hash/crc64"
"reflect"
)
func init() {
Symbols["hash/crc64/crc64"] = map[string]reflect.Value{
// function, constant and variable definitions
"Checksum": reflect.ValueOf(crc64.Checksum),
"ECMA": reflect.ValueOf(constant.MakeFromLiteral("14514072000185962306", token.INT, 0)),
"ISO": reflect.ValueOf(constant.MakeFromLiteral("15564440312192434176", token.INT, 0)),
"MakeTable": reflect.ValueOf(crc64.MakeTable),
"New": reflect.ValueOf(crc64.New),
"Size": reflect.ValueOf(constant.MakeFromLiteral("8", token.INT, 0)),
"Update": reflect.ValueOf(crc64.Update),
// type definitions
"Table": reflect.ValueOf((*crc64.Table)(nil)),
}
}
================================================
FILE: stdlib/go1_22_hash_fnv.go
================================================
// Code generated by 'yaegi extract hash/fnv'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"hash/fnv"
"reflect"
)
func init() {
Symbols["hash/fnv/fnv"] = map[string]reflect.Value{
// function, constant and variable definitions
"New128": reflect.ValueOf(fnv.New128),
"New128a": reflect.ValueOf(fnv.New128a),
"New32": reflect.ValueOf(fnv.New32),
"New32a": reflect.ValueOf(fnv.New32a),
"New64": reflect.ValueOf(fnv.New64),
"New64a": reflect.ValueOf(fnv.New64a),
}
}
================================================
FILE: stdlib/go1_22_hash_maphash.go
================================================
// Code generated by 'yaegi extract hash/maphash'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"hash/maphash"
"reflect"
)
func init() {
Symbols["hash/maphash/maphash"] = map[string]reflect.Value{
// function, constant and variable definitions
"Bytes": reflect.ValueOf(maphash.Bytes),
"MakeSeed": reflect.ValueOf(maphash.MakeSeed),
"String": reflect.ValueOf(maphash.String),
// type definitions
"Hash": reflect.ValueOf((*maphash.Hash)(nil)),
"Seed": reflect.ValueOf((*maphash.Seed)(nil)),
}
}
================================================
FILE: stdlib/go1_22_html.go
================================================
// Code generated by 'yaegi extract html'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"html"
"reflect"
)
func init() {
Symbols["html/html"] = map[string]reflect.Value{
// function, constant and variable definitions
"EscapeString": reflect.ValueOf(html.EscapeString),
"UnescapeString": reflect.ValueOf(html.UnescapeString),
}
}
================================================
FILE: stdlib/go1_22_html_template.go
================================================
// Code generated by 'yaegi extract html/template'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"html/template"
"reflect"
)
func init() {
Symbols["html/template/template"] = map[string]reflect.Value{
// function, constant and variable definitions
"ErrAmbigContext": reflect.ValueOf(template.ErrAmbigContext),
"ErrBadHTML": reflect.ValueOf(template.ErrBadHTML),
"ErrBranchEnd": reflect.ValueOf(template.ErrBranchEnd),
"ErrEndContext": reflect.ValueOf(template.ErrEndContext),
"ErrJSTemplate": reflect.ValueOf(template.ErrJSTemplate),
"ErrNoSuchTemplate": reflect.ValueOf(template.ErrNoSuchTemplate),
"ErrOutputContext": reflect.ValueOf(template.ErrOutputContext),
"ErrPartialCharset": reflect.ValueOf(template.ErrPartialCharset),
"ErrPartialEscape": reflect.ValueOf(template.ErrPartialEscape),
"ErrPredefinedEscaper": reflect.ValueOf(template.ErrPredefinedEscaper),
"ErrRangeLoopReentry": reflect.ValueOf(template.ErrRangeLoopReentry),
"ErrSlashAmbig": reflect.ValueOf(template.ErrSlashAmbig),
"HTMLEscape": reflect.ValueOf(template.HTMLEscape),
"HTMLEscapeString": reflect.ValueOf(template.HTMLEscapeString),
"HTMLEscaper": reflect.ValueOf(template.HTMLEscaper),
"IsTrue": reflect.ValueOf(template.IsTrue),
"JSEscape": reflect.ValueOf(template.JSEscape),
"JSEscapeString": reflect.ValueOf(template.JSEscapeString),
"JSEscaper": reflect.ValueOf(template.JSEscaper),
"Must": reflect.ValueOf(template.Must),
"New": reflect.ValueOf(template.New),
"OK": reflect.ValueOf(template.OK),
"ParseFS": reflect.ValueOf(template.ParseFS),
"ParseFiles": reflect.ValueOf(template.ParseFiles),
"ParseGlob": reflect.ValueOf(template.ParseGlob),
"URLQueryEscaper": reflect.ValueOf(template.URLQueryEscaper),
// type definitions
"CSS": reflect.ValueOf((*template.CSS)(nil)),
"Error": reflect.ValueOf((*template.Error)(nil)),
"ErrorCode": reflect.ValueOf((*template.ErrorCode)(nil)),
"FuncMap": reflect.ValueOf((*template.FuncMap)(nil)),
"HTML": reflect.ValueOf((*template.HTML)(nil)),
"HTMLAttr": reflect.ValueOf((*template.HTMLAttr)(nil)),
"JS": reflect.ValueOf((*template.JS)(nil)),
"JSStr": reflect.ValueOf((*template.JSStr)(nil)),
"Srcset": reflect.ValueOf((*template.Srcset)(nil)),
"Template": reflect.ValueOf((*template.Template)(nil)),
"URL": reflect.ValueOf((*template.URL)(nil)),
}
}
================================================
FILE: stdlib/go1_22_image.go
================================================
// Code generated by 'yaegi extract image'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"image"
"image/color"
"reflect"
)
func init() {
Symbols["image/image"] = map[string]reflect.Value{
// function, constant and variable definitions
"Black": reflect.ValueOf(&image.Black).Elem(),
"Decode": reflect.ValueOf(image.Decode),
"DecodeConfig": reflect.ValueOf(image.DecodeConfig),
"ErrFormat": reflect.ValueOf(&image.ErrFormat).Elem(),
"NewAlpha": reflect.ValueOf(image.NewAlpha),
"NewAlpha16": reflect.ValueOf(image.NewAlpha16),
"NewCMYK": reflect.ValueOf(image.NewCMYK),
"NewGray": reflect.ValueOf(image.NewGray),
"NewGray16": reflect.ValueOf(image.NewGray16),
"NewNRGBA": reflect.ValueOf(image.NewNRGBA),
"NewNRGBA64": reflect.ValueOf(image.NewNRGBA64),
"NewNYCbCrA": reflect.ValueOf(image.NewNYCbCrA),
"NewPaletted": reflect.ValueOf(image.NewPaletted),
"NewRGBA": reflect.ValueOf(image.NewRGBA),
"NewRGBA64": reflect.ValueOf(image.NewRGBA64),
"NewUniform": reflect.ValueOf(image.NewUniform),
"NewYCbCr": reflect.ValueOf(image.NewYCbCr),
"Opaque": reflect.ValueOf(&image.Opaque).Elem(),
"Pt": reflect.ValueOf(image.Pt),
"Rect": reflect.ValueOf(image.Rect),
"RegisterFormat": reflect.ValueOf(image.RegisterFormat),
"Transparent": reflect.ValueOf(&image.Transparent).Elem(),
"White": reflect.ValueOf(&image.White).Elem(),
"YCbCrSubsampleRatio410": reflect.ValueOf(image.YCbCrSubsampleRatio410),
"YCbCrSubsampleRatio411": reflect.ValueOf(image.YCbCrSubsampleRatio411),
"YCbCrSubsampleRatio420": reflect.ValueOf(image.YCbCrSubsampleRatio420),
"YCbCrSubsampleRatio422": reflect.ValueOf(image.YCbCrSubsampleRatio422),
"YCbCrSubsampleRatio440": reflect.ValueOf(image.YCbCrSubsampleRatio440),
"YCbCrSubsampleRatio444": reflect.ValueOf(image.YCbCrSubsampleRatio444),
"ZP": reflect.ValueOf(&image.ZP).Elem(),
"ZR": reflect.ValueOf(&image.ZR).Elem(),
// type definitions
"Alpha": reflect.ValueOf((*image.Alpha)(nil)),
"Alpha16": reflect.ValueOf((*image.Alpha16)(nil)),
"CMYK": reflect.ValueOf((*image.CMYK)(nil)),
"Config": reflect.ValueOf((*image.Config)(nil)),
"Gray": reflect.ValueOf((*image.Gray)(nil)),
"Gray16": reflect.ValueOf((*image.Gray16)(nil)),
"Image": reflect.ValueOf((*image.Image)(nil)),
"NRGBA": reflect.ValueOf((*image.NRGBA)(nil)),
"NRGBA64": reflect.ValueOf((*image.NRGBA64)(nil)),
"NYCbCrA": reflect.ValueOf((*image.NYCbCrA)(nil)),
"Paletted": reflect.ValueOf((*image.Paletted)(nil)),
"PalettedImage": reflect.ValueOf((*image.PalettedImage)(nil)),
"Point": reflect.ValueOf((*image.Point)(nil)),
"RGBA": reflect.ValueOf((*image.RGBA)(nil)),
"RGBA64": reflect.ValueOf((*image.RGBA64)(nil)),
"RGBA64Image": reflect.ValueOf((*image.RGBA64Image)(nil)),
"Rectangle": reflect.ValueOf((*image.Rectangle)(nil)),
"Uniform": reflect.ValueOf((*image.Uniform)(nil)),
"YCbCr": reflect.ValueOf((*image.YCbCr)(nil)),
"YCbCrSubsampleRatio": reflect.ValueOf((*image.YCbCrSubsampleRatio)(nil)),
// interface wrapper definitions
"_Image": reflect.ValueOf((*_image_Image)(nil)),
"_PalettedImage": reflect.ValueOf((*_image_PalettedImage)(nil)),
"_RGBA64Image": reflect.ValueOf((*_image_RGBA64Image)(nil)),
}
}
// _image_Image is an interface wrapper for Image type
type _image_Image struct {
IValue interface{}
WAt func(x int, y int) color.Color
WBounds func() image.Rectangle
WColorModel func() color.Model
}
func (W _image_Image) At(x int, y int) color.Color { return W.WAt(x, y) }
func (W _image_Image) Bounds() image.Rectangle { return W.WBounds() }
func (W _image_Image) ColorModel() color.Model { return W.WColorModel() }
// _image_PalettedImage is an interface wrapper for PalettedImage type
type _image_PalettedImage struct {
IValue interface{}
WAt func(x int, y int) color.Color
WBounds func() image.Rectangle
WColorIndexAt func(x int, y int) uint8
WColorModel func() color.Model
}
func (W _image_PalettedImage) At(x int, y int) color.Color { return W.WAt(x, y) }
func (W _image_PalettedImage) Bounds() image.Rectangle { return W.WBounds() }
func (W _image_PalettedImage) ColorIndexAt(x int, y int) uint8 { return W.WColorIndexAt(x, y) }
func (W _image_PalettedImage) ColorModel() color.Model { return W.WColorModel() }
// _image_RGBA64Image is an interface wrapper for RGBA64Image type
type _image_RGBA64Image struct {
IValue interface{}
WAt func(x int, y int) color.Color
WBounds func() image.Rectangle
WColorModel func() color.Model
WRGBA64At func(x int, y int) color.RGBA64
}
func (W _image_RGBA64Image) At(x int, y int) color.Color { return W.WAt(x, y) }
func (W _image_RGBA64Image) Bounds() image.Rectangle { return W.WBounds() }
func (W _image_RGBA64Image) ColorModel() color.Model { return W.WColorModel() }
func (W _image_RGBA64Image) RGBA64At(x int, y int) color.RGBA64 { return W.WRGBA64At(x, y) }
================================================
FILE: stdlib/go1_22_image_color.go
================================================
// Code generated by 'yaegi extract image/color'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"image/color"
"reflect"
)
func init() {
Symbols["image/color/color"] = map[string]reflect.Value{
// function, constant and variable definitions
"Alpha16Model": reflect.ValueOf(&color.Alpha16Model).Elem(),
"AlphaModel": reflect.ValueOf(&color.AlphaModel).Elem(),
"Black": reflect.ValueOf(&color.Black).Elem(),
"CMYKModel": reflect.ValueOf(&color.CMYKModel).Elem(),
"CMYKToRGB": reflect.ValueOf(color.CMYKToRGB),
"Gray16Model": reflect.ValueOf(&color.Gray16Model).Elem(),
"GrayModel": reflect.ValueOf(&color.GrayModel).Elem(),
"ModelFunc": reflect.ValueOf(color.ModelFunc),
"NRGBA64Model": reflect.ValueOf(&color.NRGBA64Model).Elem(),
"NRGBAModel": reflect.ValueOf(&color.NRGBAModel).Elem(),
"NYCbCrAModel": reflect.ValueOf(&color.NYCbCrAModel).Elem(),
"Opaque": reflect.ValueOf(&color.Opaque).Elem(),
"RGBA64Model": reflect.ValueOf(&color.RGBA64Model).Elem(),
"RGBAModel": reflect.ValueOf(&color.RGBAModel).Elem(),
"RGBToCMYK": reflect.ValueOf(color.RGBToCMYK),
"RGBToYCbCr": reflect.ValueOf(color.RGBToYCbCr),
"Transparent": reflect.ValueOf(&color.Transparent).Elem(),
"White": reflect.ValueOf(&color.White).Elem(),
"YCbCrModel": reflect.ValueOf(&color.YCbCrModel).Elem(),
"YCbCrToRGB": reflect.ValueOf(color.YCbCrToRGB),
// type definitions
"Alpha": reflect.ValueOf((*color.Alpha)(nil)),
"Alpha16": reflect.ValueOf((*color.Alpha16)(nil)),
"CMYK": reflect.ValueOf((*color.CMYK)(nil)),
"Color": reflect.ValueOf((*color.Color)(nil)),
"Gray": reflect.ValueOf((*color.Gray)(nil)),
"Gray16": reflect.ValueOf((*color.Gray16)(nil)),
"Model": reflect.ValueOf((*color.Model)(nil)),
"NRGBA": reflect.ValueOf((*color.NRGBA)(nil)),
"NRGBA64": reflect.ValueOf((*color.NRGBA64)(nil)),
"NYCbCrA": reflect.ValueOf((*color.NYCbCrA)(nil)),
"Palette": reflect.ValueOf((*color.Palette)(nil)),
"RGBA": reflect.ValueOf((*color.RGBA)(nil)),
"RGBA64": reflect.ValueOf((*color.RGBA64)(nil)),
"YCbCr": reflect.ValueOf((*color.YCbCr)(nil)),
// interface wrapper definitions
"_Color": reflect.ValueOf((*_image_color_Color)(nil)),
"_Model": reflect.ValueOf((*_image_color_Model)(nil)),
}
}
// _image_color_Color is an interface wrapper for Color type
type _image_color_Color struct {
IValue interface{}
WRGBA func() (r uint32, g uint32, b uint32, a uint32)
}
func (W _image_color_Color) RGBA() (r uint32, g uint32, b uint32, a uint32) { return W.WRGBA() }
// _image_color_Model is an interface wrapper for Model type
type _image_color_Model struct {
IValue interface{}
WConvert func(c color.Color) color.Color
}
func (W _image_color_Model) Convert(c color.Color) color.Color { return W.WConvert(c) }
================================================
FILE: stdlib/go1_22_image_color_palette.go
================================================
// Code generated by 'yaegi extract image/color/palette'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"image/color/palette"
"reflect"
)
func init() {
Symbols["image/color/palette/palette"] = map[string]reflect.Value{
// function, constant and variable definitions
"Plan9": reflect.ValueOf(&palette.Plan9).Elem(),
"WebSafe": reflect.ValueOf(&palette.WebSafe).Elem(),
}
}
================================================
FILE: stdlib/go1_22_image_draw.go
================================================
// Code generated by 'yaegi extract image/draw'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"image"
"image/color"
"image/draw"
"reflect"
)
func init() {
Symbols["image/draw/draw"] = map[string]reflect.Value{
// function, constant and variable definitions
"Draw": reflect.ValueOf(draw.Draw),
"DrawMask": reflect.ValueOf(draw.DrawMask),
"FloydSteinberg": reflect.ValueOf(&draw.FloydSteinberg).Elem(),
"Over": reflect.ValueOf(draw.Over),
"Src": reflect.ValueOf(draw.Src),
// type definitions
"Drawer": reflect.ValueOf((*draw.Drawer)(nil)),
"Image": reflect.ValueOf((*draw.Image)(nil)),
"Op": reflect.ValueOf((*draw.Op)(nil)),
"Quantizer": reflect.ValueOf((*draw.Quantizer)(nil)),
"RGBA64Image": reflect.ValueOf((*draw.RGBA64Image)(nil)),
// interface wrapper definitions
"_Drawer": reflect.ValueOf((*_image_draw_Drawer)(nil)),
"_Image": reflect.ValueOf((*_image_draw_Image)(nil)),
"_Quantizer": reflect.ValueOf((*_image_draw_Quantizer)(nil)),
"_RGBA64Image": reflect.ValueOf((*_image_draw_RGBA64Image)(nil)),
}
}
// _image_draw_Drawer is an interface wrapper for Drawer type
type _image_draw_Drawer struct {
IValue interface{}
WDraw func(dst draw.Image, r image.Rectangle, src image.Image, sp image.Point)
}
func (W _image_draw_Drawer) Draw(dst draw.Image, r image.Rectangle, src image.Image, sp image.Point) {
W.WDraw(dst, r, src, sp)
}
// _image_draw_Image is an interface wrapper for Image type
type _image_draw_Image struct {
IValue interface{}
WAt func(x int, y int) color.Color
WBounds func() image.Rectangle
WColorModel func() color.Model
WSet func(x int, y int, c color.Color)
}
func (W _image_draw_Image) At(x int, y int) color.Color { return W.WAt(x, y) }
func (W _image_draw_Image) Bounds() image.Rectangle { return W.WBounds() }
func (W _image_draw_Image) ColorModel() color.Model { return W.WColorModel() }
func (W _image_draw_Image) Set(x int, y int, c color.Color) { W.WSet(x, y, c) }
// _image_draw_Quantizer is an interface wrapper for Quantizer type
type _image_draw_Quantizer struct {
IValue interface{}
WQuantize func(p color.Palette, m image.Image) color.Palette
}
func (W _image_draw_Quantizer) Quantize(p color.Palette, m image.Image) color.Palette {
return W.WQuantize(p, m)
}
// _image_draw_RGBA64Image is an interface wrapper for RGBA64Image type
type _image_draw_RGBA64Image struct {
IValue interface{}
WAt func(x int, y int) color.Color
WBounds func() image.Rectangle
WColorModel func() color.Model
WRGBA64At func(x int, y int) color.RGBA64
WSet func(x int, y int, c color.Color)
WSetRGBA64 func(x int, y int, c color.RGBA64)
}
func (W _image_draw_RGBA64Image) At(x int, y int) color.Color { return W.WAt(x, y) }
func (W _image_draw_RGBA64Image) Bounds() image.Rectangle { return W.WBounds() }
func (W _image_draw_RGBA64Image) ColorModel() color.Model { return W.WColorModel() }
func (W _image_draw_RGBA64Image) RGBA64At(x int, y int) color.RGBA64 { return W.WRGBA64At(x, y) }
func (W _image_draw_RGBA64Image) Set(x int, y int, c color.Color) { W.WSet(x, y, c) }
func (W _image_draw_RGBA64Image) SetRGBA64(x int, y int, c color.RGBA64) { W.WSetRGBA64(x, y, c) }
================================================
FILE: stdlib/go1_22_image_gif.go
================================================
// Code generated by 'yaegi extract image/gif'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"go/constant"
"go/token"
"image/gif"
"reflect"
)
func init() {
Symbols["image/gif/gif"] = map[string]reflect.Value{
// function, constant and variable definitions
"Decode": reflect.ValueOf(gif.Decode),
"DecodeAll": reflect.ValueOf(gif.DecodeAll),
"DecodeConfig": reflect.ValueOf(gif.DecodeConfig),
"DisposalBackground": reflect.ValueOf(constant.MakeFromLiteral("2", token.INT, 0)),
"DisposalNone": reflect.ValueOf(constant.MakeFromLiteral("1", token.INT, 0)),
"DisposalPrevious": reflect.ValueOf(constant.MakeFromLiteral("3", token.INT, 0)),
"Encode": reflect.ValueOf(gif.Encode),
"EncodeAll": reflect.ValueOf(gif.EncodeAll),
// type definitions
"GIF": reflect.ValueOf((*gif.GIF)(nil)),
"Options": reflect.ValueOf((*gif.Options)(nil)),
}
}
================================================
FILE: stdlib/go1_22_image_jpeg.go
================================================
// Code generated by 'yaegi extract image/jpeg'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"go/constant"
"go/token"
"image/jpeg"
"reflect"
)
func init() {
Symbols["image/jpeg/jpeg"] = map[string]reflect.Value{
// function, constant and variable definitions
"Decode": reflect.ValueOf(jpeg.Decode),
"DecodeConfig": reflect.ValueOf(jpeg.DecodeConfig),
"DefaultQuality": reflect.ValueOf(constant.MakeFromLiteral("75", token.INT, 0)),
"Encode": reflect.ValueOf(jpeg.Encode),
// type definitions
"FormatError": reflect.ValueOf((*jpeg.FormatError)(nil)),
"Options": reflect.ValueOf((*jpeg.Options)(nil)),
"Reader": reflect.ValueOf((*jpeg.Reader)(nil)),
"UnsupportedError": reflect.ValueOf((*jpeg.UnsupportedError)(nil)),
// interface wrapper definitions
"_Reader": reflect.ValueOf((*_image_jpeg_Reader)(nil)),
}
}
// _image_jpeg_Reader is an interface wrapper for Reader type
type _image_jpeg_Reader struct {
IValue interface{}
WRead func(p []byte) (n int, err error)
WReadByte func() (byte, error)
}
func (W _image_jpeg_Reader) Read(p []byte) (n int, err error) { return W.WRead(p) }
func (W _image_jpeg_Reader) ReadByte() (byte, error) { return W.WReadByte() }
================================================
FILE: stdlib/go1_22_image_png.go
================================================
// Code generated by 'yaegi extract image/png'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"image/png"
"reflect"
)
func init() {
Symbols["image/png/png"] = map[string]reflect.Value{
// function, constant and variable definitions
"BestCompression": reflect.ValueOf(png.BestCompression),
"BestSpeed": reflect.ValueOf(png.BestSpeed),
"Decode": reflect.ValueOf(png.Decode),
"DecodeConfig": reflect.ValueOf(png.DecodeConfig),
"DefaultCompression": reflect.ValueOf(png.DefaultCompression),
"Encode": reflect.ValueOf(png.Encode),
"NoCompression": reflect.ValueOf(png.NoCompression),
// type definitions
"CompressionLevel": reflect.ValueOf((*png.CompressionLevel)(nil)),
"Encoder": reflect.ValueOf((*png.Encoder)(nil)),
"EncoderBuffer": reflect.ValueOf((*png.EncoderBuffer)(nil)),
"EncoderBufferPool": reflect.ValueOf((*png.EncoderBufferPool)(nil)),
"FormatError": reflect.ValueOf((*png.FormatError)(nil)),
"UnsupportedError": reflect.ValueOf((*png.UnsupportedError)(nil)),
// interface wrapper definitions
"_EncoderBufferPool": reflect.ValueOf((*_image_png_EncoderBufferPool)(nil)),
}
}
// _image_png_EncoderBufferPool is an interface wrapper for EncoderBufferPool type
type _image_png_EncoderBufferPool struct {
IValue interface{}
WGet func() *png.EncoderBuffer
WPut func(a0 *png.EncoderBuffer)
}
func (W _image_png_EncoderBufferPool) Get() *png.EncoderBuffer { return W.WGet() }
func (W _image_png_EncoderBufferPool) Put(a0 *png.EncoderBuffer) { W.WPut(a0) }
================================================
FILE: stdlib/go1_22_index_suffixarray.go
================================================
// Code generated by 'yaegi extract index/suffixarray'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"index/suffixarray"
"reflect"
)
func init() {
Symbols["index/suffixarray/suffixarray"] = map[string]reflect.Value{
// function, constant and variable definitions
"New": reflect.ValueOf(suffixarray.New),
// type definitions
"Index": reflect.ValueOf((*suffixarray.Index)(nil)),
}
}
================================================
FILE: stdlib/go1_22_io.go
================================================
// Code generated by 'yaegi extract io'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"go/constant"
"go/token"
"io"
"reflect"
)
func init() {
Symbols["io/io"] = map[string]reflect.Value{
// function, constant and variable definitions
"Copy": reflect.ValueOf(io.Copy),
"CopyBuffer": reflect.ValueOf(io.CopyBuffer),
"CopyN": reflect.ValueOf(io.CopyN),
"Discard": reflect.ValueOf(&io.Discard).Elem(),
"EOF": reflect.ValueOf(&io.EOF).Elem(),
"ErrClosedPipe": reflect.ValueOf(&io.ErrClosedPipe).Elem(),
"ErrNoProgress": reflect.ValueOf(&io.ErrNoProgress).Elem(),
"ErrShortBuffer": reflect.ValueOf(&io.ErrShortBuffer).Elem(),
"ErrShortWrite": reflect.ValueOf(&io.ErrShortWrite).Elem(),
"ErrUnexpectedEOF": reflect.ValueOf(&io.ErrUnexpectedEOF).Elem(),
"LimitReader": reflect.ValueOf(io.LimitReader),
"MultiReader": reflect.ValueOf(io.MultiReader),
"MultiWriter": reflect.ValueOf(io.MultiWriter),
"NewOffsetWriter": reflect.ValueOf(io.NewOffsetWriter),
"NewSectionReader": reflect.ValueOf(io.NewSectionReader),
"NopCloser": reflect.ValueOf(io.NopCloser),
"Pipe": reflect.ValueOf(io.Pipe),
"ReadAll": reflect.ValueOf(io.ReadAll),
"ReadAtLeast": reflect.ValueOf(io.ReadAtLeast),
"ReadFull": reflect.ValueOf(io.ReadFull),
"SeekCurrent": reflect.ValueOf(constant.MakeFromLiteral("1", token.INT, 0)),
"SeekEnd": reflect.ValueOf(constant.MakeFromLiteral("2", token.INT, 0)),
"SeekStart": reflect.ValueOf(constant.MakeFromLiteral("0", token.INT, 0)),
"TeeReader": reflect.ValueOf(io.TeeReader),
"WriteString": reflect.ValueOf(io.WriteString),
// type definitions
"ByteReader": reflect.ValueOf((*io.ByteReader)(nil)),
"ByteScanner": reflect.ValueOf((*io.ByteScanner)(nil)),
"ByteWriter": reflect.ValueOf((*io.ByteWriter)(nil)),
"Closer": reflect.ValueOf((*io.Closer)(nil)),
"LimitedReader": reflect.ValueOf((*io.LimitedReader)(nil)),
"OffsetWriter": reflect.ValueOf((*io.OffsetWriter)(nil)),
"PipeReader": reflect.ValueOf((*io.PipeReader)(nil)),
"PipeWriter": reflect.ValueOf((*io.PipeWriter)(nil)),
"ReadCloser": reflect.ValueOf((*io.ReadCloser)(nil)),
"ReadSeekCloser": reflect.ValueOf((*io.ReadSeekCloser)(nil)),
"ReadSeeker": reflect.ValueOf((*io.ReadSeeker)(nil)),
"ReadWriteCloser": reflect.ValueOf((*io.ReadWriteCloser)(nil)),
"ReadWriteSeeker": reflect.ValueOf((*io.ReadWriteSeeker)(nil)),
"ReadWriter": reflect.ValueOf((*io.ReadWriter)(nil)),
"Reader": reflect.ValueOf((*io.Reader)(nil)),
"ReaderAt": reflect.ValueOf((*io.ReaderAt)(nil)),
"ReaderFrom": reflect.ValueOf((*io.ReaderFrom)(nil)),
"RuneReader": reflect.ValueOf((*io.RuneReader)(nil)),
"RuneScanner": reflect.ValueOf((*io.RuneScanner)(nil)),
"SectionReader": reflect.ValueOf((*io.SectionReader)(nil)),
"Seeker": reflect.ValueOf((*io.Seeker)(nil)),
"StringWriter": reflect.ValueOf((*io.StringWriter)(nil)),
"WriteCloser": reflect.ValueOf((*io.WriteCloser)(nil)),
"WriteSeeker": reflect.ValueOf((*io.WriteSeeker)(nil)),
"Writer": reflect.ValueOf((*io.Writer)(nil)),
"WriterAt": reflect.ValueOf((*io.WriterAt)(nil)),
"WriterTo": reflect.ValueOf((*io.WriterTo)(nil)),
// interface wrapper definitions
"_ByteReader": reflect.ValueOf((*_io_ByteReader)(nil)),
"_ByteScanner": reflect.ValueOf((*_io_ByteScanner)(nil)),
"_ByteWriter": reflect.ValueOf((*_io_ByteWriter)(nil)),
"_Closer": reflect.ValueOf((*_io_Closer)(nil)),
"_ReadCloser": reflect.ValueOf((*_io_ReadCloser)(nil)),
"_ReadSeekCloser": reflect.ValueOf((*_io_ReadSeekCloser)(nil)),
"_ReadSeeker": reflect.ValueOf((*_io_ReadSeeker)(nil)),
"_ReadWriteCloser": reflect.ValueOf((*_io_ReadWriteCloser)(nil)),
"_ReadWriteSeeker": reflect.ValueOf((*_io_ReadWriteSeeker)(nil)),
"_ReadWriter": reflect.ValueOf((*_io_ReadWriter)(nil)),
"_Reader": reflect.ValueOf((*_io_Reader)(nil)),
"_ReaderAt": reflect.ValueOf((*_io_ReaderAt)(nil)),
"_ReaderFrom": reflect.ValueOf((*_io_ReaderFrom)(nil)),
"_RuneReader": reflect.ValueOf((*_io_RuneReader)(nil)),
"_RuneScanner": reflect.ValueOf((*_io_RuneScanner)(nil)),
"_Seeker": reflect.ValueOf((*_io_Seeker)(nil)),
"_StringWriter": reflect.ValueOf((*_io_StringWriter)(nil)),
"_WriteCloser": reflect.ValueOf((*_io_WriteCloser)(nil)),
"_WriteSeeker": reflect.ValueOf((*_io_WriteSeeker)(nil)),
"_Writer": reflect.ValueOf((*_io_Writer)(nil)),
"_WriterAt": reflect.ValueOf((*_io_WriterAt)(nil)),
"_WriterTo": reflect.ValueOf((*_io_WriterTo)(nil)),
}
}
// _io_ByteReader is an interface wrapper for ByteReader type
type _io_ByteReader struct {
IValue interface{}
WReadByte func() (byte, error)
}
func (W _io_ByteReader) ReadByte() (byte, error) { return W.WReadByte() }
// _io_ByteScanner is an interface wrapper for ByteScanner type
type _io_ByteScanner struct {
IValue interface{}
WReadByte func() (byte, error)
WUnreadByte func() error
}
func (W _io_ByteScanner) ReadByte() (byte, error) { return W.WReadByte() }
func (W _io_ByteScanner) UnreadByte() error { return W.WUnreadByte() }
// _io_ByteWriter is an interface wrapper for ByteWriter type
type _io_ByteWriter struct {
IValue interface{}
WWriteByte func(c byte) error
}
func (W _io_ByteWriter) WriteByte(c byte) error { return W.WWriteByte(c) }
// _io_Closer is an interface wrapper for Closer type
type _io_Closer struct {
IValue interface{}
WClose func() error
}
func (W _io_Closer) Close() error { return W.WClose() }
// _io_ReadCloser is an interface wrapper for ReadCloser type
type _io_ReadCloser struct {
IValue interface{}
WClose func() error
WRead func(p []byte) (n int, err error)
}
func (W _io_ReadCloser) Close() error { return W.WClose() }
func (W _io_ReadCloser) Read(p []byte) (n int, err error) { return W.WRead(p) }
// _io_ReadSeekCloser is an interface wrapper for ReadSeekCloser type
type _io_ReadSeekCloser struct {
IValue interface{}
WClose func() error
WRead func(p []byte) (n int, err error)
WSeek func(offset int64, whence int) (int64, error)
}
func (W _io_ReadSeekCloser) Close() error { return W.WClose() }
func (W _io_ReadSeekCloser) Read(p []byte) (n int, err error) { return W.WRead(p) }
func (W _io_ReadSeekCloser) Seek(offset int64, whence int) (int64, error) {
return W.WSeek(offset, whence)
}
// _io_ReadSeeker is an interface wrapper for ReadSeeker type
type _io_ReadSeeker struct {
IValue interface{}
WRead func(p []byte) (n int, err error)
WSeek func(offset int64, whence int) (int64, error)
}
func (W _io_ReadSeeker) Read(p []byte) (n int, err error) { return W.WRead(p) }
func (W _io_ReadSeeker) Seek(offset int64, whence int) (int64, error) { return W.WSeek(offset, whence) }
// _io_ReadWriteCloser is an interface wrapper for ReadWriteCloser type
type _io_ReadWriteCloser struct {
IValue interface{}
WClose func() error
WRead func(p []byte) (n int, err error)
WWrite func(p []byte) (n int, err error)
}
func (W _io_ReadWriteCloser) Close() error { return W.WClose() }
func (W _io_ReadWriteCloser) Read(p []byte) (n int, err error) { return W.WRead(p) }
func (W _io_ReadWriteCloser) Write(p []byte) (n int, err error) { return W.WWrite(p) }
// _io_ReadWriteSeeker is an interface wrapper for ReadWriteSeeker type
type _io_ReadWriteSeeker struct {
IValue interface{}
WRead func(p []byte) (n int, err error)
WSeek func(offset int64, whence int) (int64, error)
WWrite func(p []byte) (n int, err error)
}
func (W _io_ReadWriteSeeker) Read(p []byte) (n int, err error) { return W.WRead(p) }
func (W _io_ReadWriteSeeker) Seek(offset int64, whence int) (int64, error) {
return W.WSeek(offset, whence)
}
func (W _io_ReadWriteSeeker) Write(p []byte) (n int, err error) { return W.WWrite(p) }
// _io_ReadWriter is an interface wrapper for ReadWriter type
type _io_ReadWriter struct {
IValue interface{}
WRead func(p []byte) (n int, err error)
WWrite func(p []byte) (n int, err error)
}
func (W _io_ReadWriter) Read(p []byte) (n int, err error) { return W.WRead(p) }
func (W _io_ReadWriter) Write(p []byte) (n int, err error) { return W.WWrite(p) }
// _io_Reader is an interface wrapper for Reader type
type _io_Reader struct {
IValue interface{}
WRead func(p []byte) (n int, err error)
}
func (W _io_Reader) Read(p []byte) (n int, err error) { return W.WRead(p) }
// _io_ReaderAt is an interface wrapper for ReaderAt type
type _io_ReaderAt struct {
IValue interface{}
WReadAt func(p []byte, off int64) (n int, err error)
}
func (W _io_ReaderAt) ReadAt(p []byte, off int64) (n int, err error) { return W.WReadAt(p, off) }
// _io_ReaderFrom is an interface wrapper for ReaderFrom type
type _io_ReaderFrom struct {
IValue interface{}
WReadFrom func(r io.Reader) (n int64, err error)
}
func (W _io_ReaderFrom) ReadFrom(r io.Reader) (n int64, err error) { return W.WReadFrom(r) }
// _io_RuneReader is an interface wrapper for RuneReader type
type _io_RuneReader struct {
IValue interface{}
WReadRune func() (r rune, size int, err error)
}
func (W _io_RuneReader) ReadRune() (r rune, size int, err error) { return W.WReadRune() }
// _io_RuneScanner is an interface wrapper for RuneScanner type
type _io_RuneScanner struct {
IValue interface{}
WReadRune func() (r rune, size int, err error)
WUnreadRune func() error
}
func (W _io_RuneScanner) ReadRune() (r rune, size int, err error) { return W.WReadRune() }
func (W _io_RuneScanner) UnreadRune() error { return W.WUnreadRune() }
// _io_Seeker is an interface wrapper for Seeker type
type _io_Seeker struct {
IValue interface{}
WSeek func(offset int64, whence int) (int64, error)
}
func (W _io_Seeker) Seek(offset int64, whence int) (int64, error) { return W.WSeek(offset, whence) }
// _io_StringWriter is an interface wrapper for StringWriter type
type _io_StringWriter struct {
IValue interface{}
WWriteString func(s string) (n int, err error)
}
func (W _io_StringWriter) WriteString(s string) (n int, err error) { return W.WWriteString(s) }
// _io_WriteCloser is an interface wrapper for WriteCloser type
type _io_WriteCloser struct {
IValue interface{}
WClose func() error
WWrite func(p []byte) (n int, err error)
}
func (W _io_WriteCloser) Close() error { return W.WClose() }
func (W _io_WriteCloser) Write(p []byte) (n int, err error) { return W.WWrite(p) }
// _io_WriteSeeker is an interface wrapper for WriteSeeker type
type _io_WriteSeeker struct {
IValue interface{}
WSeek func(offset int64, whence int) (int64, error)
WWrite func(p []byte) (n int, err error)
}
func (W _io_WriteSeeker) Seek(offset int64, whence int) (int64, error) {
return W.WSeek(offset, whence)
}
func (W _io_WriteSeeker) Write(p []byte) (n int, err error) { return W.WWrite(p) }
// _io_Writer is an interface wrapper for Writer type
type _io_Writer struct {
IValue interface{}
WWrite func(p []byte) (n int, err error)
}
func (W _io_Writer) Write(p []byte) (n int, err error) { return W.WWrite(p) }
// _io_WriterAt is an interface wrapper for WriterAt type
type _io_WriterAt struct {
IValue interface{}
WWriteAt func(p []byte, off int64) (n int, err error)
}
func (W _io_WriterAt) WriteAt(p []byte, off int64) (n int, err error) { return W.WWriteAt(p, off) }
// _io_WriterTo is an interface wrapper for WriterTo type
type _io_WriterTo struct {
IValue interface{}
WWriteTo func(w io.Writer) (n int64, err error)
}
func (W _io_WriterTo) WriteTo(w io.Writer) (n int64, err error) { return W.WWriteTo(w) }
================================================
FILE: stdlib/go1_22_io_fs.go
================================================
// Code generated by 'yaegi extract io/fs'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"io/fs"
"reflect"
"time"
)
func init() {
Symbols["io/fs/fs"] = map[string]reflect.Value{
// function, constant and variable definitions
"ErrClosed": reflect.ValueOf(&fs.ErrClosed).Elem(),
"ErrExist": reflect.ValueOf(&fs.ErrExist).Elem(),
"ErrInvalid": reflect.ValueOf(&fs.ErrInvalid).Elem(),
"ErrNotExist": reflect.ValueOf(&fs.ErrNotExist).Elem(),
"ErrPermission": reflect.ValueOf(&fs.ErrPermission).Elem(),
"FileInfoToDirEntry": reflect.ValueOf(fs.FileInfoToDirEntry),
"FormatDirEntry": reflect.ValueOf(fs.FormatDirEntry),
"FormatFileInfo": reflect.ValueOf(fs.FormatFileInfo),
"Glob": reflect.ValueOf(fs.Glob),
"ModeAppend": reflect.ValueOf(fs.ModeAppend),
"ModeCharDevice": reflect.ValueOf(fs.ModeCharDevice),
"ModeDevice": reflect.ValueOf(fs.ModeDevice),
"ModeDir": reflect.ValueOf(fs.ModeDir),
"ModeExclusive": reflect.ValueOf(fs.ModeExclusive),
"ModeIrregular": reflect.ValueOf(fs.ModeIrregular),
"ModeNamedPipe": reflect.ValueOf(fs.ModeNamedPipe),
"ModePerm": reflect.ValueOf(fs.ModePerm),
"ModeSetgid": reflect.ValueOf(fs.ModeSetgid),
"ModeSetuid": reflect.ValueOf(fs.ModeSetuid),
"ModeSocket": reflect.ValueOf(fs.ModeSocket),
"ModeSticky": reflect.ValueOf(fs.ModeSticky),
"ModeSymlink": reflect.ValueOf(fs.ModeSymlink),
"ModeTemporary": reflect.ValueOf(fs.ModeTemporary),
"ModeType": reflect.ValueOf(fs.ModeType),
"ReadDir": reflect.ValueOf(fs.ReadDir),
"ReadFile": reflect.ValueOf(fs.ReadFile),
"SkipAll": reflect.ValueOf(&fs.SkipAll).Elem(),
"SkipDir": reflect.ValueOf(&fs.SkipDir).Elem(),
"Stat": reflect.ValueOf(fs.Stat),
"Sub": reflect.ValueOf(fs.Sub),
"ValidPath": reflect.ValueOf(fs.ValidPath),
"WalkDir": reflect.ValueOf(fs.WalkDir),
// type definitions
"DirEntry": reflect.ValueOf((*fs.DirEntry)(nil)),
"FS": reflect.ValueOf((*fs.FS)(nil)),
"File": reflect.ValueOf((*fs.File)(nil)),
"FileInfo": reflect.ValueOf((*fs.FileInfo)(nil)),
"FileMode": reflect.ValueOf((*fs.FileMode)(nil)),
"GlobFS": reflect.ValueOf((*fs.GlobFS)(nil)),
"PathError": reflect.ValueOf((*fs.PathError)(nil)),
"ReadDirFS": reflect.ValueOf((*fs.ReadDirFS)(nil)),
"ReadDirFile": reflect.ValueOf((*fs.ReadDirFile)(nil)),
"ReadFileFS": reflect.ValueOf((*fs.ReadFileFS)(nil)),
"StatFS": reflect.ValueOf((*fs.StatFS)(nil)),
"SubFS": reflect.ValueOf((*fs.SubFS)(nil)),
"WalkDirFunc": reflect.ValueOf((*fs.WalkDirFunc)(nil)),
// interface wrapper definitions
"_DirEntry": reflect.ValueOf((*_io_fs_DirEntry)(nil)),
"_FS": reflect.ValueOf((*_io_fs_FS)(nil)),
"_File": reflect.ValueOf((*_io_fs_File)(nil)),
"_FileInfo": reflect.ValueOf((*_io_fs_FileInfo)(nil)),
"_GlobFS": reflect.ValueOf((*_io_fs_GlobFS)(nil)),
"_ReadDirFS": reflect.ValueOf((*_io_fs_ReadDirFS)(nil)),
"_ReadDirFile": reflect.ValueOf((*_io_fs_ReadDirFile)(nil)),
"_ReadFileFS": reflect.ValueOf((*_io_fs_ReadFileFS)(nil)),
"_StatFS": reflect.ValueOf((*_io_fs_StatFS)(nil)),
"_SubFS": reflect.ValueOf((*_io_fs_SubFS)(nil)),
}
}
// _io_fs_DirEntry is an interface wrapper for DirEntry type
type _io_fs_DirEntry struct {
IValue interface{}
WInfo func() (fs.FileInfo, error)
WIsDir func() bool
WName func() string
WType func() fs.FileMode
}
func (W _io_fs_DirEntry) Info() (fs.FileInfo, error) { return W.WInfo() }
func (W _io_fs_DirEntry) IsDir() bool { return W.WIsDir() }
func (W _io_fs_DirEntry) Name() string { return W.WName() }
func (W _io_fs_DirEntry) Type() fs.FileMode { return W.WType() }
// _io_fs_FS is an interface wrapper for FS type
type _io_fs_FS struct {
IValue interface{}
WOpen func(name string) (fs.File, error)
}
func (W _io_fs_FS) Open(name string) (fs.File, error) { return W.WOpen(name) }
// _io_fs_File is an interface wrapper for File type
type _io_fs_File struct {
IValue interface{}
WClose func() error
WRead func(a0 []byte) (int, error)
WStat func() (fs.FileInfo, error)
}
func (W _io_fs_File) Close() error { return W.WClose() }
func (W _io_fs_File) Read(a0 []byte) (int, error) { return W.WRead(a0) }
func (W _io_fs_File) Stat() (fs.FileInfo, error) { return W.WStat() }
// _io_fs_FileInfo is an interface wrapper for FileInfo type
type _io_fs_FileInfo struct {
IValue interface{}
WIsDir func() bool
WModTime func() time.Time
WMode func() fs.FileMode
WName func() string
WSize func() int64
WSys func() any
}
func (W _io_fs_FileInfo) IsDir() bool { return W.WIsDir() }
func (W _io_fs_FileInfo) ModTime() time.Time { return W.WModTime() }
func (W _io_fs_FileInfo) Mode() fs.FileMode { return W.WMode() }
func (W _io_fs_FileInfo) Name() string { return W.WName() }
func (W _io_fs_FileInfo) Size() int64 { return W.WSize() }
func (W _io_fs_FileInfo) Sys() any { return W.WSys() }
// _io_fs_GlobFS is an interface wrapper for GlobFS type
type _io_fs_GlobFS struct {
IValue interface{}
WGlob func(pattern string) ([]string, error)
WOpen func(name string) (fs.File, error)
}
func (W _io_fs_GlobFS) Glob(pattern string) ([]string, error) { return W.WGlob(pattern) }
func (W _io_fs_GlobFS) Open(name string) (fs.File, error) { return W.WOpen(name) }
// _io_fs_ReadDirFS is an interface wrapper for ReadDirFS type
type _io_fs_ReadDirFS struct {
IValue interface{}
WOpen func(name string) (fs.File, error)
WReadDir func(name string) ([]fs.DirEntry, error)
}
func (W _io_fs_ReadDirFS) Open(name string) (fs.File, error) { return W.WOpen(name) }
func (W _io_fs_ReadDirFS) ReadDir(name string) ([]fs.DirEntry, error) { return W.WReadDir(name) }
// _io_fs_ReadDirFile is an interface wrapper for ReadDirFile type
type _io_fs_ReadDirFile struct {
IValue interface{}
WClose func() error
WRead func(a0 []byte) (int, error)
WReadDir func(n int) ([]fs.DirEntry, error)
WStat func() (fs.FileInfo, error)
}
func (W _io_fs_ReadDirFile) Close() error { return W.WClose() }
func (W _io_fs_ReadDirFile) Read(a0 []byte) (int, error) { return W.WRead(a0) }
func (W _io_fs_ReadDirFile) ReadDir(n int) ([]fs.DirEntry, error) { return W.WReadDir(n) }
func (W _io_fs_ReadDirFile) Stat() (fs.FileInfo, error) { return W.WStat() }
// _io_fs_ReadFileFS is an interface wrapper for ReadFileFS type
type _io_fs_ReadFileFS struct {
IValue interface{}
WOpen func(name string) (fs.File, error)
WReadFile func(name string) ([]byte, error)
}
func (W _io_fs_ReadFileFS) Open(name string) (fs.File, error) { return W.WOpen(name) }
func (W _io_fs_ReadFileFS) ReadFile(name string) ([]byte, error) { return W.WReadFile(name) }
// _io_fs_StatFS is an interface wrapper for StatFS type
type _io_fs_StatFS struct {
IValue interface{}
WOpen func(name string) (fs.File, error)
WStat func(name string) (fs.FileInfo, error)
}
func (W _io_fs_StatFS) Open(name string) (fs.File, error) { return W.WOpen(name) }
func (W _io_fs_StatFS) Stat(name string) (fs.FileInfo, error) { return W.WStat(name) }
// _io_fs_SubFS is an interface wrapper for SubFS type
type _io_fs_SubFS struct {
IValue interface{}
WOpen func(name string) (fs.File, error)
WSub func(dir string) (fs.FS, error)
}
func (W _io_fs_SubFS) Open(name string) (fs.File, error) { return W.WOpen(name) }
func (W _io_fs_SubFS) Sub(dir string) (fs.FS, error) { return W.WSub(dir) }
================================================
FILE: stdlib/go1_22_io_ioutil.go
================================================
// Code generated by 'yaegi extract io/ioutil'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"io/ioutil"
"reflect"
)
func init() {
Symbols["io/ioutil/ioutil"] = map[string]reflect.Value{
// function, constant and variable definitions
"Discard": reflect.ValueOf(&ioutil.Discard).Elem(),
"NopCloser": reflect.ValueOf(ioutil.NopCloser),
"ReadAll": reflect.ValueOf(ioutil.ReadAll),
"ReadDir": reflect.ValueOf(ioutil.ReadDir),
"ReadFile": reflect.ValueOf(ioutil.ReadFile),
"TempDir": reflect.ValueOf(ioutil.TempDir),
"TempFile": reflect.ValueOf(ioutil.TempFile),
"WriteFile": reflect.ValueOf(ioutil.WriteFile),
}
}
================================================
FILE: stdlib/go1_22_log.go
================================================
// Code generated by 'yaegi extract log'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"go/constant"
"go/token"
"log"
"reflect"
)
func init() {
Symbols["log/log"] = map[string]reflect.Value{
// function, constant and variable definitions
"Default": reflect.ValueOf(log.Default),
"Fatal": reflect.ValueOf(logFatal),
"Fatalf": reflect.ValueOf(logFatalf),
"Fatalln": reflect.ValueOf(logFatalln),
"Flags": reflect.ValueOf(log.Flags),
"LUTC": reflect.ValueOf(constant.MakeFromLiteral("32", token.INT, 0)),
"Ldate": reflect.ValueOf(constant.MakeFromLiteral("1", token.INT, 0)),
"Llongfile": reflect.ValueOf(constant.MakeFromLiteral("8", token.INT, 0)),
"Lmicroseconds": reflect.ValueOf(constant.MakeFromLiteral("4", token.INT, 0)),
"Lmsgprefix": reflect.ValueOf(constant.MakeFromLiteral("64", token.INT, 0)),
"Lshortfile": reflect.ValueOf(constant.MakeFromLiteral("16", token.INT, 0)),
"LstdFlags": reflect.ValueOf(constant.MakeFromLiteral("3", token.INT, 0)),
"Ltime": reflect.ValueOf(constant.MakeFromLiteral("2", token.INT, 0)),
"New": reflect.ValueOf(logNew),
"Output": reflect.ValueOf(log.Output),
"Panic": reflect.ValueOf(log.Panic),
"Panicf": reflect.ValueOf(log.Panicf),
"Panicln": reflect.ValueOf(log.Panicln),
"Prefix": reflect.ValueOf(log.Prefix),
"Print": reflect.ValueOf(log.Print),
"Printf": reflect.ValueOf(log.Printf),
"Println": reflect.ValueOf(log.Println),
"SetFlags": reflect.ValueOf(log.SetFlags),
"SetOutput": reflect.ValueOf(log.SetOutput),
"SetPrefix": reflect.ValueOf(log.SetPrefix),
"Writer": reflect.ValueOf(log.Writer),
// type definitions
"Logger": reflect.ValueOf((*logLogger)(nil)),
}
}
================================================
FILE: stdlib/go1_22_log_slog.go
================================================
// Code generated by 'yaegi extract log/slog'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"context"
"go/constant"
"go/token"
"log/slog"
"reflect"
)
func init() {
Symbols["log/slog/slog"] = map[string]reflect.Value{
// function, constant and variable definitions
"Any": reflect.ValueOf(slog.Any),
"AnyValue": reflect.ValueOf(slog.AnyValue),
"Bool": reflect.ValueOf(slog.Bool),
"BoolValue": reflect.ValueOf(slog.BoolValue),
"Debug": reflect.ValueOf(slog.Debug),
"DebugContext": reflect.ValueOf(slog.DebugContext),
"Default": reflect.ValueOf(slog.Default),
"Duration": reflect.ValueOf(slog.Duration),
"DurationValue": reflect.ValueOf(slog.DurationValue),
"Error": reflect.ValueOf(slog.Error),
"ErrorContext": reflect.ValueOf(slog.ErrorContext),
"Float64": reflect.ValueOf(slog.Float64),
"Float64Value": reflect.ValueOf(slog.Float64Value),
"Group": reflect.ValueOf(slog.Group),
"GroupValue": reflect.ValueOf(slog.GroupValue),
"Info": reflect.ValueOf(slog.Info),
"InfoContext": reflect.ValueOf(slog.InfoContext),
"Int": reflect.ValueOf(slog.Int),
"Int64": reflect.ValueOf(slog.Int64),
"Int64Value": reflect.ValueOf(slog.Int64Value),
"IntValue": reflect.ValueOf(slog.IntValue),
"KindAny": reflect.ValueOf(slog.KindAny),
"KindBool": reflect.ValueOf(slog.KindBool),
"KindDuration": reflect.ValueOf(slog.KindDuration),
"KindFloat64": reflect.ValueOf(slog.KindFloat64),
"KindGroup": reflect.ValueOf(slog.KindGroup),
"KindInt64": reflect.ValueOf(slog.KindInt64),
"KindLogValuer": reflect.ValueOf(slog.KindLogValuer),
"KindString": reflect.ValueOf(slog.KindString),
"KindTime": reflect.ValueOf(slog.KindTime),
"KindUint64": reflect.ValueOf(slog.KindUint64),
"LevelDebug": reflect.ValueOf(slog.LevelDebug),
"LevelError": reflect.ValueOf(slog.LevelError),
"LevelInfo": reflect.ValueOf(slog.LevelInfo),
"LevelKey": reflect.ValueOf(constant.MakeFromLiteral("\"level\"", token.STRING, 0)),
"LevelWarn": reflect.ValueOf(slog.LevelWarn),
"Log": reflect.ValueOf(slog.Log),
"LogAttrs": reflect.ValueOf(slog.LogAttrs),
"MessageKey": reflect.ValueOf(constant.MakeFromLiteral("\"msg\"", token.STRING, 0)),
"New": reflect.ValueOf(slog.New),
"NewJSONHandler": reflect.ValueOf(slog.NewJSONHandler),
"NewLogLogger": reflect.ValueOf(slog.NewLogLogger),
"NewRecord": reflect.ValueOf(slog.NewRecord),
"NewTextHandler": reflect.ValueOf(slog.NewTextHandler),
"SetDefault": reflect.ValueOf(slog.SetDefault),
"SetLogLoggerLevel": reflect.ValueOf(slog.SetLogLoggerLevel),
"SourceKey": reflect.ValueOf(constant.MakeFromLiteral("\"source\"", token.STRING, 0)),
"String": reflect.ValueOf(slog.String),
"StringValue": reflect.ValueOf(slog.StringValue),
"Time": reflect.ValueOf(slog.Time),
"TimeKey": reflect.ValueOf(constant.MakeFromLiteral("\"time\"", token.STRING, 0)),
"TimeValue": reflect.ValueOf(slog.TimeValue),
"Uint64": reflect.ValueOf(slog.Uint64),
"Uint64Value": reflect.ValueOf(slog.Uint64Value),
"Warn": reflect.ValueOf(slog.Warn),
"WarnContext": reflect.ValueOf(slog.WarnContext),
"With": reflect.ValueOf(slog.With),
// type definitions
"Attr": reflect.ValueOf((*slog.Attr)(nil)),
"Handler": reflect.ValueOf((*slog.Handler)(nil)),
"HandlerOptions": reflect.ValueOf((*slog.HandlerOptions)(nil)),
"JSONHandler": reflect.ValueOf((*slog.JSONHandler)(nil)),
"Kind": reflect.ValueOf((*slog.Kind)(nil)),
"Level": reflect.ValueOf((*slog.Level)(nil)),
"LevelVar": reflect.ValueOf((*slog.LevelVar)(nil)),
"Leveler": reflect.ValueOf((*slog.Leveler)(nil)),
"LogValuer": reflect.ValueOf((*slog.LogValuer)(nil)),
"Logger": reflect.ValueOf((*slog.Logger)(nil)),
"Record": reflect.ValueOf((*slog.Record)(nil)),
"Source": reflect.ValueOf((*slog.Source)(nil)),
"TextHandler": reflect.ValueOf((*slog.TextHandler)(nil)),
"Value": reflect.ValueOf((*slog.Value)(nil)),
// interface wrapper definitions
"_Handler": reflect.ValueOf((*_log_slog_Handler)(nil)),
"_Leveler": reflect.ValueOf((*_log_slog_Leveler)(nil)),
"_LogValuer": reflect.ValueOf((*_log_slog_LogValuer)(nil)),
}
}
// _log_slog_Handler is an interface wrapper for Handler type
type _log_slog_Handler struct {
IValue interface{}
WEnabled func(a0 context.Context, a1 slog.Level) bool
WHandle func(a0 context.Context, a1 slog.Record) error
WWithAttrs func(attrs []slog.Attr) slog.Handler
WWithGroup func(name string) slog.Handler
}
func (W _log_slog_Handler) Enabled(a0 context.Context, a1 slog.Level) bool { return W.WEnabled(a0, a1) }
func (W _log_slog_Handler) Handle(a0 context.Context, a1 slog.Record) error { return W.WHandle(a0, a1) }
func (W _log_slog_Handler) WithAttrs(attrs []slog.Attr) slog.Handler { return W.WWithAttrs(attrs) }
func (W _log_slog_Handler) WithGroup(name string) slog.Handler { return W.WWithGroup(name) }
// _log_slog_Leveler is an interface wrapper for Leveler type
type _log_slog_Leveler struct {
IValue interface{}
WLevel func() slog.Level
}
func (W _log_slog_Leveler) Level() slog.Level { return W.WLevel() }
// _log_slog_LogValuer is an interface wrapper for LogValuer type
type _log_slog_LogValuer struct {
IValue interface{}
WLogValue func() slog.Value
}
func (W _log_slog_LogValuer) LogValue() slog.Value { return W.WLogValue() }
================================================
FILE: stdlib/go1_22_log_syslog.go
================================================
// Code generated by 'yaegi extract log/syslog'. DO NOT EDIT.
//go:build go1.22 && !windows && !nacl && !plan9
// +build go1.22,!windows,!nacl,!plan9
package stdlib
import (
"log/syslog"
"reflect"
)
func init() {
Symbols["log/syslog/syslog"] = map[string]reflect.Value{
// function, constant and variable definitions
"Dial": reflect.ValueOf(syslog.Dial),
"LOG_ALERT": reflect.ValueOf(syslog.LOG_ALERT),
"LOG_AUTH": reflect.ValueOf(syslog.LOG_AUTH),
"LOG_AUTHPRIV": reflect.ValueOf(syslog.LOG_AUTHPRIV),
"LOG_CRIT": reflect.ValueOf(syslog.LOG_CRIT),
"LOG_CRON": reflect.ValueOf(syslog.LOG_CRON),
"LOG_DAEMON": reflect.ValueOf(syslog.LOG_DAEMON),
"LOG_DEBUG": reflect.ValueOf(syslog.LOG_DEBUG),
"LOG_EMERG": reflect.ValueOf(syslog.LOG_EMERG),
"LOG_ERR": reflect.ValueOf(syslog.LOG_ERR),
"LOG_FTP": reflect.ValueOf(syslog.LOG_FTP),
"LOG_INFO": reflect.ValueOf(syslog.LOG_INFO),
"LOG_KERN": reflect.ValueOf(syslog.LOG_KERN),
"LOG_LOCAL0": reflect.ValueOf(syslog.LOG_LOCAL0),
"LOG_LOCAL1": reflect.ValueOf(syslog.LOG_LOCAL1),
"LOG_LOCAL2": reflect.ValueOf(syslog.LOG_LOCAL2),
"LOG_LOCAL3": reflect.ValueOf(syslog.LOG_LOCAL3),
"LOG_LOCAL4": reflect.ValueOf(syslog.LOG_LOCAL4),
"LOG_LOCAL5": reflect.ValueOf(syslog.LOG_LOCAL5),
"LOG_LOCAL6": reflect.ValueOf(syslog.LOG_LOCAL6),
"LOG_LOCAL7": reflect.ValueOf(syslog.LOG_LOCAL7),
"LOG_LPR": reflect.ValueOf(syslog.LOG_LPR),
"LOG_MAIL": reflect.ValueOf(syslog.LOG_MAIL),
"LOG_NEWS": reflect.ValueOf(syslog.LOG_NEWS),
"LOG_NOTICE": reflect.ValueOf(syslog.LOG_NOTICE),
"LOG_SYSLOG": reflect.ValueOf(syslog.LOG_SYSLOG),
"LOG_USER": reflect.ValueOf(syslog.LOG_USER),
"LOG_UUCP": reflect.ValueOf(syslog.LOG_UUCP),
"LOG_WARNING": reflect.ValueOf(syslog.LOG_WARNING),
"New": reflect.ValueOf(syslog.New),
"NewLogger": reflect.ValueOf(syslog.NewLogger),
// type definitions
"Priority": reflect.ValueOf((*syslog.Priority)(nil)),
"Writer": reflect.ValueOf((*syslog.Writer)(nil)),
}
}
================================================
FILE: stdlib/go1_22_maps.go
================================================
// Code generated by 'yaegi extract maps'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"reflect"
)
func init() {
Symbols["maps/maps"] = map[string]reflect.Value{}
}
================================================
FILE: stdlib/go1_22_math.go
================================================
// Code generated by 'yaegi extract math'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"go/constant"
"go/token"
"math"
"reflect"
)
func init() {
Symbols["math/math"] = map[string]reflect.Value{
// function, constant and variable definitions
"Abs": reflect.ValueOf(math.Abs),
"Acos": reflect.ValueOf(math.Acos),
"Acosh": reflect.ValueOf(math.Acosh),
"Asin": reflect.ValueOf(math.Asin),
"Asinh": reflect.ValueOf(math.Asinh),
"Atan": reflect.ValueOf(math.Atan),
"Atan2": reflect.ValueOf(math.Atan2),
"Atanh": reflect.ValueOf(math.Atanh),
"Cbrt": reflect.ValueOf(math.Cbrt),
"Ceil": reflect.ValueOf(math.Ceil),
"Copysign": reflect.ValueOf(math.Copysign),
"Cos": reflect.ValueOf(math.Cos),
"Cosh": reflect.ValueOf(math.Cosh),
"Dim": reflect.ValueOf(math.Dim),
"E": reflect.ValueOf(constant.MakeFromLiteral("2.71828182845904523536028747135266249775724709369995957496696762566337824315673231520670375558666729784504486779277967997696994772644702281675346915668215131895555530285035761295375777990557253360748291015625", token.FLOAT, 0)),
"Erf": reflect.ValueOf(math.Erf),
"Erfc": reflect.ValueOf(math.Erfc),
"Erfcinv": reflect.ValueOf(math.Erfcinv),
"Erfinv": reflect.ValueOf(math.Erfinv),
"Exp": reflect.ValueOf(math.Exp),
"Exp2": reflect.ValueOf(math.Exp2),
"Expm1": reflect.ValueOf(math.Expm1),
"FMA": reflect.ValueOf(math.FMA),
"Float32bits": reflect.ValueOf(math.Float32bits),
"Float32frombits": reflect.ValueOf(math.Float32frombits),
"Float64bits": reflect.ValueOf(math.Float64bits),
"Float64frombits": reflect.ValueOf(math.Float64frombits),
"Floor": reflect.ValueOf(math.Floor),
"Frexp": reflect.ValueOf(math.Frexp),
"Gamma": reflect.ValueOf(math.Gamma),
"Hypot": reflect.ValueOf(math.Hypot),
"Ilogb": reflect.ValueOf(math.Ilogb),
"Inf": reflect.ValueOf(math.Inf),
"IsInf": reflect.ValueOf(math.IsInf),
"IsNaN": reflect.ValueOf(math.IsNaN),
"J0": reflect.ValueOf(math.J0),
"J1": reflect.ValueOf(math.J1),
"Jn": reflect.ValueOf(math.Jn),
"Ldexp": reflect.ValueOf(math.Ldexp),
"Lgamma": reflect.ValueOf(math.Lgamma),
"Ln10": reflect.ValueOf(constant.MakeFromLiteral("2.30258509299404568401799145468436420760110148862877297603332784146804725494827975466552490443295866962642372461496758838959542646932914211937012833592062802600362869664962772731087170541286468505859375", token.FLOAT, 0)),
"Ln2": reflect.ValueOf(constant.MakeFromLiteral("0.6931471805599453094172321214581765680755001343602552541206800092715999496201383079363438206637927920954189307729314303884387720696314608777673678644642390655170150035209453154294578780536539852619171142578125", token.FLOAT, 0)),
"Log": reflect.ValueOf(math.Log),
"Log10": reflect.ValueOf(math.Log10),
"Log10E": reflect.ValueOf(constant.MakeFromLiteral("0.43429448190325182765112891891660508229439700580366656611445378416636798190620320263064286300825210972160277489744884502676719847561509639618196799746596688688378591625127711495224502868950366973876953125", token.FLOAT, 0)),
"Log1p": reflect.ValueOf(math.Log1p),
"Log2": reflect.ValueOf(math.Log2),
"Log2E": reflect.ValueOf(constant.MakeFromLiteral("1.44269504088896340735992468100189213742664595415298593413544940772066427768997545329060870636212628972710992130324953463427359402479619301286929040235571747101382214539290471666532766903401352465152740478515625", token.FLOAT, 0)),
"Logb": reflect.ValueOf(math.Logb),
"Max": reflect.ValueOf(math.Max),
"MaxFloat32": reflect.ValueOf(constant.MakeFromLiteral("340282346638528859811704183484516925440", token.FLOAT, 0)),
"MaxFloat64": reflect.ValueOf(constant.MakeFromLiteral("179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368", token.FLOAT, 0)),
"MaxInt": reflect.ValueOf(constant.MakeFromLiteral("9223372036854775807", token.INT, 0)),
"MaxInt16": reflect.ValueOf(constant.MakeFromLiteral("32767", token.INT, 0)),
"MaxInt32": reflect.ValueOf(constant.MakeFromLiteral("2147483647", token.INT, 0)),
"MaxInt64": reflect.ValueOf(constant.MakeFromLiteral("9223372036854775807", token.INT, 0)),
"MaxInt8": reflect.ValueOf(constant.MakeFromLiteral("127", token.INT, 0)),
"MaxUint": reflect.ValueOf(constant.MakeFromLiteral("18446744073709551615", token.INT, 0)),
"MaxUint16": reflect.ValueOf(constant.MakeFromLiteral("65535", token.INT, 0)),
"MaxUint32": reflect.ValueOf(constant.MakeFromLiteral("4294967295", token.INT, 0)),
"MaxUint64": reflect.ValueOf(constant.MakeFromLiteral("18446744073709551615", token.INT, 0)),
"MaxUint8": reflect.ValueOf(constant.MakeFromLiteral("255", token.INT, 0)),
"Min": reflect.ValueOf(math.Min),
"MinInt": reflect.ValueOf(constant.MakeFromLiteral("-9223372036854775808", token.INT, 0)),
"MinInt16": reflect.ValueOf(constant.MakeFromLiteral("-32768", token.INT, 0)),
"MinInt32": reflect.ValueOf(constant.MakeFromLiteral("-2147483648", token.INT, 0)),
"MinInt64": reflect.ValueOf(constant.MakeFromLiteral("-9223372036854775808", token.INT, 0)),
"MinInt8": reflect.ValueOf(constant.MakeFromLiteral("-128", token.INT, 0)),
"Mod": reflect.ValueOf(math.Mod),
"Modf": reflect.ValueOf(math.Modf),
"NaN": reflect.ValueOf(math.NaN),
"Nextafter": reflect.ValueOf(math.Nextafter),
"Nextafter32": reflect.ValueOf(math.Nextafter32),
"Phi": reflect.ValueOf(constant.MakeFromLiteral("1.6180339887498948482045868343656381177203091798057628621354486119746080982153796619881086049305501566952211682590824739205931370737029882996587050475921915678674035433959321750307935872115194797515869140625", token.FLOAT, 0)),
"Pi": reflect.ValueOf(constant.MakeFromLiteral("3.141592653589793238462643383279502884197169399375105820974944594789982923695635954704435713335896673485663389728754819466702315787113662862838515639906529162340867271374644786874341662041842937469482421875", token.FLOAT, 0)),
"Pow": reflect.ValueOf(math.Pow),
"Pow10": reflect.ValueOf(math.Pow10),
"Remainder": reflect.ValueOf(math.Remainder),
"Round": reflect.ValueOf(math.Round),
"RoundToEven": reflect.ValueOf(math.RoundToEven),
"Signbit": reflect.ValueOf(math.Signbit),
"Sin": reflect.ValueOf(math.Sin),
"Sincos": reflect.ValueOf(math.Sincos),
"Sinh": reflect.ValueOf(math.Sinh),
"SmallestNonzeroFloat32": reflect.ValueOf(constant.MakeFromLiteral("1.40129846432481707092372958328991613128026194187651577175706828388979108268586060148663818836212158203125e-45", token.FLOAT, 0)),
"SmallestNonzeroFloat64": reflect.ValueOf(constant.MakeFromLiteral("4.940656458412465441765687928682213723650598026143247644255856825006755072702087518652998363616359923797965646954457177309266567103559397963987747960107818781263007131903114045278458171678489821036887186360569987307230500063874091535649843873124733972731696151400317153853980741262385655911710266585566867681870395603106249319452715914924553293054565444011274801297099995419319894090804165633245247571478690147267801593552386115501348035264934720193790268107107491703332226844753335720832431936092382893458368060106011506169809753078342277318329247904982524730776375927247874656084778203734469699533647017972677717585125660551199131504891101451037862738167250955837389733598993664809941164205702637090279242767544565229087538682506419718265533447265625e-324", token.FLOAT, 0)),
"Sqrt": reflect.ValueOf(math.Sqrt),
"Sqrt2": reflect.ValueOf(constant.MakeFromLiteral("1.414213562373095048801688724209698078569671875376948073176679739576083351575381440094441524123797447886801949755143139115339040409162552642832693297721230919563348109313505318596071447245776653289794921875", token.FLOAT, 0)),
"SqrtE": reflect.ValueOf(constant.MakeFromLiteral("1.64872127070012814684865078781416357165377610071014801157507931167328763229187870850146925823776361770041160388013884200789716007979526823569827080974091691342077871211546646890155898290686309337615966796875", token.FLOAT, 0)),
"SqrtPhi": reflect.ValueOf(constant.MakeFromLiteral("1.2720196495140689642524224617374914917156080418400962486166403754616080542166459302584536396369727769747312116100875915825863540562126478288118732191412003988041797518382391984914647764526307582855224609375", token.FLOAT, 0)),
"SqrtPi": reflect.ValueOf(constant.MakeFromLiteral("1.772453850905516027298167483341145182797549456122387128213807789740599698370237052541269446184448945647349951047154197675245574635259260134350885938555625028620527962319730619356050738133490085601806640625", token.FLOAT, 0)),
"Tan": reflect.ValueOf(math.Tan),
"Tanh": reflect.ValueOf(math.Tanh),
"Trunc": reflect.ValueOf(math.Trunc),
"Y0": reflect.ValueOf(math.Y0),
"Y1": reflect.ValueOf(math.Y1),
"Yn": reflect.ValueOf(math.Yn),
}
}
================================================
FILE: stdlib/go1_22_math_big.go
================================================
// Code generated by 'yaegi extract math/big'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"go/constant"
"go/token"
"math/big"
"reflect"
)
func init() {
Symbols["math/big/big"] = map[string]reflect.Value{
// function, constant and variable definitions
"Above": reflect.ValueOf(big.Above),
"AwayFromZero": reflect.ValueOf(big.AwayFromZero),
"Below": reflect.ValueOf(big.Below),
"Exact": reflect.ValueOf(big.Exact),
"Jacobi": reflect.ValueOf(big.Jacobi),
"MaxBase": reflect.ValueOf(constant.MakeFromLiteral("62", token.INT, 0)),
"MaxExp": reflect.ValueOf(constant.MakeFromLiteral("2147483647", token.INT, 0)),
"MaxPrec": reflect.ValueOf(constant.MakeFromLiteral("4294967295", token.INT, 0)),
"MinExp": reflect.ValueOf(constant.MakeFromLiteral("-2147483648", token.INT, 0)),
"NewFloat": reflect.ValueOf(big.NewFloat),
"NewInt": reflect.ValueOf(big.NewInt),
"NewRat": reflect.ValueOf(big.NewRat),
"ParseFloat": reflect.ValueOf(big.ParseFloat),
"ToNearestAway": reflect.ValueOf(big.ToNearestAway),
"ToNearestEven": reflect.ValueOf(big.ToNearestEven),
"ToNegativeInf": reflect.ValueOf(big.ToNegativeInf),
"ToPositiveInf": reflect.ValueOf(big.ToPositiveInf),
"ToZero": reflect.ValueOf(big.ToZero),
// type definitions
"Accuracy": reflect.ValueOf((*big.Accuracy)(nil)),
"ErrNaN": reflect.ValueOf((*big.ErrNaN)(nil)),
"Float": reflect.ValueOf((*big.Float)(nil)),
"Int": reflect.ValueOf((*big.Int)(nil)),
"Rat": reflect.ValueOf((*big.Rat)(nil)),
"RoundingMode": reflect.ValueOf((*big.RoundingMode)(nil)),
"Word": reflect.ValueOf((*big.Word)(nil)),
}
}
================================================
FILE: stdlib/go1_22_math_bits.go
================================================
// Code generated by 'yaegi extract math/bits'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"go/constant"
"go/token"
"math/bits"
"reflect"
)
func init() {
Symbols["math/bits/bits"] = map[string]reflect.Value{
// function, constant and variable definitions
"Add": reflect.ValueOf(bits.Add),
"Add32": reflect.ValueOf(bits.Add32),
"Add64": reflect.ValueOf(bits.Add64),
"Div": reflect.ValueOf(bits.Div),
"Div32": reflect.ValueOf(bits.Div32),
"Div64": reflect.ValueOf(bits.Div64),
"LeadingZeros": reflect.ValueOf(bits.LeadingZeros),
"LeadingZeros16": reflect.ValueOf(bits.LeadingZeros16),
"LeadingZeros32": reflect.ValueOf(bits.LeadingZeros32),
"LeadingZeros64": reflect.ValueOf(bits.LeadingZeros64),
"LeadingZeros8": reflect.ValueOf(bits.LeadingZeros8),
"Len": reflect.ValueOf(bits.Len),
"Len16": reflect.ValueOf(bits.Len16),
"Len32": reflect.ValueOf(bits.Len32),
"Len64": reflect.ValueOf(bits.Len64),
"Len8": reflect.ValueOf(bits.Len8),
"Mul": reflect.ValueOf(bits.Mul),
"Mul32": reflect.ValueOf(bits.Mul32),
"Mul64": reflect.ValueOf(bits.Mul64),
"OnesCount": reflect.ValueOf(bits.OnesCount),
"OnesCount16": reflect.ValueOf(bits.OnesCount16),
"OnesCount32": reflect.ValueOf(bits.OnesCount32),
"OnesCount64": reflect.ValueOf(bits.OnesCount64),
"OnesCount8": reflect.ValueOf(bits.OnesCount8),
"Rem": reflect.ValueOf(bits.Rem),
"Rem32": reflect.ValueOf(bits.Rem32),
"Rem64": reflect.ValueOf(bits.Rem64),
"Reverse": reflect.ValueOf(bits.Reverse),
"Reverse16": reflect.ValueOf(bits.Reverse16),
"Reverse32": reflect.ValueOf(bits.Reverse32),
"Reverse64": reflect.ValueOf(bits.Reverse64),
"Reverse8": reflect.ValueOf(bits.Reverse8),
"ReverseBytes": reflect.ValueOf(bits.ReverseBytes),
"ReverseBytes16": reflect.ValueOf(bits.ReverseBytes16),
"ReverseBytes32": reflect.ValueOf(bits.ReverseBytes32),
"ReverseBytes64": reflect.ValueOf(bits.ReverseBytes64),
"RotateLeft": reflect.ValueOf(bits.RotateLeft),
"RotateLeft16": reflect.ValueOf(bits.RotateLeft16),
"RotateLeft32": reflect.ValueOf(bits.RotateLeft32),
"RotateLeft64": reflect.ValueOf(bits.RotateLeft64),
"RotateLeft8": reflect.ValueOf(bits.RotateLeft8),
"Sub": reflect.ValueOf(bits.Sub),
"Sub32": reflect.ValueOf(bits.Sub32),
"Sub64": reflect.ValueOf(bits.Sub64),
"TrailingZeros": reflect.ValueOf(bits.TrailingZeros),
"TrailingZeros16": reflect.ValueOf(bits.TrailingZeros16),
"TrailingZeros32": reflect.ValueOf(bits.TrailingZeros32),
"TrailingZeros64": reflect.ValueOf(bits.TrailingZeros64),
"TrailingZeros8": reflect.ValueOf(bits.TrailingZeros8),
"UintSize": reflect.ValueOf(constant.MakeFromLiteral("64", token.INT, 0)),
}
}
================================================
FILE: stdlib/go1_22_math_cmplx.go
================================================
// Code generated by 'yaegi extract math/cmplx'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"math/cmplx"
"reflect"
)
func init() {
Symbols["math/cmplx/cmplx"] = map[string]reflect.Value{
// function, constant and variable definitions
"Abs": reflect.ValueOf(cmplx.Abs),
"Acos": reflect.ValueOf(cmplx.Acos),
"Acosh": reflect.ValueOf(cmplx.Acosh),
"Asin": reflect.ValueOf(cmplx.Asin),
"Asinh": reflect.ValueOf(cmplx.Asinh),
"Atan": reflect.ValueOf(cmplx.Atan),
"Atanh": reflect.ValueOf(cmplx.Atanh),
"Conj": reflect.ValueOf(cmplx.Conj),
"Cos": reflect.ValueOf(cmplx.Cos),
"Cosh": reflect.ValueOf(cmplx.Cosh),
"Cot": reflect.ValueOf(cmplx.Cot),
"Exp": reflect.ValueOf(cmplx.Exp),
"Inf": reflect.ValueOf(cmplx.Inf),
"IsInf": reflect.ValueOf(cmplx.IsInf),
"IsNaN": reflect.ValueOf(cmplx.IsNaN),
"Log": reflect.ValueOf(cmplx.Log),
"Log10": reflect.ValueOf(cmplx.Log10),
"NaN": reflect.ValueOf(cmplx.NaN),
"Phase": reflect.ValueOf(cmplx.Phase),
"Polar": reflect.ValueOf(cmplx.Polar),
"Pow": reflect.ValueOf(cmplx.Pow),
"Rect": reflect.ValueOf(cmplx.Rect),
"Sin": reflect.ValueOf(cmplx.Sin),
"Sinh": reflect.ValueOf(cmplx.Sinh),
"Sqrt": reflect.ValueOf(cmplx.Sqrt),
"Tan": reflect.ValueOf(cmplx.Tan),
"Tanh": reflect.ValueOf(cmplx.Tanh),
}
}
================================================
FILE: stdlib/go1_22_math_rand.go
================================================
// Code generated by 'yaegi extract math/rand'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"math/rand"
"reflect"
)
func init() {
Symbols["math/rand/rand"] = map[string]reflect.Value{
// function, constant and variable definitions
"ExpFloat64": reflect.ValueOf(rand.ExpFloat64),
"Float32": reflect.ValueOf(rand.Float32),
"Float64": reflect.ValueOf(rand.Float64),
"Int": reflect.ValueOf(rand.Int),
"Int31": reflect.ValueOf(rand.Int31),
"Int31n": reflect.ValueOf(rand.Int31n),
"Int63": reflect.ValueOf(rand.Int63),
"Int63n": reflect.ValueOf(rand.Int63n),
"Intn": reflect.ValueOf(rand.Intn),
"New": reflect.ValueOf(rand.New),
"NewSource": reflect.ValueOf(rand.NewSource),
"NewZipf": reflect.ValueOf(rand.NewZipf),
"NormFloat64": reflect.ValueOf(rand.NormFloat64),
"Perm": reflect.ValueOf(rand.Perm),
"Read": reflect.ValueOf(rand.Read),
"Seed": reflect.ValueOf(rand.Seed),
"Shuffle": reflect.ValueOf(rand.Shuffle),
"Uint32": reflect.ValueOf(rand.Uint32),
"Uint64": reflect.ValueOf(rand.Uint64),
// type definitions
"Rand": reflect.ValueOf((*rand.Rand)(nil)),
"Source": reflect.ValueOf((*rand.Source)(nil)),
"Source64": reflect.ValueOf((*rand.Source64)(nil)),
"Zipf": reflect.ValueOf((*rand.Zipf)(nil)),
// interface wrapper definitions
"_Source": reflect.ValueOf((*_math_rand_Source)(nil)),
"_Source64": reflect.ValueOf((*_math_rand_Source64)(nil)),
}
}
// _math_rand_Source is an interface wrapper for Source type
type _math_rand_Source struct {
IValue interface{}
WInt63 func() int64
WSeed func(seed int64)
}
func (W _math_rand_Source) Int63() int64 { return W.WInt63() }
func (W _math_rand_Source) Seed(seed int64) { W.WSeed(seed) }
// _math_rand_Source64 is an interface wrapper for Source64 type
type _math_rand_Source64 struct {
IValue interface{}
WInt63 func() int64
WSeed func(seed int64)
WUint64 func() uint64
}
func (W _math_rand_Source64) Int63() int64 { return W.WInt63() }
func (W _math_rand_Source64) Seed(seed int64) { W.WSeed(seed) }
func (W _math_rand_Source64) Uint64() uint64 { return W.WUint64() }
================================================
FILE: stdlib/go1_22_math_rand_v2.go
================================================
// Code generated by 'yaegi extract math/rand/v2'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"math/rand/v2"
"reflect"
)
func init() {
Symbols["math/rand/v2/rand"] = map[string]reflect.Value{
// function, constant and variable definitions
"ExpFloat64": reflect.ValueOf(rand.ExpFloat64),
"Float32": reflect.ValueOf(rand.Float32),
"Float64": reflect.ValueOf(rand.Float64),
"Int": reflect.ValueOf(rand.Int),
"Int32": reflect.ValueOf(rand.Int32),
"Int32N": reflect.ValueOf(rand.Int32N),
"Int64": reflect.ValueOf(rand.Int64),
"Int64N": reflect.ValueOf(rand.Int64N),
"IntN": reflect.ValueOf(rand.IntN),
"New": reflect.ValueOf(rand.New),
"NewChaCha8": reflect.ValueOf(rand.NewChaCha8),
"NewPCG": reflect.ValueOf(rand.NewPCG),
"NewZipf": reflect.ValueOf(rand.NewZipf),
"NormFloat64": reflect.ValueOf(rand.NormFloat64),
"Perm": reflect.ValueOf(rand.Perm),
"Shuffle": reflect.ValueOf(rand.Shuffle),
"Uint32": reflect.ValueOf(rand.Uint32),
"Uint32N": reflect.ValueOf(rand.Uint32N),
"Uint64": reflect.ValueOf(rand.Uint64),
"Uint64N": reflect.ValueOf(rand.Uint64N),
"UintN": reflect.ValueOf(rand.UintN),
// type definitions
"ChaCha8": reflect.ValueOf((*rand.ChaCha8)(nil)),
"PCG": reflect.ValueOf((*rand.PCG)(nil)),
"Rand": reflect.ValueOf((*rand.Rand)(nil)),
"Source": reflect.ValueOf((*rand.Source)(nil)),
"Zipf": reflect.ValueOf((*rand.Zipf)(nil)),
// interface wrapper definitions
"_Source": reflect.ValueOf((*_math_rand_v2_Source)(nil)),
}
}
// _math_rand_v2_Source is an interface wrapper for Source type
type _math_rand_v2_Source struct {
IValue interface{}
WUint64 func() uint64
}
func (W _math_rand_v2_Source) Uint64() uint64 { return W.WUint64() }
================================================
FILE: stdlib/go1_22_mime.go
================================================
// Code generated by 'yaegi extract mime'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"mime"
"reflect"
)
func init() {
Symbols["mime/mime"] = map[string]reflect.Value{
// function, constant and variable definitions
"AddExtensionType": reflect.ValueOf(mime.AddExtensionType),
"BEncoding": reflect.ValueOf(mime.BEncoding),
"ErrInvalidMediaParameter": reflect.ValueOf(&mime.ErrInvalidMediaParameter).Elem(),
"ExtensionsByType": reflect.ValueOf(mime.ExtensionsByType),
"FormatMediaType": reflect.ValueOf(mime.FormatMediaType),
"ParseMediaType": reflect.ValueOf(mime.ParseMediaType),
"QEncoding": reflect.ValueOf(mime.QEncoding),
"TypeByExtension": reflect.ValueOf(mime.TypeByExtension),
// type definitions
"WordDecoder": reflect.ValueOf((*mime.WordDecoder)(nil)),
"WordEncoder": reflect.ValueOf((*mime.WordEncoder)(nil)),
}
}
================================================
FILE: stdlib/go1_22_mime_multipart.go
================================================
// Code generated by 'yaegi extract mime/multipart'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"mime/multipart"
"reflect"
)
func init() {
Symbols["mime/multipart/multipart"] = map[string]reflect.Value{
// function, constant and variable definitions
"ErrMessageTooLarge": reflect.ValueOf(&multipart.ErrMessageTooLarge).Elem(),
"NewReader": reflect.ValueOf(multipart.NewReader),
"NewWriter": reflect.ValueOf(multipart.NewWriter),
// type definitions
"File": reflect.ValueOf((*multipart.File)(nil)),
"FileHeader": reflect.ValueOf((*multipart.FileHeader)(nil)),
"Form": reflect.ValueOf((*multipart.Form)(nil)),
"Part": reflect.ValueOf((*multipart.Part)(nil)),
"Reader": reflect.ValueOf((*multipart.Reader)(nil)),
"Writer": reflect.ValueOf((*multipart.Writer)(nil)),
// interface wrapper definitions
"_File": reflect.ValueOf((*_mime_multipart_File)(nil)),
}
}
// _mime_multipart_File is an interface wrapper for File type
type _mime_multipart_File struct {
IValue interface{}
WClose func() error
WRead func(p []byte) (n int, err error)
WReadAt func(p []byte, off int64) (n int, err error)
WSeek func(offset int64, whence int) (int64, error)
}
func (W _mime_multipart_File) Close() error { return W.WClose() }
func (W _mime_multipart_File) Read(p []byte) (n int, err error) { return W.WRead(p) }
func (W _mime_multipart_File) ReadAt(p []byte, off int64) (n int, err error) {
return W.WReadAt(p, off)
}
func (W _mime_multipart_File) Seek(offset int64, whence int) (int64, error) {
return W.WSeek(offset, whence)
}
================================================
FILE: stdlib/go1_22_mime_quotedprintable.go
================================================
// Code generated by 'yaegi extract mime/quotedprintable'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"mime/quotedprintable"
"reflect"
)
func init() {
Symbols["mime/quotedprintable/quotedprintable"] = map[string]reflect.Value{
// function, constant and variable definitions
"NewReader": reflect.ValueOf(quotedprintable.NewReader),
"NewWriter": reflect.ValueOf(quotedprintable.NewWriter),
// type definitions
"Reader": reflect.ValueOf((*quotedprintable.Reader)(nil)),
"Writer": reflect.ValueOf((*quotedprintable.Writer)(nil)),
}
}
================================================
FILE: stdlib/go1_22_net.go
================================================
// Code generated by 'yaegi extract net'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"go/constant"
"go/token"
"net"
"reflect"
"time"
)
func init() {
Symbols["net/net"] = map[string]reflect.Value{
// function, constant and variable definitions
"CIDRMask": reflect.ValueOf(net.CIDRMask),
"DefaultResolver": reflect.ValueOf(&net.DefaultResolver).Elem(),
"Dial": reflect.ValueOf(net.Dial),
"DialIP": reflect.ValueOf(net.DialIP),
"DialTCP": reflect.ValueOf(net.DialTCP),
"DialTimeout": reflect.ValueOf(net.DialTimeout),
"DialUDP": reflect.ValueOf(net.DialUDP),
"DialUnix": reflect.ValueOf(net.DialUnix),
"ErrClosed": reflect.ValueOf(&net.ErrClosed).Elem(),
"ErrWriteToConnected": reflect.ValueOf(&net.ErrWriteToConnected).Elem(),
"FileConn": reflect.ValueOf(net.FileConn),
"FileListener": reflect.ValueOf(net.FileListener),
"FilePacketConn": reflect.ValueOf(net.FilePacketConn),
"FlagBroadcast": reflect.ValueOf(net.FlagBroadcast),
"FlagLoopback": reflect.ValueOf(net.FlagLoopback),
"FlagMulticast": reflect.ValueOf(net.FlagMulticast),
"FlagPointToPoint": reflect.ValueOf(net.FlagPointToPoint),
"FlagRunning": reflect.ValueOf(net.FlagRunning),
"FlagUp": reflect.ValueOf(net.FlagUp),
"IPv4": reflect.ValueOf(net.IPv4),
"IPv4Mask": reflect.ValueOf(net.IPv4Mask),
"IPv4allrouter": reflect.ValueOf(&net.IPv4allrouter).Elem(),
"IPv4allsys": reflect.ValueOf(&net.IPv4allsys).Elem(),
"IPv4bcast": reflect.ValueOf(&net.IPv4bcast).Elem(),
"IPv4len": reflect.ValueOf(constant.MakeFromLiteral("4", token.INT, 0)),
"IPv4zero": reflect.ValueOf(&net.IPv4zero).Elem(),
"IPv6interfacelocalallnodes": reflect.ValueOf(&net.IPv6interfacelocalallnodes).Elem(),
"IPv6len": reflect.ValueOf(constant.MakeFromLiteral("16", token.INT, 0)),
"IPv6linklocalallnodes": reflect.ValueOf(&net.IPv6linklocalallnodes).Elem(),
"IPv6linklocalallrouters": reflect.ValueOf(&net.IPv6linklocalallrouters).Elem(),
"IPv6loopback": reflect.ValueOf(&net.IPv6loopback).Elem(),
"IPv6unspecified": reflect.ValueOf(&net.IPv6unspecified).Elem(),
"IPv6zero": reflect.ValueOf(&net.IPv6zero).Elem(),
"InterfaceAddrs": reflect.ValueOf(net.InterfaceAddrs),
"InterfaceByIndex": reflect.ValueOf(net.InterfaceByIndex),
"InterfaceByName": reflect.ValueOf(net.InterfaceByName),
"Interfaces": reflect.ValueOf(net.Interfaces),
"JoinHostPort": reflect.ValueOf(net.JoinHostPort),
"Listen": reflect.ValueOf(net.Listen),
"ListenIP": reflect.ValueOf(net.ListenIP),
"ListenMulticastUDP": reflect.ValueOf(net.ListenMulticastUDP),
"ListenPacket": reflect.ValueOf(net.ListenPacket),
"ListenTCP": reflect.ValueOf(net.ListenTCP),
"ListenUDP": reflect.ValueOf(net.ListenUDP),
"ListenUnix": reflect.ValueOf(net.ListenUnix),
"ListenUnixgram": reflect.ValueOf(net.ListenUnixgram),
"LookupAddr": reflect.ValueOf(net.LookupAddr),
"LookupCNAME": reflect.ValueOf(net.LookupCNAME),
"LookupHost": reflect.ValueOf(net.LookupHost),
"LookupIP": reflect.ValueOf(net.LookupIP),
"LookupMX": reflect.ValueOf(net.LookupMX),
"LookupNS": reflect.ValueOf(net.LookupNS),
"LookupPort": reflect.ValueOf(net.LookupPort),
"LookupSRV": reflect.ValueOf(net.LookupSRV),
"LookupTXT": reflect.ValueOf(net.LookupTXT),
"ParseCIDR": reflect.ValueOf(net.ParseCIDR),
"ParseIP": reflect.ValueOf(net.ParseIP),
"ParseMAC": reflect.ValueOf(net.ParseMAC),
"Pipe": reflect.ValueOf(net.Pipe),
"ResolveIPAddr": reflect.ValueOf(net.ResolveIPAddr),
"ResolveTCPAddr": reflect.ValueOf(net.ResolveTCPAddr),
"ResolveUDPAddr": reflect.ValueOf(net.ResolveUDPAddr),
"ResolveUnixAddr": reflect.ValueOf(net.ResolveUnixAddr),
"SplitHostPort": reflect.ValueOf(net.SplitHostPort),
"TCPAddrFromAddrPort": reflect.ValueOf(net.TCPAddrFromAddrPort),
"UDPAddrFromAddrPort": reflect.ValueOf(net.UDPAddrFromAddrPort),
// type definitions
"Addr": reflect.ValueOf((*net.Addr)(nil)),
"AddrError": reflect.ValueOf((*net.AddrError)(nil)),
"Buffers": reflect.ValueOf((*net.Buffers)(nil)),
"Conn": reflect.ValueOf((*net.Conn)(nil)),
"DNSConfigError": reflect.ValueOf((*net.DNSConfigError)(nil)),
"DNSError": reflect.ValueOf((*net.DNSError)(nil)),
"Dialer": reflect.ValueOf((*net.Dialer)(nil)),
"Error": reflect.ValueOf((*net.Error)(nil)),
"Flags": reflect.ValueOf((*net.Flags)(nil)),
"HardwareAddr": reflect.ValueOf((*net.HardwareAddr)(nil)),
"IP": reflect.ValueOf((*net.IP)(nil)),
"IPAddr": reflect.ValueOf((*net.IPAddr)(nil)),
"IPConn": reflect.ValueOf((*net.IPConn)(nil)),
"IPMask": reflect.ValueOf((*net.IPMask)(nil)),
"IPNet": reflect.ValueOf((*net.IPNet)(nil)),
"Interface": reflect.ValueOf((*net.Interface)(nil)),
"InvalidAddrError": reflect.ValueOf((*net.InvalidAddrError)(nil)),
"ListenConfig": reflect.ValueOf((*net.ListenConfig)(nil)),
"Listener": reflect.ValueOf((*net.Listener)(nil)),
"MX": reflect.ValueOf((*net.MX)(nil)),
"NS": reflect.ValueOf((*net.NS)(nil)),
"OpError": reflect.ValueOf((*net.OpError)(nil)),
"PacketConn": reflect.ValueOf((*net.PacketConn)(nil)),
"ParseError": reflect.ValueOf((*net.ParseError)(nil)),
"Resolver": reflect.ValueOf((*net.Resolver)(nil)),
"SRV": reflect.ValueOf((*net.SRV)(nil)),
"TCPAddr": reflect.ValueOf((*net.TCPAddr)(nil)),
"TCPConn": reflect.ValueOf((*net.TCPConn)(nil)),
"TCPListener": reflect.ValueOf((*net.TCPListener)(nil)),
"UDPAddr": reflect.ValueOf((*net.UDPAddr)(nil)),
"UDPConn": reflect.ValueOf((*net.UDPConn)(nil)),
"UnixAddr": reflect.ValueOf((*net.UnixAddr)(nil)),
"UnixConn": reflect.ValueOf((*net.UnixConn)(nil)),
"UnixListener": reflect.ValueOf((*net.UnixListener)(nil)),
"UnknownNetworkError": reflect.ValueOf((*net.UnknownNetworkError)(nil)),
// interface wrapper definitions
"_Addr": reflect.ValueOf((*_net_Addr)(nil)),
"_Conn": reflect.ValueOf((*_net_Conn)(nil)),
"_Error": reflect.ValueOf((*_net_Error)(nil)),
"_Listener": reflect.ValueOf((*_net_Listener)(nil)),
"_PacketConn": reflect.ValueOf((*_net_PacketConn)(nil)),
}
}
// _net_Addr is an interface wrapper for Addr type
type _net_Addr struct {
IValue interface{}
WNetwork func() string
WString func() string
}
func (W _net_Addr) Network() string { return W.WNetwork() }
func (W _net_Addr) String() string {
if W.WString == nil {
return ""
}
return W.WString()
}
// _net_Conn is an interface wrapper for Conn type
type _net_Conn struct {
IValue interface{}
WClose func() error
WLocalAddr func() net.Addr
WRead func(b []byte) (n int, err error)
WRemoteAddr func() net.Addr
WSetDeadline func(t time.Time) error
WSetReadDeadline func(t time.Time) error
WSetWriteDeadline func(t time.Time) error
WWrite func(b []byte) (n int, err error)
}
func (W _net_Conn) Close() error { return W.WClose() }
func (W _net_Conn) LocalAddr() net.Addr { return W.WLocalAddr() }
func (W _net_Conn) Read(b []byte) (n int, err error) { return W.WRead(b) }
func (W _net_Conn) RemoteAddr() net.Addr { return W.WRemoteAddr() }
func (W _net_Conn) SetDeadline(t time.Time) error { return W.WSetDeadline(t) }
func (W _net_Conn) SetReadDeadline(t time.Time) error { return W.WSetReadDeadline(t) }
func (W _net_Conn) SetWriteDeadline(t time.Time) error { return W.WSetWriteDeadline(t) }
func (W _net_Conn) Write(b []byte) (n int, err error) { return W.WWrite(b) }
// _net_Error is an interface wrapper for Error type
type _net_Error struct {
IValue interface{}
WError func() string
WTemporary func() bool
WTimeout func() bool
}
func (W _net_Error) Error() string { return W.WError() }
func (W _net_Error) Temporary() bool { return W.WTemporary() }
func (W _net_Error) Timeout() bool { return W.WTimeout() }
// _net_Listener is an interface wrapper for Listener type
type _net_Listener struct {
IValue interface{}
WAccept func() (net.Conn, error)
WAddr func() net.Addr
WClose func() error
}
func (W _net_Listener) Accept() (net.Conn, error) { return W.WAccept() }
func (W _net_Listener) Addr() net.Addr { return W.WAddr() }
func (W _net_Listener) Close() error { return W.WClose() }
// _net_PacketConn is an interface wrapper for PacketConn type
type _net_PacketConn struct {
IValue interface{}
WClose func() error
WLocalAddr func() net.Addr
WReadFrom func(p []byte) (n int, addr net.Addr, err error)
WSetDeadline func(t time.Time) error
WSetReadDeadline func(t time.Time) error
WSetWriteDeadline func(t time.Time) error
WWriteTo func(p []byte, addr net.Addr) (n int, err error)
}
func (W _net_PacketConn) Close() error { return W.WClose() }
func (W _net_PacketConn) LocalAddr() net.Addr { return W.WLocalAddr() }
func (W _net_PacketConn) ReadFrom(p []byte) (n int, addr net.Addr, err error) { return W.WReadFrom(p) }
func (W _net_PacketConn) SetDeadline(t time.Time) error { return W.WSetDeadline(t) }
func (W _net_PacketConn) SetReadDeadline(t time.Time) error { return W.WSetReadDeadline(t) }
func (W _net_PacketConn) SetWriteDeadline(t time.Time) error { return W.WSetWriteDeadline(t) }
func (W _net_PacketConn) WriteTo(p []byte, addr net.Addr) (n int, err error) {
return W.WWriteTo(p, addr)
}
================================================
FILE: stdlib/go1_22_net_http.go
================================================
// Code generated by 'yaegi extract net/http'. DO NOT EDIT.
//go:build go1.22
// +build go1.22
package stdlib
import (
"bufio"
"go/constant"
"go/token"
"io/fs"
"net"
"net/http"
"net/url"
"reflect"
)
func init() {
Symbols["net/http/http"] = map[string]reflect.Value{
// function, constant and variable definitions
"AllowQuerySemicolons": reflect.ValueOf(http.AllowQuerySemicolons),
"CanonicalHeaderKey": reflect.ValueOf(http.CanonicalHeaderKey),
"DefaultClient": reflect.ValueOf(&http.DefaultClient).Elem(),
"DefaultMaxHeaderBytes": reflect.ValueOf(constant.MakeFromLiteral("1048576", token.INT, 0)),
"DefaultMaxIdleConnsPerHost": reflect.ValueOf(constant.MakeFromLiteral("2", token.INT, 0)),
"DefaultServeMux": reflect.ValueOf(&http.DefaultServeMux).Elem(),
"DefaultTransport": reflect.ValueOf(&http.DefaultTransport).Elem(),
"DetectContentType": reflect.ValueOf(http.DetectContentType),
"ErrAbortHandler": reflect.ValueOf(&http.ErrAbortHandler).Elem(),
"ErrBodyNotAllowed": reflect.ValueOf(&http.ErrBodyNotAllowed).Elem(),
"ErrBodyReadAfterClose": reflect.ValueOf(&http.ErrBodyReadAfterClose).Elem(),
"ErrContentLength": reflect.ValueOf(&http.ErrContentLength).Elem(),
"ErrHandlerTimeout": reflect.ValueOf(&http.ErrHandlerTimeout).Elem(),
"ErrHeaderTooLong": reflect.ValueOf(&http.ErrHeaderTooLong).Elem(),
"ErrHijacked": reflect.ValueOf(&http.ErrHijacked).Elem(),
"ErrLineTooLong": reflect.ValueOf(&http.ErrLineTooLong).Elem(),
"ErrMissingBoundary": reflect.ValueOf(&http.ErrMissingBoundary).Elem(),
"ErrMissingContentLength": reflect.ValueOf(&http.ErrMissingContentLength).Elem(),
"ErrMissingFile": reflect.ValueOf(&http.ErrMissingFile).Elem(),
"ErrNoCookie": reflect.ValueOf(&http.ErrNoCookie).Elem(),
"ErrNoLocation": reflect.ValueOf(&http.ErrNoLocation).Elem(),
"ErrNotMultipart": reflect.ValueOf(&http.ErrNotMultipart).Elem(),
"ErrNotSupported": reflect.ValueOf(&http.ErrNotSupported).Elem(),
"ErrSchemeMismatch": reflect.ValueOf(&http.ErrSchemeMismatch).Elem(),
"ErrServerClosed": reflect.ValueOf(&http.ErrServerClosed).Elem(),
"ErrShortBody": reflect.ValueOf(&http.ErrShortBody).Elem(),
"ErrSkipAltProtocol": reflect.ValueOf(&http.ErrSkipAltProtocol).Elem(),
"ErrUnexpectedTrailer": reflect.ValueOf(&http.ErrUnexpectedTrailer).Elem(),
"ErrUseLastResponse": reflect.ValueOf(&http.ErrUseLastResponse).Elem(),
"ErrWriteAfterFlush": reflect.ValueOf(&http.ErrWriteAfterFlush).Elem(),
"Error": reflect.ValueOf(http.Error),
"FS": reflect.ValueOf(http.FS),
"FileServer": reflect.ValueOf(http.FileServer),
"FileServerFS": reflect.ValueOf(http.FileServerFS),
"Get": reflect.ValueOf(http.Get),
"Handle": reflect.ValueOf(http.Handle),
"HandleFunc": reflect.ValueOf(http.HandleFunc),
"Head": reflect.ValueOf(http.Head),
"ListenAndServe": reflect.ValueOf(http.ListenAndServe),
"ListenAndServeTLS": reflect.ValueOf(http.ListenAndServeTLS),
"LocalAddrContextKey": reflect.ValueOf(&http.LocalAddrContextKey).Elem(),
"MaxBytesHandler": reflect.ValueOf(http.MaxBytesHandler),
"MaxBytesReader": reflect.ValueOf(http.MaxBytesReader),
"MethodConnect": reflect.ValueOf(constant.MakeFromLiteral("\"CONNECT\"", token.STRING, 0)),
"MethodDelete": reflect.ValueOf(constant.MakeFromLiteral("\"DELETE\"", token.STRING, 0)),
"MethodGet": reflect.ValueOf(constant.MakeFromLiteral("\"GET\"", token.STRING, 0)),
"MethodHead": reflect.ValueOf(constant.MakeFromLiteral("\"HEAD\"", token.STRING, 0)),
"MethodOptions": reflect.ValueOf(constant.MakeFromLiteral("\"OPTIONS\"", token.STRING, 0)),
"MethodPatch": reflect.ValueOf(constant.MakeFromLiteral("\"PATCH\"", token.STRING, 0)),
"MethodPost": reflect.ValueOf(constant.MakeFromLiteral("\"POST\"", token.STRING, 0)),
"MethodPut": reflect.ValueOf(constant.MakeFromLiteral("\"PUT\"", token.STRING, 0)),
"MethodTrace": reflect.ValueOf(constant.MakeFromLiteral("\"TRACE\"", token.STRING, 0)),
"NewFileTransport": reflect.ValueOf(http.NewFileTransport),
"NewFileTransportFS": reflect.ValueOf(http.NewFileTransportFS),
"NewRequest": reflect.ValueOf(http.NewRequest),
"NewRequestWithContext": reflect.ValueOf(http.NewRequestWithContext),
"NewResponseController": reflect.ValueOf(http.NewResponseController),
"NewServeMux": reflect.ValueOf(http.NewServeMux),
"NoBody": reflect.ValueOf(&http.NoBody).Elem(),
"NotFound": reflect.ValueOf(http.NotFound),
"NotFoundHandler": reflect.ValueOf(http.NotFoundHandler),
"ParseHTTPVersion": reflect.ValueOf(http.ParseHTTPVersion),
"ParseTime": reflect.ValueOf(http.ParseTime),
"Post": reflect.ValueOf(http.Post),
"PostForm": reflect.ValueOf(http.PostForm),
"ProxyFromEnvironment": reflect.ValueOf(http.ProxyFromEnvironment),
"ProxyURL": reflect.ValueOf(http.ProxyURL),
"ReadRequest": reflect.ValueOf(http.ReadRequest),
"ReadResponse": reflect.ValueOf(http.ReadResponse),
"Redirect": reflect.ValueOf(http.Redirect),
"RedirectHandler": reflect.ValueOf(http.RedirectHandler),
"SameSiteDefaultMode": reflect.ValueOf(http.SameSiteDefaultMode),
"SameSiteLaxMode": reflect.ValueOf(http.SameSiteLaxMode),
"SameSiteNoneMode": reflect.ValueOf(http.SameSiteNoneMode),
"SameSiteStrictMode": reflect.ValueOf(http.SameSiteStrictMode),
"Serve": reflect.ValueOf(http.Serve),
"ServeContent": reflect.ValueOf(http.ServeContent),
"ServeFile": reflect.ValueOf(http.ServeFile),
"ServeFileFS": reflect.ValueOf(http.ServeFileFS),
"ServeTLS": reflect.ValueOf(http.ServeTLS),
"ServerContextKey": reflect.ValueOf(&http.ServerContextKey).Elem(),
"SetCookie": reflect.ValueOf(http.SetCookie),
"StateActive": reflect.ValueOf(http.StateActive),
"StateClosed": reflect.ValueOf(http.StateClosed),
"StateHijacked": reflect.ValueOf(http.StateHijacked),
"StateIdle": reflect.ValueOf(http.StateIdle),
"StateNew": reflect.ValueOf(http.StateNew),
"StatusAccepted": reflect.ValueOf(constant.MakeFromLiteral("202", token.INT, 0)),
"StatusAlreadyReported": reflect.ValueOf(constant.MakeFromLiteral("208", token.INT, 0)),
"StatusBadGateway": reflect.ValueOf(constant.MakeFromLiteral("502", token.INT, 0)),
"StatusBadRequest": reflect.ValueOf(constant.MakeFromLiteral("400", token.INT, 0)),
"StatusConflict": reflect.ValueOf(constant.MakeFromLiteral("409", token.INT, 0)),
"StatusContinue": reflect.ValueOf(constant.MakeFromLiteral("100", token.INT, 0)),
"StatusCreated": reflect.ValueOf(constant.MakeFromLiteral("201", token.INT, 0)),
"StatusEarlyHints": reflect.ValueOf(constant.MakeFromLiteral("103", token.INT, 0)),
"StatusExpectationFailed": reflect.ValueOf(constant.MakeFromLiteral("417", token.INT, 0)),
"StatusFailedDependency": reflect.ValueOf(constant.MakeFromLiteral("424", token.INT, 0)),
"StatusForbidden": reflect.ValueOf(constant.MakeFromLiteral("403", token.INT, 0)),
"StatusFound": reflect.ValueOf(constant.MakeFromLiteral("302", token.INT, 0)),
"StatusGatewayTimeout": reflect.ValueOf(constant.MakeFromLiteral("504", token.INT, 0)),
"StatusGone": reflect.ValueOf(constant.MakeFromLiteral("410", token.INT, 0)),
"StatusHTTPVersionNotSupported": reflect.ValueOf(constant.MakeFromLiteral("505", token.INT, 0)),
"StatusIMUsed": reflect.ValueOf(constant.MakeFromLiteral("226", token.INT, 0)),
"StatusInsufficientStorage": reflect.ValueOf(constant.MakeFromLiteral("507", token.INT, 0)),
"StatusInternalServerError": reflect.ValueOf(constant.MakeFromLiteral("500", token.INT, 0)),
"StatusLengthRequired": reflect.ValueOf(constant.MakeFromLiteral("411", token.INT, 0)),
"StatusLocked": reflect.ValueOf(constant.MakeFromLiteral("423", token.INT, 0)),
"StatusLoopDetected": reflect.ValueOf(constant.MakeFromLiteral("508", token.INT, 0)),
"StatusMethodNotAllowed": reflect.ValueOf(constant.MakeFromLiteral("405", token.INT, 0)),
"StatusMisdirectedRequest": reflect.ValueOf(constant.MakeFromLiteral("421", token.INT, 0)),
"StatusMovedPermanently": reflect.ValueOf(constant.MakeFromLiteral("301", token.INT, 0)),
"StatusMultiStatus": reflect.ValueOf(constant.MakeFromLiteral("207", token.INT, 0)),
"StatusMultipleChoices": reflect.ValueOf(constant.MakeFromLiteral("300", token.INT, 0)),
"StatusNetworkAuthenticationRequired": reflect.ValueOf(constant.MakeFromLiteral("511", token.INT, 0)),
"StatusNoContent": reflect.ValueOf(constant.MakeFromLiteral("204", token.INT, 0)),
"StatusNonAuthoritativeInfo": reflect.ValueOf(constant.MakeFromLiteral("203", token.INT, 0)),
"StatusNotAcceptable": reflect.ValueOf(constant.MakeFromLiteral("406", token.INT, 0)),
"StatusNotExtended": reflect.ValueOf(constant.MakeFromLiteral("510", token.INT, 0)),
"StatusNotFound": reflect.ValueOf(constant.MakeFromLiteral("404", token.INT, 0)),
"StatusNotImplemented": reflect.ValueOf(constant.MakeFromLiteral("501", token.INT, 0)),
"StatusNotModified": reflect.ValueOf(constant.MakeFromLiteral("304", token.INT, 0)),
"StatusOK": reflect.ValueOf(constant.MakeFromLiteral("200", token.INT, 0)),
"StatusPartialContent": reflect.ValueOf(constant.MakeFromLiteral("206", token.INT, 0)),
"StatusPaymentRequired": reflect.ValueOf(constant.MakeFromLiteral("402", token.INT, 0)),
"StatusPermanentRedirect": reflect.ValueOf(constant.MakeFromLiteral("308", token.INT, 0)),
"StatusPreconditionFailed": reflect.ValueOf(constant.MakeFromLiteral("412", token.INT, 0)),
"StatusPreconditionRequired": reflect.ValueOf(constant.MakeFromLiteral("428", token.INT, 0)),
"StatusProcessing": reflect.ValueOf(constant.MakeFromLiteral("102", token.INT, 0)),
"StatusProxyAuthRequired": reflect.ValueOf(constant.MakeFromLiteral("407", token.INT, 0)),
"StatusRequestEntityTooLarge": reflect.ValueOf(constant.MakeFromLiteral("413", token.INT, 0)),
"StatusRequestHeaderFieldsTooLarge": reflect.ValueOf(constant.MakeFromLiteral("431", token.INT, 0)),
"StatusRequestTimeout": reflect.ValueOf(constant.MakeFromLiteral("408", token.INT, 0)),
"StatusRequestURITooLong": reflect.ValueOf(constant.MakeFromLiteral("414", token.INT, 0)),
"StatusRequestedRangeNotSatisfiable": reflect.ValueOf(constant.MakeFromLiteral("416", token.INT, 0)),
"StatusResetContent": reflect.ValueOf(constant.MakeFromLiteral("205", token.INT, 0)),
"StatusSeeOther": reflect.ValueOf(constant.MakeFromLiteral("303", token.INT, 0)),
"StatusServiceUnavailable": reflect.ValueOf(constant.MakeFromLiteral("503", token.INT, 0)),
"StatusSwitchingProtocols": reflect.ValueOf(constant.MakeFromLiteral("101", token.INT, 0)),
"StatusTeapot": reflect.ValueOf(constant.MakeFromLiteral("418", token.INT, 0)),
"StatusTemporaryRedirect": reflect.ValueOf(constant.MakeFromLiteral("307", token.INT, 0)),
"StatusText": reflect.ValueOf(http.StatusText),
"StatusTooEarly": reflect.ValueOf(constant.MakeFromLiteral("425", token.INT, 0)),
"StatusTooManyRequests": reflect.ValueOf(constant.MakeFromLiteral("429", token.INT, 0)),
"StatusUnauthorized": reflect.ValueOf(constant.MakeFromLiteral("401", token.INT, 0)),
"StatusUnavailableForLegalReasons": reflect.ValueOf(constant.MakeFromLiteral("451", token.INT, 0)),
"StatusUnprocessableEntity": reflect.ValueOf(constant.MakeFromLiteral("422", token.INT, 0)),
"StatusUnsupportedMediaType": reflect.ValueOf(constant.MakeFromLiteral("415", token.INT, 0)),
"StatusUpgradeRequired": reflect.ValueOf(constant.MakeFromLiteral("426", token.INT, 0)),
"StatusUseProxy": reflect.ValueOf(constant.MakeFromLiteral("305", token.INT, 0)),
"StatusVariantAlsoNegotiates": reflect.ValueOf(constant.MakeFromLiteral("506", token.INT, 0)),
"StripPrefix": reflect.ValueOf(http.StripPrefix),
"TimeFormat": reflect.ValueOf(constant.MakeFromLiteral("\"Mon, 02 Jan 2006 15:04:05 GMT\"", token.STRING, 0)),
"TimeoutHandler": reflect.ValueOf(http.TimeoutHandler),
"TrailerPrefix": reflect.ValueOf(constant.MakeFromLiteral("\"Trailer:\"", token.STRING, 0)),
// type definitions
"Client": reflect.ValueOf((*http.Client)(nil)),
"CloseNotifier": reflect.ValueOf((*http.CloseNotifier)(nil)),
"ConnState": reflect.ValueOf((*http.ConnState)(nil)),
"Cookie": reflect.ValueOf((*http.Cookie)(nil)),
"CookieJar": reflect.ValueOf((*http.CookieJar)(nil)),
"Dir": reflect.ValueOf((*http.Dir)(nil)),
"File": reflect.ValueOf((*http.File)(nil)),
"FileSystem": reflect.ValueOf((*http.FileSystem)(nil)),
"Flusher": reflect.ValueOf((*http.Flusher)(nil)),
"Handler": reflect.ValueOf((*http.Handler)(nil)),
"HandlerFunc": reflect.ValueOf((*http.HandlerFunc)(nil)),
"Header": reflect.ValueOf((*http.Header)(nil)),
"Hijacker": reflect.ValueOf((*http.Hijacker)(nil)),
"MaxBytesError": reflect.ValueOf((*http.MaxBytesError)(nil)),
"ProtocolError": reflect.ValueOf((*http.ProtocolError)(nil)),
"PushOptions": reflect.ValueOf((*http.PushOptions)(nil)),
"Pusher": reflect.ValueOf((*http.Pusher)(nil)),
"Request": reflect.ValueOf((*http.Request)(nil)),
"Response": reflect.ValueOf((*http.Response)(nil)),
"ResponseController": reflect.ValueOf((*http.ResponseController)(nil)),
"ResponseWriter": reflect.ValueOf((*http.ResponseWriter)(nil)),
"RoundTripper": reflect.ValueOf((*http.RoundTripper)(nil)),
"SameSite": reflect.ValueOf((*http.SameSite)(nil)),
"ServeMux": reflect.ValueOf((*http.ServeMux)(nil)),
"Server": reflect.ValueOf((*http.Server)(nil)),
"Transport": reflect.ValueOf((*http.Transport)(nil)),
// interface wrapper definitions
"_CloseNotifier": reflect.ValueOf((*_net_http_CloseNotifier)(nil)),
"_CookieJar": reflect.ValueOf((*_net_http_CookieJar)(nil)),
"_File": reflect.ValueOf((*_net_http_File)(nil)),
"_FileSystem": reflect.ValueOf((*_net_http_FileSystem)(nil)),
"_Flusher": reflect.ValueOf((*_net_http_Flusher)(nil)),
"_Handler": reflect.ValueOf((*_net_http_Handler)(nil)),
"_Hijacker": reflect.ValueOf((*_net_http_Hijacker)(nil)),
"_Pusher": reflect.ValueOf((*_net_http_Pusher)(nil)),
"_ResponseWriter": reflect.ValueOf((*_net_http_ResponseWriter)(nil)),
"_RoundTripper": reflect.ValueOf((*_net_http_RoundTripper)(nil)),
}
}
// _net_http_CloseNotifier is an interface wrapper for CloseNotifier type
type _net_http_CloseNotifier struct {
IValue interface{}
WCloseNotify func() <-chan bool
}
func (W _net_http_CloseNotifier) CloseNotify() <
