package interp

Import Path
	github.com/traefik/yaegi/interp (on go.dev)

Dependency Relation
	imports 33 packages, and imported by one package

Involved Source Files

	    ast.go
	    build.go
	    cfg.go
	    debugger.go
	  d doc.go
		Package interp provides a complete Go interpreter.
		
		For the Go language itself, refer to the official Go specification
		https://golang.org/ref/spec.
		
		# Importing packages
		
		Packages can be imported in source or binary form, using the standard
		Go import statement. In source form, packages are searched first in the
		vendor directory, the preferred way to store source dependencies. If not
		found in vendor, sources modules will be searched in GOPATH. Go modules
		are not supported yet by yaegi.
		
		Binary form packages are compiled and linked with the interpreter
		executable, and exposed to scripts with the Use method. The extract
		subcommand of yaegi can be used to generate package wrappers.
		
		# Custom build tags
		
		Custom build tags allow to control which files in imported source
		packages are interpreted, in the same way as the "-tags" option of the
		"go build" command. Setting a custom build tag spans globally for all
		future imports of the session.
		
		A build tag is a line comment that begins
		
			// yaegi:tags
		
		that lists the build constraints to be satisfied by the further
		imports of source packages.
		
		For example the following custom build tag
		
			// yaegi:tags noasm
		
		Will ensure that an import of a package will exclude files containing
		
			// +build !noasm
		
		And include files containing
		
			// +build noasm

	    dot.go
	    generic.go
	    gta.go
	    hooks.go
	    interp.go
	    op.go
	    program.go
	    realfs.go
	    run.go
	    scope.go
	    src.go
	    type.go
	    typecheck.go
	    typestring.go
	    use.go
	    value.go
Code Examples

	_eval
		package main
		
		import (
			"fmt"
			"log"
		
			"github.com/traefik/yaegi/interp"
		)
		
		func main() {
			// Create a new interpreter context
			i := interp.New(interp.Options{})
		
			// Run some code: define a new function
			_, err := i.Eval("func f(i int) int { return 2 * i }")
			if err != nil {
				log.Fatal(err)
			}
		
			// Access the interpreted f function with Eval
			v, err := i.Eval("f")
			if err != nil {
				log.Fatal(err)
			}
		
			// Returned v is a reflect.Value, so we can use its interface
			f, ok := v.Interface().(func(int) int)
			if !ok {
				log.Fatal("type assertion failed")
			}
		
			// Use interpreted f as it was pre-compiled
			fmt.Println(f(2))
		
		}


