package plugin

Import Path
	plugin (on golang.org and go.dev)

Dependency Relation
	imports one package, and imported by 0 packages


Involved Source Files
	
		Package plugin implements loading and symbol resolution of Go plugins.

		A plugin is a Go main package with exported functions and variables that
		has been built with:

			go build -buildmode=plugin

		When a plugin is first opened, the init functions of all packages not
		already part of the program are called. The main function is not run.
		A plugin is only initialized once, and cannot be closed.

		Currently plugins are only supported on Linux, FreeBSD, and macOS.
		Please report any issues.
	      plugin_stubs.go

Package-Level Type Names (total 2)


	/* sort by:  |  */
	
		Plugin is a loaded Go plugin.

		
			
				Lookup searches for a symbol named symName in plugin p.
				A symbol is any exported variable or function.
				It reports an error if the symbol is not found.
				It is safe for concurrent use by multiple goroutines.

		
			func Open(path string) (*Plugin, error)


	
		A Symbol is a pointer to a variable or function.

		For example, a plugin defined as

			package main

			import "fmt"

			var V int

			func F() { fmt.Printf("Hello, number %d\n", V) }

		may be loaded with the Open function and then the exported package
		symbols V and F can be accessed

			p, err := plugin.Open("plugin_name.so")
			if err != nil {
				panic(err)
			}
			v, err := p.Lookup("V")
			if err != nil {
				panic(err)
			}
			f, err := p.Lookup("F")
			if err != nil {
				panic(err)
			}
			*v.(*int) = 7
			f.(func())() // prints "Hello, number 7"

		
			func (*Plugin).Lookup(symName string) (Symbol, error)




Package-Level Functions (only one)


	
		Open opens a Go plugin.
		If a path has already been opened, then the existing *Plugin is returned.
		It is safe for concurrent use by multiple goroutines.