interp: support calling goto from sub-scope

As opposed to other symbols, goto labels must be searched in included
scopes, not upper ones. Implement scope.lookdown to perform this,
to allow calls to goto to be embedded in included scopes where label
is defined.

Fixes #953.

.gitignore

@@ -3,7 +3,7 @@
 *.dot
 .idea/
 /yaegi
-cmd/goexports/goexports
+internal/cmd/extract/extract
 example/inception/inception
 _test/tmp/
 /dist

.golangci.toml

@@ -41,6 +41,8 @@
     "testpackage",
     "goerr113",
     "nestif",
+    "exhaustive",
+    "nlreturn",
   ]
 
 [issues]

.goreleaser.yml

@@ -3,32 +3,7 @@ project_name: yaegi
 builds:
   - id: yaegi
     binary: yaegi
-    main: ./cmd/yaegi/yaegi.go
-
-    goos:
-      - darwin
-      - linux
-#      - windows
-      - freebsd
-      - openbsd
-      - solaris
-    goarch:
-      - amd64
-      - 386
-      - arm
-      - arm64
-    goarm:
-      - 7
-      - 6
-      - 5
-
-    ignore:
-      - goos: darwin
-        goarch: 386
-
-  - id: goexports
-    binary: goexports
-    main: ./cmd/goexports/goexports.go
+    main: ./cmd/yaegi/
 
     goos:
       - darwin
@@ -70,3 +45,19 @@ archives:
         format: zip
     files:
       - LICENSE
+
+brews:
+  - github:
+      owner: traefik
+      name: homebrew-tap
+    commit_author:
+      name: traefiker
+      email: 30906710+traefiker@users.noreply.github.com
+    folder: Formula
+    homepage: https://github.com/traefik/yaegi
+    description: |
+      Yaegi is Another Elegant Go Interpreter.
+      It powers executable Go scripts and plugins, in embedded interpreters
+      or interactive shells, on top of the Go runtime.
+    test: |
+      system "#{bin}/yaegi version"

.travis.yml

@@ -19,15 +19,15 @@ cache:
 matrix:
   fast_finish: true
   include:
-    - go: 1.13.x
     - go: 1.14.x
+    - go: 1.15.x
       env: STABLE=true
 
 env:
   global:
     - GO111MODULE=on
 
-go_import_path: github.com/containous/yaegi
+go_import_path: github.com/traefik/yaegi
 
 before_install:
   # Install linters and misspell

CONTRIBUTING.md

@@ -3,7 +3,7 @@
 Yaegi is an open source project, and your feedback and contributions
 are needed and always welcome.
 
-[Issues] and [Pull Requests] are opened at https://github.com/containous/yaegi.
+[Issues] and [Pull Requests] are opened at https://github.com/traefik/yaegi.
 
 Non trivial changes should be discussed with the project maintainers by
 opening a [Feature Request] clearly explaining rationale, background
@@ -13,12 +13,12 @@ discussions.
 Once the proposal is approved, a Pull Request can be opened. If you want
 to provide early visibility to reviewers, create a [Draft Pull Request].
 
-We will also require you to sign the [Containous Contributor License Agreement]
+We will also require you to sign the [Traefik Contributor License Agreement]
 after you submit your first pull request to this project. The link to sign the
 agreement will be presented to you in the web interface of the pull request.
 
-[Issues]: https://github.com/containous/yaegi/issues
-[Pull Requests]: https://github.com/containous/yaegi/issues
-[Feature Request]: https://github.com/containous/yaegi/issues/new?template=feature_request.md
+[Issues]: https://github.com/traefik/yaegi/issues
+[Pull Requests]: https://github.com/traefik/yaegi/issues
+[Feature Request]: https://github.com/traefik/yaegi/issues/new?template=feature_request.md
 [Draft Pull Request]: https://github.blog/2019-02-14-introducing-draft-pull-requests/
-[Containous Contributor License Agreement]: https://cla-assistant.io/containous/yaegi
+[Traefik Labs Contributor License Agreement]: https://cla-assistant.io/traefik/yaegi

LICENSE

@@ -187,6 +187,7 @@
       identification within third-party archives.
 
    Copyright 2019 Containous SAS
+   Copyright 2020 Traefik Labs SAS
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

Makefile

@@ -3,21 +3,28 @@ check:
 	golangci-lint run
 
 # Generate stdlib/syscall/syscall_GOOS_GOARCH.go for all platforms
-gen_all_syscall: cmd/goexports/goexports
-	@cd stdlib/syscall && \
-	for v in $$(go tool dist list); do \
+gen_all_syscall: internal/cmd/extract/extract
+	@for v in $$(go tool dist list); do \
 		echo syscall_$${v%/*}_$${v#*/}.go; \
-		GOOS=$${v%/*} GOARCH=$${v#*/} go generate; \
+		GOOS=$${v%/*} GOARCH=$${v#*/} go generate ./stdlib/syscall ./stdlib/unrestricted; \
 	done
 
-cmd/goexports/goexports: cmd/goexports/goexports.go
-	go generate cmd/goexports/goexports.go
+internal/cmd/extract/extract:
+	rm -f internal/cmd/extract/extract
+	go generate ./internal/cmd/extract
 
 generate: gen_all_syscall
 	go generate
 
-tests:
-	GO111MODULE=off go test -v ./...
-	GO111MODULE=off go test -race ./interp
+install:
+	GOFLAGS=-ldflags=-X=main.version=$$(git describe --tags) go install ./...
 
-.PHONY: check gen_all_syscall gen_tests
+tests:
+	go test -v ./...
+	go test -race ./interp
+
+# https://github.com/goreleaser/godownloader
+install.sh: .goreleaser.yml
+	godownloader --repo=traefik/yaegi -o install.sh .goreleaser.yml
+
+.PHONY: check gen_all_syscall gen_tests generate_downloader internal/cmd/extract/extract install

README.md

@@ -2,9 +2,9 @@
 <img width="400" src="doc/images/yaegi.png" alt="Yaegi" title="Yaegi" />
 </p>
 