Package-Level Type Names (total 16)

	/* sort by: alphabet | popularity */
	 type Breakpoint (struct)
		Breakpoint is the result of attempting to set a breakpoint.

		Fields (total 2)
			Position token.Position
				Position indicates the source position of the breakpoint.

			Valid bool
				Valid indicates whether the breakpoint was successfully set.

		As Outputs Of (at least one exported)
			func (*Debugger).SetBreakpoints(target BreakpointTarget, requests ...BreakpointRequest) []Breakpoint

	 type BreakpointRequest (func)
		BreakpointRequest is a request to set a breakpoint.

		As Outputs Of (at least 2)
			func FunctionBreakpoint(name string) BreakpointRequest
			func LineBreakpoint(line int) BreakpointRequest
		As Inputs Of (at least one exported)
			func (*Debugger).SetBreakpoints(target BreakpointTarget, requests ...BreakpointRequest) []Breakpoint

	 type BreakpointTarget (func)
		BreakpointTarget is the target of a request to set breakpoints.

		As Outputs Of (at least 3)
			func AllBreakpointTarget() BreakpointTarget
			func PathBreakpointTarget(path string) BreakpointTarget
			func ProgramBreakpointTarget(prog *Program) BreakpointTarget
		As Inputs Of (at least one exported)
			func (*Debugger).SetBreakpoints(target BreakpointTarget, requests ...BreakpointRequest) []Breakpoint

	 type DebugEvent (struct)
		A DebugEvent is an event generated by a debugger.

		Methods (total 4)
			(*DebugEvent) FrameDepth() int
				FrameDepth returns the number of call frames in the stack trace.

			(*DebugEvent) Frames(start, end int) []*DebugFrame
				Frames returns the call frames in the range [start, end).

			(*DebugEvent) GoRoutine() int
				GoRoutine returns the ID of the Go routine that generated the event.

			(*DebugEvent) Reason() DebugEventReason
				Reason returns the reason for the event.


	 type DebugEventReason int (basic type)
		DebugEventReason is the reason a debug event occurred.

		As Outputs Of (at least one exported)
			func (*DebugEvent).Reason() DebugEventReason
		As Inputs Of (at least 2)
			func (*Debugger).Interrupt(id int, reason DebugEventReason) bool
			func (*Debugger).Step(id int, reason DebugEventReason) error
		As Types Of (total 9)
			const DebugBreak
			const DebugEnterGoRoutine
			const DebugEntry
			const DebugExitGoRoutine
			const DebugPause
			const DebugStepInto
			const DebugStepOut
			const DebugStepOver
			const DebugTerminate

	 type DebugFrame (struct)
		DebugFrame provides access to stack frame information while debugging a
		program.

		Methods (total 4)
			(*DebugFrame) Name() string
				Name returns the name of the stack frame. For function calls to named
				functions, this is the function name.

			(*DebugFrame) Position() token.Position
				Position returns the current position of the frame. This is effectively the
				program counter/link register. May return `Position{}`.

			(*DebugFrame) Program() *Program
				Program returns the program associated with the current position of the
				frame. May return nil.

			(*DebugFrame) Scopes() []*DebugFrameScope
				Scopes returns the variable scopes of the frame.

		Implements (at least one exported)
			*DebugFrame : github.com/polarsignals/frostdb/query/logicalplan.Named
		As Outputs Of (at least one exported)
			func (*DebugEvent).Frames(start, end int) []*DebugFrame

	 type DebugFrameScope (struct)
		DebugFrameScope provides access to scoped variables while debugging a
		program.

		Methods (total 2)
			(*DebugFrameScope) IsClosure() bool
				IsClosure returns true if this is the capture scope of a closure.

			(*DebugFrameScope) Variables() []*DebugVariable
				Variables returns the names and values of the variables of the scope.

		As Outputs Of (at least one exported)
			func (*DebugFrame).Scopes() []*DebugFrameScope

	 type Debugger (struct)
		A Debugger can be used to debug a Yaegi program.

		Methods (total 7)
			(*Debugger) Continue(id int) error
				Continue continues execution of the specified Go routine. Continue returns
				ErrNotLive if there is no Go routine with the corresponding ID, or if it is not
				live.

			(*Debugger) GoRoutines() []*DebugGoRoutine
				GoRoutines returns an array of live Go routines.

			(*Debugger) Interrupt(id int, reason DebugEventReason) bool
				Interrupt issues a stepInto, stepOver, or stepOut request to a running Go
				routine. Interrupt returns ErrRunning if the Go routine is running. Interrupt
				returns ErrNotLive if there is no Go routine with the corresponding ID, or if
				it is not live.

			(*Debugger) SetBreakpoints(target BreakpointTarget, requests ...BreakpointRequest) []Breakpoint
				SetBreakpoints sets breakpoints for the given target. The returned array has
				an entry for every request, in order. If a given breakpoint request cannot be
				satisfied, the corresponding entry will be marked invalid. If the target
				cannot be found, all entries will be marked invalid.

			(*Debugger) Step(id int, reason DebugEventReason) error
				Step issues a stepInto, stepOver, or stepOut request to a stopped Go routine.
				Step returns ErrRunning if the Go routine is running. Step returns ErrNotLive
				if there is no Go routine with the corresponding ID, or if it is not live.

			(*Debugger) Terminate()
				Terminate attempts to terminate the program.

			(*Debugger) Wait() (reflect.Value, error)
				Wait blocks until all Go routines launched by the program have terminated.
				Wait returns the results of `(*Interpreter).Execute`.

		As Outputs Of (at least one exported)
			func (*Interpreter).Debug(ctx context.Context, prog *Program, events func(*DebugEvent), opts *DebugOptions) *Debugger

	 type DebugGoRoutine (struct)
		DebugGoRoutine provides access to information about a Go routine while
		debugging a program.

		Methods (total 2)
			(*DebugGoRoutine) ID() int
				ID returns the ID of the Go routine.

			(*DebugGoRoutine) Name() string
				Name returns "Goroutine {ID}".

		Implements (at least one exported)
			*DebugGoRoutine : github.com/polarsignals/frostdb/query/logicalplan.Named
		As Outputs Of (at least one exported)
			func (*Debugger).GoRoutines() []*DebugGoRoutine

	 type DebugOptions (struct)
		DebugOptions are the debugger options.

		Fields (only one)
			GoRoutineStartAt1 bool
				If true, Go routine IDs start at 1 instead of 0.

		As Inputs Of (at least one exported)
			func (*Interpreter).Debug(ctx context.Context, prog *Program, events func(*DebugEvent), opts *DebugOptions) *Debugger

	 type DebugVariable (struct)
		DebugVariable is the name and value of a variable from a debug session.

		Fields (total 2)
			Name string
			Value reflect.Value
		As Outputs Of (at least one exported)
			func (*DebugFrameScope).Variables() []*DebugVariable

	 type Exports (map)
		Exports stores the map of binary packages per package path.
		The package path is the path joined from the import path and the package name
		as specified in source files by the "package" statement.

		As Outputs Of (at least one exported)
			func (*Interpreter).Symbols(importPath string) Exports
		As Inputs Of (at least 2)
			func (*Interpreter).Use(values Exports) error
			func github.com/pancsta/asyncmachine-go/pkg/integrations/yaegi.Exec[G](mach am.Api, code fstest.MapFS, host G, symbols Exports, ioOut, ioErr io.Writer) (*yhost.Ret, error)
		As Types Of (only one)
			  var Symbols

	 type Interpreter (struct)
		Interpreter contains global resources and state.

		Methods (total 17)
			(*Interpreter) Compile(src string) (*Program, error)
				Compile parses and compiles a Go code represented as a string.

			(*Interpreter) CompileAST(n ast.Node) (*Program, error)
				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.

			(*Interpreter) CompilePath(path string) (*Program, error)
				CompilePath parses and compiles a Go code located at the given path.

			(*Interpreter) Debug(ctx context.Context, prog *Program, events func(*DebugEvent), opts *DebugOptions) *Debugger
				Debug initializes a debugger for the given program.
				
				The program will not start running until Step or Continue has been called. If
				Step is called with DebugEntry, an entry event will be generated before the
				first statement is executed. Otherwise, the debugger will behave as usual.

			(*Interpreter) Eval(src string) (res reflect.Value, err error)
				Eval evaluates Go code represented as a string. Eval returns the last result
				computed by the interpreter, and a non nil error in case of failure.

			(*Interpreter) EvalPath(path string) (res reflect.Value, err error)
				EvalPath evaluates Go code located at path and returns the last result computed
				by the interpreter, and a non nil error in case of failure.
				The main function of the main package is executed if present.

			(*Interpreter) EvalPathWithContext(ctx context.Context, path string) (res reflect.Value, err error)
				EvalPathWithContext evaluates Go code located at path and returns the last
				result computed by the interpreter, and a non nil error in case of failure.
				The main function of the main package is executed if present.

			(*Interpreter) EvalTest(path string) error
				EvalTest evaluates Go code located at path, including test files with "_test.go" suffix.
				A non nil error is returned in case of failure.
				The main function, test functions and benchmark functions are internally compiled but not
				executed. Test functions can be retrieved using the Symbol() method.

			(*Interpreter) EvalWithContext(ctx context.Context, src string) (reflect.Value, error)
				EvalWithContext evaluates Go code represented as a string. It returns
				a map on current interpreted package exported symbols.

			(*Interpreter) Execute(p *Program) (res reflect.Value, err error)
				Execute executes compiled Go code.

			(*Interpreter) ExecuteWithContext(ctx context.Context, p *Program) (res reflect.Value, err error)
				ExecuteWithContext executes compiled Go code.

			(*Interpreter) FileSet() *token.FileSet
				FileSet is the fileset that must be used for parsing Go that will be passed
				to interp.CompileAST().

			(*Interpreter) Globals() map[string]reflect.Value
				Globals returns a map of global variables and constants in the main package.

			(*Interpreter) ImportUsed()
				ImportUsed automatically imports pre-compiled packages included by Use().
				This is mainly useful for REPLs, or single command lines. In case of an ambiguous default
				package name, for example "rand" for crypto/rand and math/rand, the package name is
				constructed by replacing the last "/" by a "_", producing crypto_rand and math_rand.
				ImportUsed should not be called more than once, and not after a first Eval, as it may
				rename packages.

			(*Interpreter) REPL() (reflect.Value, error)
				REPL performs a Read-Eval-Print-Loop on input reader.
				Results are printed to the output writer of the Interpreter, provided as option
				at creation time. Errors are printed to the similarly defined errors writer.
				The last interpreter result value and error are returned.

			(*Interpreter) Symbols(importPath string) Exports
				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.

			(*Interpreter) Use(values Exports) error
				Use loads binary runtime symbols in the interpreter context so
				they can be used in interpreted code.

		As Outputs Of (at least one exported)
			func New(options Options) *Interpreter
		As Types Of (only one)
			  var Self *Interpreter

	 type Options (struct)
		Options are the interpreter options.

		Fields (total 9)
			Args []string
				Cmdline args, defaults to os.Args.

			BuildTags []string
				BuildTags sets build constraints for the interpreter.

			Env []string
				Environment of interpreter. Entries are in the form "key=values".

			GoPath string
				GoPath sets GOPATH for the interpreter.

			SourcecodeFilesystem fs.FS
				SourcecodeFilesystem is where the _sourcecode_ is loaded from and does
				NOT affect the filesystem of scripts when they run.
				It can be any fs.FS compliant filesystem (e.g. embed.FS, or fstest.MapFS for testing)
				See example/fs/fs_test.go for an example.

			Stderr io.Writer
			Stdin io.Reader
				Standard input, output and error streams.
				They default to os.Stdin, os.Stdout and os.Stderr respectively.

			Stdout io.Writer
			Unrestricted bool
				Unrestricted allows to run non sandboxed stdlib symbols such as os/exec and environment

		As Inputs Of (at least one exported)
			func New(options Options) *Interpreter

	 type Panic (struct)
		Panic is an error recovered from a panic call in interpreted code.

		Fields (total 3)
			Callers []uintptr
				Callers is the call stack obtained from the recover call.
				It may be used as the parameter to runtime.CallersFrames.

			Stack []byte
				Stack is the call stack buffer for debug.

			Value interface{}
				Value is the recovered value of a call to panic.

		Methods (only one)
			( Panic) Error() string
		Implements (at least one exported)
			 Panic : error

	 type Program (struct)
		A Program is Go code that has been parsed and compiled.

		Methods (only one)
			(*Program) PackageName() string
				PackageName returns name used in a package clause.

		As Outputs Of (at least 4)
			func (*DebugFrame).Program() *Program
			func (*Interpreter).Compile(src string) (*Program, error)
			func (*Interpreter).CompileAST(n ast.Node) (*Program, error)
			func (*Interpreter).CompilePath(path string) (*Program, error)
		As Inputs Of (at least 4)
			func ProgramBreakpointTarget(prog *Program) BreakpointTarget
			func (*Interpreter).Debug(ctx context.Context, prog *Program, events func(*DebugEvent), opts *DebugOptions) *Debugger
			func (*Interpreter).Execute(p *Program) (res reflect.Value, err error)
			func (*Interpreter).ExecuteWithContext(ctx context.Context, p *Program) (res reflect.Value, err error)


Package-Level Functions (total 6)

	 func AllBreakpointTarget() BreakpointTarget
		AllBreakpointTarget is used to set breakpoints on all compiled code. Do not
		use with LineBreakpoint.

	 func FunctionBreakpoint(name string) BreakpointRequest
		FunctionBreakpoint requests a breakpoint on the named function.

	 func LineBreakpoint(line int) BreakpointRequest
		LineBreakpoint requests a breakpoint on the given line.

	 func New(options Options) *Interpreter
		New returns a new interpreter.

	 func PathBreakpointTarget(path string) BreakpointTarget
		PathBreakpointTarget is used to set breapoints on compiled code by path. This
		can be used to set breakpoints on code compiled with EvalPath, or source
		packages loaded by Yaegi.

	 func ProgramBreakpointTarget(prog *Program) BreakpointTarget
		ProgramBreakpointTarget is used to set breakpoints on a Program.


Package-Level Variables (total 5)

	  var ErrNotLive error
		ErrNotLive indicates that the specified ID does not refer to a (live) Go
		routine.

	  var ErrNotRunning error
		ErrNotRunning indicates that the specified Go routine is running.

	  var ErrRunning error
		ErrRunning indicates that the specified Go routine is running.

	  var Self *Interpreter
		Self points to the current interpreter if accessed from within itself, or is nil.

	  var Symbols Exports
		Symbols exposes interpreter values.