-[![release](https://img.shields.io/github/tag-date/containous/yaegi.svg?label=alpha)](https://github.com/containous/yaegi/releases)
-[![Build Status](https://travis-ci.com/containous/yaegi.svg?branch=master)](https://travis-ci.com/containous/yaegi)
-[![GoDoc](https://godoc.org/github.com/containous/yaegi?status.svg)](https://godoc.org/github.com/containous/yaegi)
+[![release](https://img.shields.io/github/tag-date/traefik/yaegi.svg?label=alpha)](https://github.com/traefik/yaegi/releases)
+[![Build Status](https://travis-ci.com/traefik/yaegi.svg?branch=master)](https://travis-ci.com/traefik/yaegi)
+[![GoDoc](https://godoc.org/github.com/traefik/yaegi?status.svg)](https://godoc.org/github.com/traefik/yaegi)
 [![Discourse status](https://img.shields.io/discourse/https/community.containo.us/status?label=Community&style=social)](https://community.containo.us/c/yaegi)
 
 Yaegi is Another Elegant Go Interpreter.
@@ -25,18 +25,24 @@ It powers executable Go scripts and plugins, in embedded interpreters or interac
 ### Go package
 
 ```go
-import "github.com/containous/yaegi/interp"
+import "github.com/traefik/yaegi/interp"
 ```
 
 ### Command-line executable
 
 ```bash
-go get -u github.com/containous/yaegi/cmd/yaegi
+go get -u github.com/traefik/yaegi/cmd/yaegi
 ```
 
 Note that you can use [rlwrap](https://github.com/hanslub42/rlwrap) (install with your favorite package manager),
 and alias the `yaegi` command in `alias yaegi='rlwrap yaegi'` in your `~/.bashrc`, to have history and command line edition.
 
+### CI Integration
+
+```bash
+curl -sfL https://raw.githubusercontent.com/traefik/yaegi/master/install.sh | bash -s -- -b $GOPATH/bin v0.9.0
+```
+
 ## Usage
 
 ### As an embedded interpreter
@@ -47,8 +53,8 @@ Create an interpreter with `New()`, run Go code with `Eval()`:
 package main
 
 import (
-	"github.com/containous/yaegi/interp"
-	"github.com/containous/yaegi/stdlib"
+	"github.com/traefik/yaegi/interp"
+	"github.com/traefik/yaegi/stdlib"
 )
 
 func main() {
@@ -68,7 +74,7 @@ func main() {
 }
 ```
 
-[Go Playground](https://play.golang.org/p/zzvw4VlerLP)
+[Go Playground](https://play.golang.org/p/2n-EpZbMYI9)
 
 ### As a dynamic extension framework
 
@@ -81,7 +87,7 @@ The following program is compiled ahead of time, except `bar()` which is interpr
 ```go
 package main
 
-import "github.com/containous/yaegi/interp"
+import "github.com/traefik/yaegi/interp"
 
 const src = `package foo
 func Bar(s string) string { return s + "-Foo" }`
@@ -106,7 +112,7 @@ func main() {
 }
 ```
 
-[Go Playground](https://play.golang.org/p/6SEAoaO7n0U)
+[Go Playground](https://play.golang.org/p/WvwH4JqrU-p)
 
 ### As a command-line interpreter
 
@@ -122,10 +128,20 @@ Hello World
 >
 ```
 
-Or interpret Go files:
+Note that in interactive mode, all stdlib package are pre-imported,
+you can use them directly:
 
 ```console
-$ yaegi cmd/yaegi/yaegi.go
+$ yaegi
+> reflect.TypeOf(time.Date)
+: func(int, time.Month, int, int, int, int, int, *time.Location) time.Time
+>
+```
+
+Or interpret Go packages, directories or files, including itself:
+
+```console
+$ yaegi -syscall -unsafe -unrestricted github.com/traefik/yaegi/cmd/yaegi
 >
 ```
 
@@ -155,11 +171,11 @@ Documentation about Yaegi commands and libraries can be found at usual [godoc.or
 
 Beside the known [bugs] which are supposed to be fixed in the short term, there are some limitations not planned to be addressed soon:
 
-- assembly files (`.s`) are not supported
-- calling C code is not supported (no virtual "C" package)
-- interfaces to be used from the pre-compiled code can not be added dynamically, as it is required to pre-compile interface wrappers
-- representation of types by `reflect` and printing values using %T may give different results between compiled mode and interpreted mode
-- interpreting computation intensive code is likely to remain significantly slower than in compiled mode
+- Assembly files (`.s`) are not supported.
+- Calling C code is not supported (no virtual "C" package).
+- Interfaces to be used from the pre-compiled code can not be added dynamically, as it is required to pre-compile interface wrappers.
+- Representation of types by `reflect` and printing values using %T may give different results between compiled mode and interpreted mode.
+- Interpreting computation intensive code is likely to remain significantly slower than in compiled mode.
 
 ## Contributing
 
@@ -170,7 +186,7 @@ Beside the known [bugs] which are supposed to be fixed in the short term, there
 [Apache 2.0][License].
 
 [specs]: https://golang.org/ref/spec
-[docs]: https://godoc.org/github.com/containous/yaegi
-[license]: https://github.com/containous/yaegi/blob/master/LICENSE
-[github]: https://github.com/containous/yaegi
-[bugs]: https://github.com/containous/yaegi/issues?q=is%3Aissue+is%3Aopen+label%3Abug
+[docs]: https://godoc.org/github.com/traefik/yaegi
+[license]: https://github.com/traefik/yaegi/blob/master/LICENSE
+[github]: https://github.com/traefik/yaegi
+[bugs]: https://github.com/traefik/yaegi/issues?q=is%3Aissue+is%3Aopen+label%3Abug

_test/a42.go

@@ -0,0 +1,16 @@
+package main
+
+import (
+	"encoding/binary"
+	"fmt"
+)
+
+func main() {
+	var b [8]byte
+	binary.LittleEndian.PutUint64(b[:], uint64(1))
+
+	fmt.Println(b)
+}
+
+// Output:
+// [1 0 0 0 0 0 0 0]

_test/a43.go

@@ -0,0 +1,17 @@
+package main
+
+import "fmt"
+
+type T [l1 + l2]int
+
+const (
+	l1 = 2
+	l2 = 3
+)
+
+func main() {
+	fmt.Println(T{})
+}
+
+// Output:
+// [0 0 0 0 0]

_test/a44.go

@@ -0,0 +1,12 @@
+package main
+
+var a = [max]int{}
+
+const max = 32
+
+func main() {
+	println(len(a))
+}
+
+// Output:
+// 32

_test/addr0.go

@@ -0,0 +1,25 @@
+package main
+
+import (
+	"fmt"
+	"net/http"
+)
+
+type extendedRequest struct {
+	http.Request
+
+	Data string
+}
+
+func main() {
+	r := extendedRequest{}
+	req := &r.Request
+
+
+	fmt.Println(r)
+	fmt.Println(req)
+}
+
+// Output:
+// {{ <nil>  0 0 map[] <nil> <nil> 0 [] false  map[] map[] <nil> map[]   <nil> <nil> <nil> <nil>} }
+// &{ <nil>  0 0 map[] <nil> <nil> 0 [] false  map[] map[] <nil> map[]   <nil> <nil> <nil> <nil>}

_test/addr1.go

@@ -0,0 +1,22 @@
+package main
+
+import "fmt"
+
+type T struct {
+	A int
+	B int
+}
+
+func main() {
+	a := &[]T{
+		{1, 2},
+		{3, 4},
+	}
+	fmt.Println("a:", a)
+	x := &(*a)[1:][0]
+	fmt.Println("x:", x)
+}
+
+// Output:
+// a: &[{1 2} {3 4}]
+// x: &{3 4}

_test/append1.go

@@ -0,0 +1,15 @@
+package main
+
+import (
+	"bufio"
+	"bytes"
+)
+
+func main() {
+	s := bufio.NewScanner(bytes.NewReader([]byte("Hello\nTest\nLine3")))
+	s.Scan()
+	println(string(append(s.Bytes(), []byte(" World")...)))
+}
+
+// Output:
+// Hello World

_test/append2.go

@@ -0,0 +1,15 @@
+package main
+
+import (
+	"bufio"
+	"bytes"
+)
+
+func main() {
+	s := bufio.NewScanner(bytes.NewReader([]byte("Hello\nTest\nLine3")))
+	s.Scan()
+	println(string(append(s.Bytes(), " World"...)))
+}
+
+// Output:
+// Hello World

_test/assign16.go

@@ -0,0 +1,15 @@
+package main
+
+type H struct {
+	bits uint
+}
+
+func main() {
+	h := &H{8}
+	var x uint = (1 << h.bits) >> 6
+
+	println(x)
+}
+
+// Output:
+// 4

_test/b1/foo/foo.go

@@ -1,6 +1,6 @@
 package foo
 
-import bar "github.com/containous/yaegi/_test/b2/foo"
+import bar "github.com/traefik/yaegi/_test/b2/foo"
 
 var Desc = "in b1/foo"
 

_test/binstruct_ptr_map0.go

@@ -0,0 +1,17 @@
+package main
+
+import (
+	"fmt"
+	"image"
+)
+
+func main() {
+	v := map[string]*image.Point{
+		"foo": {X: 3, Y: 2},
+		"bar": {X: 4, Y: 5},
+	}
+	fmt.Println(v["foo"], v["bar"])
+}
+
+// Output:
+// (3,2) (4,5)

_test/binstruct_ptr_slice0.go

@@ -0,0 +1,17 @@
+package main
+
+import (
+	"fmt"
+	"image"
+)
+
+func main() {
+	v := []*image.Point{
+		{X: 3, Y: 2},
+		{X: 4, Y: 5},
+	}
+	fmt.Println(v)
+}
+
+// Output:
+// [(3,2) (4,5)]

_test/binstruct_slice0.go

@@ -0,0 +1,16 @@
+package main
+
+import (
+	"fmt"
+	"image"
+)
+
+func main() {
+	v := []image.Point{
+		{X: 3, Y: 2},
+	}
+	fmt.Println(v)
+}
+
+// Output:
+// [(3,2)]

_test/c1/c1.go

@@ -1,5 +1,5 @@
 package c1
 
-import "github.com/containous/yaegi/_test/c2"
+import "github.com/traefik/yaegi/_test/c2"
 
 var C1 = c2.C2 + "x"

_test/c2/c2.go

@@ -1,5 +1,5 @@
 package c2
 
-import "github.com/containous/yaegi/_test/c1"
+import "github.com/traefik/yaegi/_test/c1"
 
 var C2 = c1.C1 + "Y"

_test/cli4.go

@@ -0,0 +1,51 @@
+package main
+
+import (
+	"fmt"
+	"io/ioutil"
+	"log"
+	"net/http"
+	"net/http/httptest"
+)
+
+type mw1 struct {
+	next http.Handler
+}
+
+func (m *mw1) ServeHTTP(rw http.ResponseWriter, rq *http.Request) {
+	m.next.ServeHTTP(rw, rq)
+}
+
+type mw0 struct{}
+
+func (m *mw0) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	fmt.Fprint(w, "Welcome to my website!")
+}
+
+func main() {
+	m0 := &mw0{}
+	m1 := &mw1{m0}
+
+	mux := http.NewServeMux()
+	mux.HandleFunc("/", m1.ServeHTTP)
+
+	server := httptest.NewServer(mux)
+	defer server.Close()
+
+	client(server.URL)
+}
+
+func client(uri string) {
+	resp, err := http.Get(uri)
+	if err != nil {
+		log.Fatal(err)
+	}
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		log.Fatal(err)
+	}
+	fmt.Println(string(body))
+}
+
+// Output:
+// Welcome to my website!

_test/cli5.go

@@ -0,0 +1,51 @@
+package main
+
+import (
+	"fmt"
+	"io/ioutil"
+	"log"
+	"net/http"
+	"net/http/httptest"
+)
+
+type mw1 struct {
+	next http.Handler
+}
+
+func (m *mw1) ServeHTTP(rw http.ResponseWriter, rq *http.Request) {
+	m.next.ServeHTTP(rw, rq)
+}
+
+type mw0 struct{}
+
+func (m *mw0) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	fmt.Fprint(w, "Welcome to my website!")
+}
+
+func main() {
+	m0 := &mw0{}
+	m1 := &mw1{next: m0}
+
+	mux := http.NewServeMux()
+	mux.HandleFunc("/", m1.ServeHTTP)
+
+	server := httptest.NewServer(mux)
+	defer server.Close()
+
+	client(server.URL)
+}
+
+func client(uri string) {
+	resp, err := http.Get(uri)
+	if err != nil {
+		log.Fatal(err)
+	}
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		log.Fatal(err)
+	}
+	fmt.Println(string(body))
+}
+
+// Output:
+// Welcome to my website!

_test/cli6.go

@@ -0,0 +1,52 @@
+package main
+
+import (
+	"fmt"
+	"io/ioutil"
+	"log"
+	"net/http"
+	"net/http/httptest"
+)
+
+type T struct {
+	http.ResponseWriter
+}
+
+type mw1 struct {
+	next http.Handler
+}
+
+func (m *mw1) ServeHTTP(rw http.ResponseWriter, rq *http.Request) {
+	t := &T{
+		ResponseWriter: rw,
+	}
+	x := t.Header()
+	fmt.Fprint(rw, "Welcome to my website!", x)
+}
+
+func main() {
+	m1 := &mw1{}
+
+	mux := http.NewServeMux()
+	mux.HandleFunc("/", m1.ServeHTTP)
+
+	server := httptest.NewServer(mux)
+	defer server.Close()
+
+	client(server.URL)
+}
+
+func client(uri string) {
+	resp, err := http.Get(uri)
+	if err != nil {
+		log.Fatal(err)
+	}
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		log.Fatal(err)
+	}
+	fmt.Println(string(body))
+}
+
+// Output:
+// Welcome to my website!map[]

_test/composite12.go

@@ -0,0 +1,19 @@
+package main
+
+type A struct {
+	C D
+}
+
+type D struct {
+	E string
+}
+
+func main() {
+	a := A{}
+	a.C = D{"bb"}
+
+	println(a.C.E)
+}
+
+// Output:
+// bb

_test/composite13.go

@@ -0,0 +1,19 @@
+package main
+
+type A struct {
+	C D
+}
+
+type D struct {
+	E string
+}
+
+func main() {
+	a := A{}
+	a.C = D{E: "bb"}
+
+	println(a.C.E)
+}
+
+// Output:
+// bb

_test/composite14.go

@@ -0,0 +1,15 @@
+package main
+
+import "fmt"
+
+type T struct {
+	b []byte
+}
+
+func main() {
+	t := T{nil}
+	fmt.Println(t)
+}
+
+// Output:
+// {[]}

_test/composite6.go

@@ -3,7 +3,7 @@ package main
 import (
 	"fmt"
 
-	"github.com/containous/yaegi/_test/ct1"
+	"github.com/traefik/yaegi/_test/ct1"
 )
 
 type T struct {

_test/composite8bis.go

@@ -0,0 +1,16 @@
+package main
+
+type T struct{ I int }
+
+func main() {
+	t := []*T{}
+	s := []int{1, 2}
+	for _, e := range s {
+		x := &T{I: e}
+		t = append(t, x)
+	}
+	println(t[0].I, t[1].I)
+}
+
+// Output:
+// 1 2

_test/const16.go

@@ -0,0 +1,12 @@
+package main
+
+import (
+	"fmt"
+)
+
+func main() {
+	fmt.Println(7 / 3)
+}
+
+// Output:
+// 2

_test/const17.go

@@ -0,0 +1,14 @@
+package main
+
+import "fmt"
+
+var t [7/3]int
+
+func main() {
+	t[0] = 3/2
+	t[1] = 5/2
+	fmt.Println(t)
+}
+
+// Output:
+// [1 2]

_test/const18.go

@@ -0,0 +1,11 @@
+package main
+
+import "time"
+
+func main() {
+	a := int64(time.Second)
+	println(a)
+}
+
+// Output:
+// 1000000000

_test/const19.go

@@ -0,0 +1,17 @@
+package main
+
+import (
+	"fmt"
+	"time"
+)
+
+func get10Hours() time.Duration {
+	return 10 * time.Hour
+}
+
+func main() {
+	fmt.Println(get10Hours().String())
+}
+
+// Output:
+// 10h0m0s

_test/const20.go

@@ -0,0 +1,12 @@
+package main
+
+import "fmt"
+
+const maxLen = int64(int(^uint(0) >> 1))
+
+func main() {
+	fmt.Println(maxLen)
+}
+
+// Output:
+// 9223372036854775807

_test/const21.go

@@ -0,0 +1,12 @@
+package main
+
+const a = 64
+
+var b uint = a * a / 2
+
+func main() {
+	println(b)
+}
+
+// Output:
+// 2048

_test/convert0.go

@@ -0,0 +1,21 @@
+package main
+
+type T struct {
+	v int
+}
+
+type comparator func(T, T) bool
+
+func sort(items []T, comp comparator) {
+	println("in sort")
+}
+
+func compT(t0, t1 T) bool { return t0.v < t1.v }
+
+func main() {
+	a := []T{}
+	sort(a, comparator(compT))
+}
+
+// Output:
+// in sort

_test/convert1.go

@@ -0,0 +1,17 @@
+package main
+
+import "strconv"
+
+type atoidef func(s string) (int, error)
+
+func main() {
+	stdatoi := atoidef(strconv.Atoi)
+	n, err := stdatoi("7")
+	if err != nil {
+		panic(err)
+	}
+	println(n)
+}
+
+// Output:
+// 7

_test/convert2.go

@@ -0,0 +1,19 @@
+package main
+
+import "bufio"
+
+func fakeSplitFunc(data []byte, atEOF bool) (advance int, token []byte, err error) {
+	return 7, nil, nil
+}
+
+func main() {
+	splitfunc := bufio.SplitFunc(fakeSplitFunc)
+	n, _, err := splitfunc(nil, true)
+	if err != nil {
+		panic(err)
+	}
+	println(n)
+}
+
+// Output:
+// 7

_test/eval0.go

@@ -2,13 +2,14 @@ package main
 
 import (
 	"log"
+	"os"
 
-	"github.com/containous/yaegi/interp"
+	"github.com/traefik/yaegi/interp"
 )
 
 func main() {
 	log.SetFlags(log.Lshortfile)
-	i := interp.New(interp.Options{})
+	i := interp.New(interp.Options{Stdout: os.Stdout})
 	if _, err := i.Eval(`func f() (int, int) { return 1, 2 }`); err != nil {
 		log.Fatal(err)
 	}

_test/foo/bar.go

@@ -1,6 +1,6 @@
 package foo
 
-import "github.com/containous/yaegi/_test/foo/boo"
+import "github.com/traefik/yaegi/_test/foo/boo"
 
 var Bar = "BARR"
 var Boo = boo.Boo

_test/foo/bir.go

@@ -1,5 +1,5 @@
 package foo
 
-import "github.com/containous/yaegi/_test/foo/boo"
+import "github.com/traefik/yaegi/_test/foo/boo"
 
 var Bir = boo.Boo + "22"

_test/for15.go

@@ -0,0 +1,16 @@
+package main
+
+func f() int { println("in f"); return 1 }
+
+func main() {
+	for i := f(); ; {
+		println("in loop")
+		if i > 0 {
+			break
+		}
+	}
+}
+
+// Output:
+// in f
+// in loop

_test/for16.go

@@ -0,0 +1,16 @@
+package main
+
+func main() {
+	max := 1
+	for ; ; max-- {
+		if max == 0 {
+			break
+		}
+		println("in for")
+	}
+	println("bye")
+}
+
+// Output:
+// in for
+// bye

_test/fun23.go

@@ -0,0 +1,10 @@
+package main
+
+func f(x int) { return x }
+
+func main() {
+	print("hello")
+}
+
+// Error:
+// 3:17: too many arguments to return

_test/fun24.go

@@ -0,0 +1,10 @@
+package main
+
+func f(x int) (int, int) { return x, "foo" }
+
+func main() {
+	print("hello")
+}
+
+// Error:
+// cannot use "foo" (type stringT) as type intT in return argument

_test/fun25.go

@@ -0,0 +1,10 @@
+package main
+
+func f(x string) (a int, b int) { return x, 5 }
+
+func main() {
+	print("hello")
+}
+
+// Error:
+// cannot use x (type stringT) as type intT in return argument

_test/fun26.go

@@ -0,0 +1,17 @@
+package main
+
+type F func() (int, error)
+
+func f1() (int, error) { return 3, nil }
+
+func f2(a string, f F) {
+	c, _ := f()
+	println(a, c)
+}
+
+func main() {
+	f2("hello", F(f1))
+}
+
+// Output:
+// hello 3

_test/goto1.go

@@ -0,0 +1,12 @@
+package main
+
+func main() {
+	if true {
+		goto here
+	}
+here:
+	println("ok")
+}
+
+// Output:
+// ok

_test/import3.go

@@ -1,6 +1,6 @@
 package main
 
-import "github.com/containous/yaegi/_test/foo"
+import "github.com/traefik/yaegi/_test/foo"
 
 func main() { println(foo.Bar, foo.Boo) }
 

_test/import4.go

@@ -1,6 +1,6 @@
 package main
 
-import "github.com/containous/yaegi/_test/p1"
+import "github.com/traefik/yaegi/_test/p1"
 
 func main() { println("num:", p1.Uint32()) }
 

_test/import5.go

@@ -1,6 +1,6 @@
 package main
 
-import boo "github.com/containous/yaegi/_test/foo"
+import boo "github.com/traefik/yaegi/_test/foo"
 
 func main() { println(boo.Bar, boo.Boo, boo.Bir) }
 

_test/import6.go

@@ -1,6 +1,6 @@
 package main
 
-import "github.com/containous/yaegi/_test/c1"
+import "github.com/traefik/yaegi/_test/c1"
 
 func main() {
 	println(c1.C1)
@@ -8,4 +8,4 @@ func main() {
 
 // Error:
 // import cycle not allowed
-//	imports github.com/containous/yaegi/_test/c1
+//	imports github.com/traefik/yaegi/_test/c1

_test/import7.go

@@ -1,6 +1,6 @@
 package main
 
-import "github.com/containous/yaegi/_test/foo-bar"
+import bar "github.com/traefik/yaegi/_test/foo-bar"
 
 func main() {
 	println(bar.Name)

_test/import8.go

@@ -1,6 +1,6 @@
 package main
 
-import "github.com/containous/yaegi/_test/b1/foo"
+import "github.com/traefik/yaegi/_test/b1/foo"
 
 func main() {
 	println(foo.Desc)

_test/import9.go

@@ -1,6 +1,6 @@
 package main
 
-import "github.com/containous/yaegi/_test/baz-bat"
+import "github.com/traefik/yaegi/_test/baz-bat"
 
 func main() {
 	println(baz.Name)

_test/inception.go

@@ -3,14 +3,14 @@ package main
 import (
 	"log"
 
-	"github.com/containous/yaegi/interp"
+	"github.com/traefik/yaegi/interp"
 )
 
 func main() {
 	log.SetFlags(log.Lshortfile)
 	i := interp.New(interp.Options{})
 	i.Use(interp.Symbols)
-	if _, err := i.Eval(`import "github.com/containous/yaegi/interp"`); err != nil {
+	if _, err := i.Eval(`import "github.com/traefik/yaegi/interp"`); err != nil {
 		log.Fatal(err)
 	}
 	if _, err := i.Eval(`i := interp.New(interp.Options{})`); err != nil {
@@ -20,6 +20,3 @@ func main() {
 		log.Fatal(err)
 	}
 }
-
-// Output:
-// 42

_test/interface46.go

@@ -0,0 +1,35 @@
+package main
+
+import "fmt"
+
+type I interface {
+	Foo() string
+}
+
+type Printer struct {
+	i I
+}
+
+func New(i I) *Printer {
+	return &Printer{
+		i: i,
+	}
+}
+
+func (p *Printer) Print() {
+	fmt.Println(p.i.Foo())
+}
+
+type T struct{}
+
+func (t *T) Foo() string {
+	return "test"
+}
+
+func main() {
+	g := New(&T{})
+	g.Print()
+}
+
+// Output:
+// test

_test/interp.gi

@@ -1,7 +1,7 @@
 package main
 
 import (
-	"github.com/containous/yaegi/interp"
+	"github.com/traefik/yaegi/interp"
 )
 
 func main() {

_test/interp2.gi

@@ -1,13 +1,13 @@
 package main
 
 import (
-	"github.com/containous/yaegi/interp"
+	"github.com/traefik/yaegi/interp"
 )
 
 func main() {
 	i := interp.New(interp.Opt{})
 	i.Use(interp.ExportValue, interp.ExportType)
-	i.Eval(`import "github.com/containous/yaegi/interp"`)
+	i.Eval(`import "github.com/traefik/yaegi/interp"`)
 	i.Eval(`i := interp.New(interp.Opt{})`)
 	i.Eval(`i.Eval("println(42)")`)
 }

_test/ipp_as_key.go

@@ -0,0 +1,16 @@
+package main
+
+import (
+	"guthib.com/toto" // pkg name is actually titi
+	"guthib.com/tata" // pkg name is actually tutu
+)
+
+func main() {
+	println("Hello", titi.Quux())
+	println("Hello", tutu.Quux())
+}
+
+// GOPATH:testdata/redeclaration-global7
+// Output:
+// Hello bar
+// Hello baz

_test/issue-770.go

@@ -0,0 +1,25 @@
+package main
+
+import "reflect"
+
+type I interface {
+	Foo() int
+}
+
+type T struct {
+	Name string
+}
+
+func (t T) Foo() int { return 0 }
+
+func f(v reflect.Value) int {
+	i := v.Interface().(I)
+	return i.Foo()
+}
+
+func main() {
+	println("hello")
+}
+
+// Output:
+// hello

_test/issue-782.go

@@ -0,0 +1,14 @@
+package main
+
+import "fmt"
+
+func main() {
+	a := []int{1, 2, 3, 4, 5, 6, 7, 8, 9}
+	from := uint32(2)
+	to := uint32(4)
+	b := a[from:to]
+	fmt.Print(b)
+}
+
+// Output:
+// [3 4]

_test/issue-784.go

@@ -0,0 +1,39 @@
+package main
+
+import "fmt"
+
+// Filter is a filter interface
+type Filter interface {
+	Bounds(srcBounds string) (dstBounds string)
+}
+
+// GIFT type
+type GIFT struct {
+	Filters []Filter
+}
+
+// New creates a new filter list and initializes it with the given slice of filters.
+func New(filters ...Filter) *GIFT {
+	return &GIFT{
+		Filters: filters,
+	}
+}
+
+// Bounds calculates the appropriate bounds for the result image after applying all the added filters.
+func (g *GIFT) Bounds(srcBounds string) (dstBounds string) {
+	dstBounds = srcBounds
+	for _, f := range g.Filters {
+		dstBounds = f.Bounds(dstBounds)
+	}
+	return dstBounds
+}
+
+func main() {
+	var filters []Filter
+	bounds := "foo"
+	g := New(filters...)
+	fmt.Println(g.Bounds(bounds))
+}
+
+// Output:
+// foo

_test/issue-880.go

@@ -0,0 +1,23 @@
+package main
+
+import (
+	"bufio"
+	"bytes"
+)
+
+func main() {
+	var buf1 = make([]byte, 1024)
+	var buf2 []byte
+	buf1 = []byte("Hallo\nTest\nLine3")
+
+	s := bufio.NewScanner(bytes.NewReader(buf1))
+	for s.Scan() {
+		buf2 = append(buf2, append(s.Bytes(), []byte("\n")...)...)
+	}
+	print(string(buf2))
+}
+
+// Output:
+// Hallo
+// Test
+// Line3

_test/m1/main.go

@@ -0,0 +1,14 @@
+package main
+
+import (
+	"fmt"
+	"testing"
+)
+
+func main() {
+	fmt.Println("vim-go")
+}
+
+func TestWeird(t *testing.T) {
+	fmt.Println("in TestWeird")
+}

_test/m1/main_test.go

@@ -0,0 +1,17 @@
+package main
+
+import (
+	"fmt"
+	"math/rand"
+	"testing"
+)
+
+func TestMain(t *testing.T) {
+	fmt.Println("in test")
+}
+
+func BenchmarkMain(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		rand.Int()
+	}
+}

_test/m2/m2_test.go

@@ -0,0 +1,7 @@
+package m2
+
+import "testing"
+
+func TestM2(t *testing.T) {
+	t.Errorf("got %s, want %s", "AAA", "BBB")
+}

_test/math3.go

@@ -0,0 +1,32 @@
+package main
+
+import (
+	"crypto/md5"
+	"fmt"
+)
+
+func md5Crypt(password, salt, magic []byte) []byte {
+	d := md5.New()
+	d.Write(password)
+	d.Write(magic)
+	d.Write(salt)
+
+	d2 := md5.New()
+	d2.Write(password)
+	d2.Write(salt)
+
+	for i, mixin := 0, d2.Sum(nil); i < len(password); i++ {
+		d.Write([]byte{mixin[i%16]})
+	}
+
+	return d.Sum(nil)
+}
+
+func main() {
+	b := md5Crypt([]byte("1"), []byte("2"), []byte("3"))
+
+	fmt.Println(b)
+}
+
+// Output:
+// [187 141 73 89 101 229 33 106 226 63 117 234 117 149 230 21]

_test/method35.go

@@ -0,0 +1,14 @@
+package main
+
+import "strconv"
+
+func main() {
+	var err error
+	_, err = strconv.Atoi("erwer")
+	if _, ok := err.(*strconv.NumError); ok {
+		println("here")
+	}
+}
+
+// Output:
+// here

_test/nil3.go

@@ -0,0 +1,28 @@
+package main
+
+type I interface {
+	Hello()
+}
+
+type T struct {
+	h I
+}
+
+func (t *T) Hello() { println("Hello") }
+
+func main() {
+	t := &T{}
+	println(t.h != nil)
+	println(t.h == nil)
+	t.h = t
+	println(t.h != nil)
+	println(t.h == nil)
+	t.h.Hello()
+}
+
+// Output:
+// false
+// true
+// true
+// false
+// Hello

_test/op1.go

@@ -7,4 +7,4 @@ func main() {
 }
 
 // Error:
-// 5:2: illegal operand types for '+=' operator
+// 5:2: invalid operation: mismatched types int and float64

_test/pkgname0.go

@@ -0,0 +1,16 @@
+package main
+
+import (
+	"guthib.com/bar" // pkg name is actually quux
+	baz "guthib.com/baz" // pkg name is also quux, force it to baz.
+)
+
+func main() {
+	println("Hello", quux.Quux())
+	println("Hello", baz.Quux())
+}
+
+// GOPATH:testdata/redeclaration-global7
+// Output:
+// Hello bar
+// Hello baz

_test/pkgname1.go

@@ -0,0 +1,13 @@
+package main
+
+import (
+	"guthib.com/bar" // pkg name is actually quux
+)
+
+func main() {
+	println("Hello", bar.Quux()) // bar should not be a known symbol.
+}
+
+// GOPATH:testdata/redeclaration-global7
+// Error:
+// ../_test/pkgname1.go:8:19: undefined: bar

_test/pkgname2.go

@@ -0,0 +1,13 @@
+package main
+
+import (
+	"guthib.com/toto" // pkg name is actually titi
+)
+
+func main() {
+	println("Hello", titi.Quux())
+}
+
+// GOPATH:testdata/redeclaration-global7
+// Output:
+// Hello bar

_test/redeclaration-global5.go

@@ -12,4 +12,5 @@ func main() {
 }
 
 // Error:
-// ../_test/redeclaration-global5.go:5:1: time redeclared in this block
+// ../_test/redeclaration-global5.go:5:6: time redeclared in this block
+//	previous declaration at ../_test/redeclaration-global5.go:3:5

_test/redeclaration-global7.go

@@ -0,0 +1,14 @@
+package main
+
+import (
+	"guthib.com/bar" // pkg name is actually quux
+	"guthib.com/baz" // pkg name is also quux
+)
+
+func main() {
+	println("Hello", quux.Quux())
+}
+
+// GOPATH:testdata/redeclaration-global7
+// Error:
+// ../_test/redeclaration-global7.go:5:2: quux/redeclaration-global7.go redeclared as imported package name

_test/rune1.go

@@ -0,0 +1,12 @@
+package main
+
+import "fmt"
+
+func main() {
+	t := make([]byte, 2)
+	t[0] = '$'
+	fmt.Println(t)
+}
+
+// Output:
+// [36 0]

_test/select1.go

@@ -1,18 +1,20 @@
 package main
 
-import "time"
-import "fmt"
+import (
+	"fmt"
+	"time"
+)
 
 func main() {
 	c1 := make(chan string)
 	c2 := make(chan string)
 
 	go func() {
-		time.Sleep(1e9)
+		time.Sleep(1e7)
 		c1 <- "one"
 	}()
 	go func() {
-		time.Sleep(2e9)
+		time.Sleep(2e7)
 		c2 <- "two"
 	}()
 

_test/select14.go

@@ -0,0 +1,44 @@
+package main
+
+import (
+	"fmt"
+	"time"
+)
+
+const (
+	period    = 100 * time.Millisecond
+	precision = 5 * time.Millisecond
+)
+
+func main() {
+	counter := 0
+	p := time.Now()
+	ticker := time.NewTicker(period)
+	ch := make(chan int)
+
+	go func() {
+		for i := 0; i < 3; i++ {
+			select {
+			case t := <-ticker.C:
+				counter = counter + 1
+				ch <- counter
+				if d := t.Sub(p) - period; d < -precision || d > precision {
+					fmt.Println("wrong delay", d)
+				}
+				p = t
+			}
+		}
+		ch <- 0
+	}()
+	for c := range ch {
+		if c == 0 {
+			break
+		}
+		println(c)
+	}
+}
+
+// Output:
+// 1
+// 2
+// 3

_test/select15.go

@@ -0,0 +1,23 @@
+package main
+
+type T struct {
+	c1 chan string
+	c2 chan string
+}
+
+func main() {
+	t := &T{}
+	t.c2 = make(chan string)
+
+	go func(c chan string) { c <- "done" }(t.c2)
+
+	select {
+	case msg := <-t.c1:
+		println("received from c1:", msg)
+	case <-t.c2:
+	}
+	println("Bye")
+}
+
+// Output:
+// Bye

_test/slice.go

@@ -0,0 +1,11 @@
+package main
+
+import "fmt"
+
+func main() {
+    a := [2][2]int{{0, 1}, {2, 3}}
+    fmt.Println(a[0][0:])
+}
+
+// Output:
+// [0 1]

_test/struct55.go

@@ -0,0 +1,22 @@
+package main
+
+import (
+	"log"
+	"os"
+)
+
+type Logger struct {
+	m []*log.Logger
+}
+
+func (l *Logger) Infof(format string, args ...interface{}) {
+	l.m[0].Printf(format, args...)
+}
+
+func main() {
+	l := &Logger{m: []*log.Logger{log.New(os.Stdout, "", log.Lmsgprefix)}}
+	l.Infof("test %s", "test")
+}
+
+// Output:
+// test test

_test/struct56.go

@@ -0,0 +1,23 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+)
+
+type A struct {
+	IA InnerA
+}
+
+type InnerA struct {
+	Timestamp int64
+}
+
+func main() {
+	a := &A{}
+	b, _ := json.Marshal(a)
+	fmt.Println(string(b))
+}
+
+// Output:
+// {"IA":{"Timestamp":0}}

_test/struct57.go

@@ -0,0 +1,23 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+)
+
+type A struct {
+	InnerA
+}
+
+type InnerA struct {
+	Timestamp int64
+}
+
+func main() {
+	a := &A{}
+	b, _ := json.Marshal(a)
+	fmt.Println(string(b))
+}
+
+// Output:
+// {"Timestamp":0}

_test/struct58.go

@@ -0,0 +1,24 @@
+package main
+
+import (
+	"fmt"
+	"reflect"
+)
+
+type A struct {
+	Test string `tag:"test"`
+}
+
+func main() {
+	a := A{}
+	t := reflect.TypeOf(a)
+	f, ok := t.FieldByName("Test")
+	if !ok {
+		return
+	}
+
+	fmt.Println(f.Tag.Get("tag"))
+}
+
+// Output:
+// test

_test/tag0.go

@@ -3,7 +3,7 @@
 
 package main
 
-import _ "github.com/containous/yaegi/_test/ct"
+import _ "github.com/traefik/yaegi/_test/ct"
 
 func main() {
 	println("bye")

_test/testdata/redeclaration-global7/src/guthib.com/bar/quux.go

@@ -0,0 +1,5 @@
+package quux
+
+func Quux() string {
+	return "bar"
+}

_test/testdata/redeclaration-global7/src/guthib.com/baz/quux.go

@@ -0,0 +1,5 @@
+package quux
+
+func Quux() string {
+	return "baz"
+}

_test/testdata/redeclaration-global7/src/guthib.com/tata/tutu.go

@@ -0,0 +1,7 @@
+package tutu
+
+import "guthib.com/baz"
+
+func Quux() string {
+	return quux.Quux()
+}

_test/testdata/redeclaration-global7/src/guthib.com/toto/titi.go

@@ -0,0 +1,7 @@
+package titi
+
+import "guthib.com/bar"
+
+func Quux() string {
+	return quux.Quux()
+}

_test/time14.go

@@ -0,0 +1,20 @@
+package main
+
+import (
+	"fmt"
+	"time"
+)
+
+var t time.Time
+
+func f() time.Time {
+	time := t
+	return time
+}
+
+func main() {
+	fmt.Println(f())
+}
+
+// Output:
+// 0001-01-01 00:00:00 +0000 UTC

_test/var14.go

@@ -1,6 +1,6 @@
 package main
 
-import "github.com/containous/yaegi/_test/vars"
+import "github.com/traefik/yaegi/_test/vars"
 
 func main() {
 	println(vars.A)

_test/variadic10.go

@@ -0,0 +1,16 @@
+package main
+
+import (
+	"log"
+	"os"
+)
+
+func main() {
+	logger := log.New(os.Stdout, "test ", log.Lmsgprefix)
+	logger.Printf("args: %v %v", 1, "truc")
+	logger.Printf("args: %v %v %v", 1, "truc", 2)
+}
+
+// Output:
+// test args: 1 truc
+// test args: 1 truc 2

cmd/goexports/goexports.go

@@ -1,402 +0,0 @@
-//go:generate go build
-
-/*
-Goexports generates wrappers of package exported symbols.
-
-Output files are written in the current directory, and prefixed with the go version.
-
-Usage:
-
-    goexports package...
-
-Example:
-
-    goexports github.com/containous/yaegi/interp
-
-The same goexport program is used for all target operating systems and architectures.
-The GOOS and GOARCH environment variables set the desired target.
-*/
-package main
-
-import (
-	"bufio"
-	"bytes"
-	"flag"
-	"fmt"
-	"go/constant"
-	"go/format"
-	"go/importer"
-	"go/token"
-	"go/types"
-	"io/ioutil"
-	"log"
-	"math/big"
-	"os"
-	"path"
-	"runtime"
-	"strconv"
-	"strings"
-	"text/template"
-)
-
-const model = `// Code generated by 'goexports {{.PkgName}}'. DO NOT EDIT.
-
-{{.License}}
-
-{{if .BuildTags}}// +build {{.BuildTags}}{{end}}
-
-package {{.Dest}}
-
-import (
-{{- range $key, $value := .Imports }}
-	{{- if $value}}
-	"{{$key}}"
-	{{- end}}
-{{- end}}
-	"{{.PkgName}}"
-	"reflect"
-)
-
-func init() {
-	Symbols["{{.PkgName}}"] = map[string]reflect.Value{
-		{{- if .Val}}
-		// function, constant and variable definitions
-		{{range $key, $value := .Val -}}
-			{{- if $value.Addr -}}
-				"{{$key}}": reflect.ValueOf(&{{$value.Name}}).Elem(),
-			{{else -}}
-				"{{$key}}": reflect.ValueOf({{$value.Name}}),
-			{{end -}}
-		{{end}}
-
-		{{- end}}
-		{{- if .Typ}}
-		// type definitions
-		{{range $key, $value := .Typ -}}
-			"{{$key}}": reflect.ValueOf((*{{$value}})(nil)),
-		{{end}}
-
-		{{- end}}
-		{{- if .Wrap}}
-		// interface wrapper definitions
-		{{range $key, $value := .Wrap -}}
-			"_{{$key}}": reflect.ValueOf((*{{$value.Name}})(nil)),
-		{{end}}
-		{{- end}}
-	}
-}
-{{range $key, $value := .Wrap -}}
-	// {{$value.Name}} is an interface wrapper for {{$key}} type
-	type {{$value.Name}} struct {
-		{{range $m := $value.Method -}}
-		W{{$m.Name}} func{{$m.Param}} {{$m.Result}}
-		{{end}}
-	}
-	{{range $m := $value.Method -}}
-		func (W {{$value.Name}}) {{$m.Name}}{{$m.Param}} {{$m.Result}} { {{$m.Ret}} W.W{{$m.Name}}{{$m.Arg}} }
-	{{end}}
-{{end}}
-`
-
-// Val store the value name and addressable status of symbols.
-type Val struct {
-	Name string // "package.name"
-	Addr bool   // true if symbol is a Var
-}
-
-// Method store information for generating interface wrapper method.
-type Method struct {
-	Name, Param, Result, Arg, Ret string
-}
-
-// Wrap store information for generating interface wrapper.
-type Wrap struct {
-	Name   string
-	Method []Method
-}
-
-// restricted map defines symbols for which a special implementation is provided.
-var restricted = map[string]bool{
-	"osExit":        true,
-	"osFindProcess": true,
-	"logFatal":      true,
-	"logFatalf":     true,
-	"logFatalln":    true,
-	"logLogger":     true,
-	"logNew":        true,
-}
-
-func genContent(dest, pkgName, license string, skip map[string]bool) ([]byte, error) {
-	p, err := importer.ForCompiler(token.NewFileSet(), "source", nil).Import(pkgName)
-	if err != nil {
-		return nil, err
-	}
-
-	prefix := "_" + pkgName + "_"
-	prefix = strings.NewReplacer("/", "_", "-", "_", ".", "_").Replace(prefix)
-
-	typ := map[string]string{}
-	val := map[string]Val{}
-	wrap := map[string]Wrap{}
-	imports := map[string]bool{}
-	sc := p.Scope()
-
-	for _, pkg := range p.Imports() {
-		imports[pkg.Path()] = false
-	}
-	qualify := func(pkg *types.Package) string {
-		if pkg.Path() != pkgName {
-			imports[pkg.Path()] = true
-		}
-		return pkg.Name()
-	}
-
-	for _, name := range sc.Names() {
-		o := sc.Lookup(name)
-		if !o.Exported() {
-			continue
-		}
-
-		pname := path.Base(pkgName) + "." + name
-		if skip[pname] {
-			continue
-		}
-		if rname := path.Base(pkgName) + name; restricted[rname] {
-			// Restricted symbol, locally provided by stdlib wrapper.
-			pname = rname
-		}
-
-		switch o := o.(type) {
-		case *types.Const:
-			if b, ok := o.Type().(*types.Basic); ok && (b.Info()&types.IsUntyped) != 0 {
-				// convert untyped constant to right type to avoid overflow
-				val[name] = Val{fixConst(pname, o.Val(), imports), false}
-			} else {
-				val[name] = Val{pname, false}
-			}
-		case *types.Func:
-			val[name] = Val{pname, false}
-		case *types.Var:
-			val[name] = Val{pname, true}
-		case *types.TypeName:
-			typ[name] = pname
-			if t, ok := o.Type().Underlying().(*types.Interface); ok {
-				var methods []Method
-				for i := 0; i < t.NumMethods(); i++ {
-					f := t.Method(i)
-					if !f.Exported() {
-						continue
-					}
-
-					sign := f.Type().(*types.Signature)
-					args := make([]string, sign.Params().Len())
-					params := make([]string, len(args))
-					for j := range args {
-						v := sign.Params().At(j)
-						if args[j] = v.Name(); args[j] == "" {
-							args[j] = fmt.Sprintf("a%d", j)
-						}
-						params[j] = args[j] + " " + types.TypeString(v.Type(), qualify)
-					}
-					arg := "(" + strings.Join(args, ", ") + ")"
-					param := "(" + strings.Join(params, ", ") + ")"
-
-					results := make([]string, sign.Results().Len())
-					for j := range results {
-						v := sign.Results().At(j)
-						results[j] = v.Name() + " " + types.TypeString(v.Type(), qualify)
-					}
-					result := "(" + strings.Join(results, ", ") + ")"
-
-					ret := ""
-					if sign.Results().Len() > 0 {
-						ret = "return"
-					}
-
-					methods = append(methods, Method{f.Name(), param, result, arg, ret})
-				}
-				wrap[name] = Wrap{prefix + name, methods}
-			}
-		}
-	}
-
-	var buildTags string
-	if runtime.Version() != "devel" {
-		parts := strings.Split(runtime.Version(), ".")
-
-		minorRaw := getMinor(parts[1])
-
-		currentGoVersion := parts[0] + "." + minorRaw
-
-		minor, errParse := strconv.Atoi(minorRaw)
-		if errParse != nil {
-			return nil, fmt.Errorf("failed to parse version: %v", errParse)
-		}
-
-		nextGoVersion := parts[0] + "." + strconv.Itoa(minor+1)
-
-		buildTags = currentGoVersion + ",!" + nextGoVersion
-	}
-
-	base := template.New("goexports")
-	parse, err := base.Parse(model)
-	if err != nil {
-		return nil, fmt.Errorf("template parsing error: %v", err)
-	}
-
-	if pkgName == "log/syslog" {
-		buildTags += ",!windows,!nacl,!plan9"
-	}
-
-	b := new(bytes.Buffer)
-	data := map[string]interface{}{
-		"Dest":      dest,
-		"Imports":   imports,
-		"PkgName":   pkgName,
-		"Val":       val,
-		"Typ":       typ,
-		"Wrap":      wrap,
-		"BuildTags": buildTags,
-		"License":   license,
-	}
-	err = parse.Execute(b, data)
-	if err != nil {
-		return nil, fmt.Errorf("template error: %v", err)
-	}
-
-	// gofmt
-	source, err := format.Source(b.Bytes())
-	if err != nil {
-		return nil, fmt.Errorf("failed to format source: %v: %s", err, b.Bytes())
-	}
-	return source, nil
-}
-
-// fixConst checks untyped constant value, converting it if necessary to avoid overflow.
-func fixConst(name string, val constant.Value, imports map[string]bool) string {
-	var (
-		tok string
-		str string
-	)
-	switch val.Kind() {
-	case constant.Int:
-		tok = "INT"
-		str = val.ExactString()
-	case constant.Float:
-		v := constant.Val(val) // v is *big.Rat or *big.Float
-		f, ok := v.(*big.Float)
-		if !ok {
-			f = new(big.Float).SetRat(v.(*big.Rat))
-		}
-
-		tok = "FLOAT"
-		str = f.Text('g', int(f.Prec()))
-	case constant.Complex:
-		// TODO: not sure how to parse this case
-		fallthrough
-	default:
-		return name
-	}
-
-	imports["go/constant"] = true
-	imports["go/token"] = true
-
-	return fmt.Sprintf("constant.MakeFromLiteral(\"%s\", token.%s, 0)", str, tok)
-}
-
-// genLicense generates the correct LICENSE header text from the provided
-// path to a LICENSE file.
-func genLicense(fname string) (string, error) {
-	if fname == "" {
-		return "", nil
-	}
-
-	f, err := os.Open(fname)
-	if err != nil {
-		return "", fmt.Errorf("could not open LICENSE file: %v", err)
-	}
-	defer func() { _ = f.Close() }()
-
-	license := new(strings.Builder)
-	sc := bufio.NewScanner(f)
-	for sc.Scan() {
-		txt := sc.Text()
-		if txt != "" {
-			txt = " " + txt
-		}
-		license.WriteString("//" + txt + "\n")
-	}
-	if sc.Err() != nil {
-		return "", fmt.Errorf("could not scan LICENSE file: %v", err)
-	}
-
-	return license.String(), nil
-}
-
-func main() {
-	licenseFlag := flag.String("license", "", "path to a LICENSE file")
-
-	flag.Parse()
-
-	if flag.NArg() == 0 {
-		flag.Usage()
-		log.Fatalf("missing package path")
-	}
-
-	license, err := genLicense(*licenseFlag)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	dir, err := os.Getwd()
-	if err != nil {
-		log.Fatal(err)
-	}
-	dest := path.Base(dir)
-
-	for _, pkg := range flag.Args() {
-		var oFile string
-		skip := map[string]bool{}
-		if pkg == "syscall" {
-			goos, arch := os.Getenv("GOOS"), os.Getenv("GOARCH")
-			oFile = strings.Replace(pkg, "/", "_", -1) + "_" + goos + "_" + arch + ".go"
-			if goos == "solaris" {
-				skip["syscall.RawSyscall6"] = true
-				skip["syscall.Syscall6"] = true
-			}
-		} else {
-			oFile = strings.Replace(pkg, "/", "_", -1) + ".go"
-		}
-
-		content, err := genContent(dest, pkg, license, skip)
-		if err != nil {
-			log.Println(err)
-			continue
-		}
-
-		prefix := runtime.Version()
-		if runtime.Version() != "devel" {
-			parts := strings.Split(runtime.Version(), ".")
-
-			prefix = parts[0] + "_" + getMinor(parts[1])
-		}
-
-		err = ioutil.WriteFile(prefix+"_"+oFile, content, 0666)
-		if err != nil {
-			log.Fatal(err)
-		}
-	}
-}
-
-func getMinor(part string) string {
-	minor := part
-	index := strings.Index(minor, "beta")
-	if index < 0 {
-		index = strings.Index(minor, "rc")
-	}
-	if index > 0 {
-		minor = minor[:index]
-	}
-
-	return minor
-}

cmd/yaegi/extract.go

@@ -0,0 +1,123 @@
+package main
+
+import (
+	"bufio"
+	"bytes"
+	"flag"
+	"fmt"
+	"io"
+	"os"
+	"path"
+	"strings"
+
+	"github.com/traefik/yaegi/extract"
+)
+
+func extractCmd(arg []string) error {
+	var licensePath string
+	var name string
+	var exclude string
+	var include string
+
+	eflag := flag.NewFlagSet("run", flag.ContinueOnError)
+	eflag.StringVar(&licensePath, "license", "", "path to a LICENSE file")
+	eflag.StringVar(&name, "name", "", "the namespace for the extracted symbols")
+	eflag.StringVar(&exclude, "exclude", "", "comma separated list of regexp matching symbols to exclude")
+	eflag.StringVar(&include, "include", "", "comma separated list of regexp matching symbols to include")
+	eflag.Usage = func() {
+		fmt.Println("Usage: yaegi extract [options] packages...")
+		fmt.Println("Options:")
+		eflag.PrintDefaults()
+	}
+
+	if err := eflag.Parse(arg); err != nil {
+		return err
+	}
+
+	args := eflag.Args()
+	if len(args) == 0 {
+		return fmt.Errorf("missing package")
+	}
+
+	license, err := genLicense(licensePath)
+	if err != nil {
+		return err
+	}
+
+	wd, err := os.Getwd()
+	if err != nil {
+		return err
+	}
+
+	if name == "" {
+		name = path.Base(wd)
+	}
+	ext := extract.Extractor{
+		Dest:    name,
+		License: license,
+	}
+
+	if exclude != "" {
+		ext.Exclude = strings.Split(exclude, ",")
+	}
+	if include != "" {
+		ext.Include = strings.Split(include, ",")
+	}
+
+	r := strings.NewReplacer("/", "-", ".", "_")
+
+	for _, pkgIdent := range args {
+		var buf bytes.Buffer
+		importPath, err := ext.Extract(pkgIdent, name, &buf)
+		if err != nil {
+			fmt.Fprintln(os.Stderr, err)
+			continue
+		}
+
+		oFile := r.Replace(importPath) + ".go"
+		f, err := os.Create(oFile)
+		if err != nil {
+			return err
+		}
+
+		if _, err := io.Copy(f, &buf); err != nil {
+			_ = f.Close()
+			return err
+		}
+
+		if err := f.Close(); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// genLicense generates the correct LICENSE header text from the provided
+// path to a LICENSE file.
+func genLicense(fname string) (string, error) {
+	if fname == "" {
+		return "", nil
+	}
+
+	f, err := os.Open(fname)
+	if err != nil {
+		return "", fmt.Errorf("could not open LICENSE file: %v", err)
+	}
+	defer func() { _ = f.Close() }()
+
+	license := new(strings.Builder)
+	sc := bufio.NewScanner(f)
+	for sc.Scan() {
+		txt := sc.Text()
+		if txt != "" {
+			txt = " " + txt
+		}
+		license.WriteString("//" + txt + "\n")
+	}
+	if sc.Err() != nil {
+		return "", fmt.Errorf("could not scan LICENSE file: %v", err)
+	}
+
+	return license.String(), nil
+}

cmd/yaegi/help.go

@@ -0,0 +1,47 @@
+package main
+
+import "fmt"
+
+const usage = `Yaegi is a Go interpreter.
+
+Usage:
+
+    yaegi [command] [arguments]
+
+The commands are:
+
+    extract     generate a wrapper file from a source package
+    help        print usage information
+    run         execute a Go program from source
+    test        execute test functions in a Go package
+    version     print version
+
+Use "yaegi help <command>" for more information about a command.
+
+If no command is given or if the first argument is not a command, then
+the run command is assumed.
+`
+
+func help(arg []string) error {
+	var cmd string
+	if len(arg) > 0 {
+		cmd = arg[0]
+	}
+
+	switch cmd {
+	case Extract:
+		return extractCmd([]string{"-h"})
+	case Help, "", "-h", "--help":
+		fmt.Print(usage)
+		return nil
+	case Run:
+		return run([]string{"-h"})
+	case Test:
+		return test([]string{"-h"})
+	case Version:
+		fmt.Println("Usage: yaegi version")
+		return nil
+	default:
+		return fmt.Errorf("help: invalid yaegi command: %v", cmd)
+	}
+}

cmd/yaegi/run.go

@@ -0,0 +1,135 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"go/build"
+	"io/ioutil"
+	"os"
+	"strconv"
+	"strings"
+
+	"github.com/traefik/yaegi/interp"
+	"github.com/traefik/yaegi/stdlib"
+	"github.com/traefik/yaegi/stdlib/syscall"
+	"github.com/traefik/yaegi/stdlib/unrestricted"
+	"github.com/traefik/yaegi/stdlib/unsafe"
+)
+
+func run(arg []string) error {
+	var interactive bool
+	var tags string
+	var cmd string
+	var err error
+
+	// The following flags are initialized from environment.
+	useSyscall, _ := strconv.ParseBool(os.Getenv("YAEGI_SYSCALL"))
+	useUnrestricted, _ := strconv.ParseBool(os.Getenv("YAEGI_UNRESTRICTED"))
+	useUnsafe, _ := strconv.ParseBool(os.Getenv("YAEGI_UNSAFE"))
+
+	rflag := flag.NewFlagSet("run", flag.ContinueOnError)
+	rflag.BoolVar(&interactive, "i", false, "start an interactive REPL")
+	rflag.BoolVar(&useSyscall, "syscall", useSyscall, "include syscall symbols")
+	rflag.BoolVar(&useUnrestricted, "unrestricted", useUnrestricted, "include unrestricted symbols")
+	rflag.StringVar(&tags, "tags", "", "set a list of build tags")
+	rflag.BoolVar(&useUnsafe, "unsafe", useUnsafe, "include unsafe symbols")
+	rflag.StringVar(&cmd, "e", "", "set the command to be executed (instead of script or/and shell)")
+	rflag.Usage = func() {
+		fmt.Println("Usage: yaegi run [options] [path] [args]")
+		fmt.Println("Options:")
+		rflag.PrintDefaults()
+	}
+	if err = rflag.Parse(arg); err != nil {
+		return err
+	}
+	args := rflag.Args()
+
+	i := interp.New(interp.Options{GoPath: build.Default.GOPATH, BuildTags: strings.Split(tags, ",")})
+	i.Use(stdlib.Symbols)
+	i.Use(interp.Symbols)
+	if useSyscall {
+		i.Use(syscall.Symbols)
+		// Using a environment var allows a nested interpreter to import the syscall package.
+		if err := os.Setenv("YAEGI_SYSCALL", "1"); err != nil {
+			return err
+		}
+	}
+	if useUnsafe {
+		i.Use(unsafe.Symbols)
+		if err := os.Setenv("YAEGI_UNSAFE", "1"); err != nil {
+			return err
+		}
+	}
+	if useUnrestricted {
+		// Use of unrestricted symbols should always follow stdlib and syscall symbols, to update them.
+		i.Use(unrestricted.Symbols)
+		if err := os.Setenv("YAEGI_UNRESTRICTED", "1"); err != nil {
+			return err
+		}
+	}
+
+	if cmd != "" {
+		_, err = i.Eval(cmd)
+	}
+
+	if len(args) == 0 {
+		if interactive || cmd == "" {
+			showError(err)
+			_, err = i.REPL()
+		}
+		return err
+	}
+
+	// Skip first os arg to set command line as expected by interpreted main
+	path := args[0]
+	os.Args = arg
+	flag.CommandLine = flag.NewFlagSet(path, flag.ExitOnError)
+
+	if isFile(path) {
+		err = runFile(i, path)
+	} else {
+		_, err = i.EvalPath(path)
+	}
+
+	if err != nil {
+		return err
+	}
+
+	if interactive {
+		_, err = i.REPL()
+	}
+	return err
+}
+
+func isFile(path string) bool {
+	fi, err := os.Stat(path)
+	return err == nil && fi.Mode().IsRegular()
+}
+
+func runFile(i *interp.Interpreter, path string) error {
+	b, err := ioutil.ReadFile(path)
+	if err != nil {
+		return err
+	}
+
+	if s := string(b); strings.HasPrefix(s, "#!") {
+		// Allow executable go scripts, Have the same behavior as in interactive mode.
+		s = strings.Replace(s, "#!", "//", 1)
+		_, err = i.Eval(s)
+		return err
+	}
+
+	// Files not starting with "#!" are supposed to be pure Go, directly Evaled.
+	_, err = i.EvalPath(path)
+	return err
+}
+
+func showError(err error) {
+	if err == nil {
+		return
+	}
+	fmt.Fprintln(os.Stderr, err)
+	if p, ok := err.(interp.Panic); ok {
+		fmt.Fprintln(os.Stderr, string(p.Stack))
+	}
+}

cmd/yaegi/test.go

@@ -0,0 +1,149 @@
+package main
+
+import (
+	"errors"
+	"flag"
+	"fmt"
+	"go/build"
+	"os"
+	"regexp"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/traefik/yaegi/interp"
+	"github.com/traefik/yaegi/stdlib"
+	"github.com/traefik/yaegi/stdlib/syscall"
+	"github.com/traefik/yaegi/stdlib/unrestricted"
+	"github.com/traefik/yaegi/stdlib/unsafe"
+)
+
+func test(arg []string) (err error) {
+	var (
+		bench     string
+		benchmem  bool
+		benchtime string
+		count     string
+		cpu       string
+		failfast  bool
+		run       string
+		short     bool
+		tags      string
+		timeout   string
+		verbose   bool
+	)
+
+	// The following flags are initialized from environment.
+	useSyscall, _ := strconv.ParseBool(os.Getenv("YAEGI_SYSCALL"))
+	useUnrestricted, _ := strconv.ParseBool(os.Getenv("YAEGI_UNRESTRICTED"))
+	useUnsafe, _ := strconv.ParseBool(os.Getenv("YAEGI_UNSAFE"))
+
+	tflag := flag.NewFlagSet("test", flag.ContinueOnError)
+	tflag.StringVar(&bench, "bench", "", "Run only those benchmarks matching a regular expression.")
+	tflag.BoolVar(&benchmem, "benchmem", false, "Print memory allocation statistics for benchmarks.")
+	tflag.StringVar(&benchtime, "benchtime", "", "Run enough iterations of each benchmark to take t.")
+	tflag.StringVar(&count, "count", "", "Run each test and benchmark n times (default 1).")
+	tflag.StringVar(&cpu, "cpu", "", "Specify a list of GOMAXPROCS values for which the tests or benchmarks should be executed.")
+	tflag.BoolVar(&failfast, "failfast", false, "Do not start new tests after the first test failure.")
+	tflag.StringVar(&run, "run", "", "Run only those tests matching a regular expression.")
+	tflag.BoolVar(&short, "short", false, "Tell long-running tests to shorten their run time.")
+	tflag.StringVar(&tags, "tags", "", "Set a list of build tags.")
+	tflag.StringVar(&timeout, "timeout", "", "If a test binary runs longer than duration d, panic.")
+	tflag.BoolVar(&useUnrestricted, "unrestricted", useUnrestricted, "Include unrestricted symbols.")
+	tflag.BoolVar(&useUnsafe, "unsafe", useUnsafe, "Include usafe symbols.")
+	tflag.BoolVar(&useSyscall, "syscall", useSyscall, "Include syscall symbols.")
+	tflag.BoolVar(&verbose, "v", false, "Verbose output: log all tests as they are run.")
+	tflag.Usage = func() {
+		fmt.Println("Usage: yaegi test [options] [path]")
+		fmt.Println("Options:")
+		tflag.PrintDefaults()
+	}
+	if err = tflag.Parse(arg); err != nil {
+		return err
+	}
+	args := tflag.Args()
+	path := "."
+	if len(args) > 0 {
+		path = args[0]
+	}
+
+	// Overwrite os.Args with correct flags to setup testing.Init.
+	tf := []string{""}
+	if bench != "" {
+		tf = append(tf, "-test.bench", bench)
+	}
+	if benchmem {
+		tf = append(tf, "-test.benchmem")
+	}
+	if benchtime != "" {
+		tf = append(tf, "-test.benchtime", benchtime)
+	}
+	if count != "" {
+		tf = append(tf, "-test.count", count)
+	}
+	if cpu != "" {
+		tf = append(tf, "-test.cpu", cpu)
+	}
+	if failfast {
+		tf = append(tf, "-test.failfast")
+	}
+	if run != "" {
+		tf = append(tf, "-test.run", run)
+	}
+	if short {
+		tf = append(tf, "-test.short")
+	}
+	if timeout != "" {
+		tf = append(tf, "-test.timeout", timeout)
+	}
+	if verbose {
+		tf = append(tf, "-test.v")
+	}
+	testing.Init()
+	os.Args = tf
+	flag.Parse()
+
+	i := interp.New(interp.Options{GoPath: build.Default.GOPATH, BuildTags: strings.Split(tags, ",")})
+	i.Use(stdlib.Symbols)
+	i.Use(interp.Symbols)
+	if useSyscall {
+		i.Use(syscall.Symbols)
+		// Using a environment var allows a nested interpreter to import the syscall package.
+		if err := os.Setenv("YAEGI_SYSCALL", "1"); err != nil {
+			return err
+		}
+	}
+	if useUnrestricted {
+		i.Use(unrestricted.Symbols)
+		if err := os.Setenv("YAEGI_UNRESTRICTED", "1"); err != nil {
+			return err
+		}
+	}
+	if useUnsafe {
+		i.Use(unsafe.Symbols)
+		if err := os.Setenv("YAEGI_UNSAFE", "1"); err != nil {
+			return err
+		}
+	}
+	if err = i.EvalTest(path); err != nil {
+		return err
+	}
+
+	benchmarks := []testing.InternalBenchmark{}
+	tests := []testing.InternalTest{}
+	syms, ok := i.Symbols(path)[path]
+	if !ok {
+		return errors.New("No tests found")
+	}
+	for name, sym := range syms {
+		switch fun := sym.Interface().(type) {
+		case func(*testing.B):
+			benchmarks = append(benchmarks, testing.InternalBenchmark{name, fun})
+		case func(*testing.T):
+			tests = append(tests, testing.InternalTest{name, fun})
+		}
+	}
+
+	testing.Main(regexp.MatchString, tests, benchmarks, nil)
+	return nil
+}

cmd/yaegi/yaegi.go

@@ -71,7 +71,16 @@ Options:
 	-unsafe
 	  include unsafe symbols.
 
-Debugging support (may be removed at any time):
+Environment variables:
+  YAEGI_SYSCALL=1
+    Include syscall symbols (same as -syscall flag).
+  YAEGI_UNRESTRICTED=1
+    Include unrestricted symbols (same as -unrestricted flag).
+  YAEGI_UNSAFE=1
+    Include unsafe symbols (same as -unsafe flag).
+  YAEGI_PROMPT=1
+    Force enable the printing of the REPL prompt and the result of last instruction,
+    even if stdin is not a terminal.
   YAEGI_AST_DOT=1
     Generate and display graphviz dot of AST with dotty(1)
   YAEGI_CFG_DOT=1
@@ -85,94 +94,62 @@ Debugging support (may be removed at any time):
 package main
 
 import (
+	"errors"
 	"flag"
 	"fmt"
-	"go/build"
-	"io/ioutil"
 	"log"
 	"os"
-	"strings"
 
-	"github.com/containous/yaegi/interp"
-	"github.com/containous/yaegi/stdlib"
-	"github.com/containous/yaegi/stdlib/syscall"
-	"github.com/containous/yaegi/stdlib/unrestricted"
-	"github.com/containous/yaegi/stdlib/unsafe"
+	"github.com/traefik/yaegi/interp"
 )
 
+const (
+	Extract = "extract"
+	Help    = "help"
+	Run     = "run"
+	Test    = "test"
+	Version = "version"
+)
+
+var version = "devel" // This may be overwritten at build time.
+
 func main() {
-	var interactive bool
-	var useSyscall bool
-	var useUnrestricted bool
-	var useUnsafe bool
-	var tags string
 	var cmd string
-	flag.BoolVar(&interactive, "i", false, "start an interactive REPL")
-	flag.BoolVar(&useSyscall, "syscall", false, "include syscall symbols")
-	flag.BoolVar(&useUnrestricted, "unrestricted", false, "include unrestricted symbols")
-	flag.StringVar(&tags, "tags", "", "set a list of build tags")
-	flag.BoolVar(&useUnsafe, "unsafe", false, "include usafe symbols")
-	flag.StringVar(&cmd, "e", "", "set the command to be executed (instead of script or/and shell)")
-	flag.Usage = func() {
-		fmt.Println("Usage:", os.Args[0], "[options] [script] [args]")
-		fmt.Println("Options:")
-		flag.PrintDefaults()
-	}
-	flag.Parse()
-	args := flag.Args()
-	log.SetFlags(log.Lshortfile)
+	var err error
+	var exitCode int
 
-	i := interp.New(interp.Options{GoPath: build.Default.GOPATH, BuildTags: strings.Split(tags, ",")})
-	i.Use(stdlib.Symbols)
-	i.Use(interp.Symbols)
-	if useSyscall {
-		i.Use(syscall.Symbols)
-	}
-	if useUnsafe {
-		i.Use(unsafe.Symbols)
-	}
-	if useUnrestricted {
-		// Use of unrestricted symbols should always follow use of stdlib symbols, to update them.
-		i.Use(unrestricted.Symbols)
+	log.SetFlags(log.Lshortfile) // Ease debugging.
+
+	if len(os.Args) > 1 {
+		cmd = os.Args[1]
 	}
 
-	if cmd != `` {
-		i.REPL(strings.NewReader(cmd), os.Stderr)
+	switch cmd {
+	case Extract:
+		err = extractCmd(os.Args[2:])
+	case Help, "-h", "--help":
+		err = help(os.Args[2:])
+	case Run:
+		err = run(os.Args[2:])
+	case Test:
+		err = test(os.Args[2:])
+	case Version:
+		fmt.Println(version)
+	default:
+		// If no command is given, fallback to default "run" command.
+		// This allows scripts starting with "#!/usr/bin/env yaegi",
+		// as passing more than 1 argument to #! executable may be not supported
+		// on all platforms.
+		cmd = Run
+		err = run(os.Args[1:])
 	}
 
-	if len(args) == 0 {
-		if interactive || cmd == `` {
-			i.REPL(os.Stdin, os.Stdout)
-		}
-		return
-	}
-
-	// Skip first os arg to set command line as expected by interpreted main
-	os.Args = os.Args[1:]
-	flag.CommandLine = flag.NewFlagSet(os.Args[0], flag.ExitOnError)
-
-	b, err := ioutil.ReadFile(args[0])
-	if err != nil {
-		log.Fatal("Could not read file: ", args[0])
-	}
-
-	if s := string(b); strings.HasPrefix(s, "#!") {
-		// Allow executable go scripts, Have the same behavior as in interactive mode.
-		s = strings.Replace(s, "#!", "//", 1)
-		i.REPL(strings.NewReader(s), os.Stdout)
-	} else {
-		// Files not starting with "#!" are supposed to be pure Go, directly Evaled.
-		i.Name = args[0]
-		_, err := i.Eval(s)
-		if err != nil {
-			fmt.Println(err)
+	if err != nil && !errors.Is(err, flag.ErrHelp) {
+		fmt.Fprintln(os.Stderr, fmt.Errorf("%s: %w", cmd, err))
 		if p, ok := err.(interp.Panic); ok {
-				fmt.Println(string(p.Stack))
+			fmt.Fprintln(os.Stderr, string(p.Stack))
 		}
+		exitCode = 1
 	}
-	}
-
-	if interactive {
-		i.REPL(os.Stdin, os.Stdout)
-	}
+	os.Exit(exitCode)
 }