Package-Level Constants (total 12)

	const DebugBreak DebugEventReason = 2
		DebugBreak is emitted when a debug target hits a breakpoint.

	const DebugEnterGoRoutine DebugEventReason = 8
		DebugEnterGoRoutine is emitted when a Go routine is entered.

	const DebugEntry DebugEventReason = 3
		DebugEntry is emitted when a debug target starts executing. Can be used
		with Step to produce a corresponding event when execution starts.

	const DebugExitGoRoutine DebugEventReason = 9
		DebugExitGoRoutine is emitted when a Go routine is exited.

	const DebugPause DebugEventReason = 1
		DebugPause is emitted when a pause request is completed. Can be used with
		Interrupt to request a pause.

	const DebugStepInto DebugEventReason = 4
		DebugStepInto is emitted when a stepInto request is completed. Can be
		used with Step or Interrupt to request a stepInto.

	const DebugStepOut DebugEventReason = 6
		DebugStepOut is emitted when a stepOut request is completed. Can be used
		with Step or Interrupt to request a stepOut.

	const DebugStepOver DebugEventReason = 5
		DebugStepOver is emitted when a stepOver request is completed. Can be
		used with Step or Interrupt to request a stepOver.

	const DebugTerminate DebugEventReason = 7
		DebugTerminate is emitted when a debug target terminates. Can be used
		with Interrupt to attempt to terminate the program.

	const DefaultSourceName = "_.go"
		DefaultSourceName is the name used by default when the name of the input
		source file has not been specified for an Eval.
		TODO(mpl): something even more special as a name?

	const NoTest = true
		NoTest is the value to pass to EvalPath to skip evaluation of test functions.

	const Test = false
		Test is the value to pass to EvalPath to activate evaluation of test functions.

The pages are generated with Golds v0.8.4. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.