scriggo

type CombinedLoader ¶

type CombinedLoader []PackageLoader

CombinedLoader combines more loaders in one loader. Load calls in order the Load methods of each loader and returns as soon as a loader returns a package.

func (loaders CombinedLoader) Load(path string) (interface{}, error)

type CombinedPackage ¶

type CombinedPackage []Package

CombinedPackage combines more packages in one package with name the name of the first package and declarations the declarations of all the packages.

Lookup method calls in order the Lookup methods of each package and returns as soon as a package returns a declaration.

func (packages CombinedPackage) DeclarationNames() []string

func (packages CombinedPackage) Lookup(declName string) interface{}

func (packages CombinedPackage) Name() string

type CompilerError ¶

type CompilerError interface {
	error
	Position() ast.Position
	Path() string
	Message() string
}

CompilerError represents an error returned by the compiler.

type Declarations ¶

type Declarations map[string]interface{}

Declarations.

type LoadOptions ¶

type LoadOptions struct {
	OutOfSpec struct {
		AllowShebangLine bool         // allow shebang line; only for package-less programs.
		DisallowGoStmt   bool         // disallow "go" statement.
		PackageLess      bool         // enable the package-less syntax.
		Builtins         Declarations // builtins.
	}
}

type MapPackage ¶

type MapPackage struct {
	// Package name.
	PkgName string
	// Package declarations.
	Declarations map[string]interface{}
}

func (p *MapPackage) DeclarationNames() []string

func (p *MapPackage) Lookup(declName string) interface{}

func (p *MapPackage) Name() string

type MapStringLoader ¶

type MapStringLoader map[string]string

MapStringLoader implements PackageLoader that returns the source of a package. Package paths and sources are respectively the keys and the values of the map.

func (r MapStringLoader) Load(path string) (interface{}, error)

type Package ¶

type Package interface {

	// Name returns the package's name.
	Name() string

	// Lookup searches for an exported declaration, named declName, in the
	// package. If the declaration does not exist, it returns nil.
	//
	// For a variable returns a pointer to the variable, for a function
	// returns the function, for a type returns the reflect.Type and for a
	// constant returns its value or a Constant.
	Lookup(declName string) interface{}

	// DeclarationNames returns the exported declaration names in the package.
	DeclarationNames() []string
}

Package represents a predefined package.

type PackageLoader ¶

type PackageLoader interface {
	Load(path string) (interface{}, error)
}

PackageLoader is implemented by package loaders. Given a package path, Load returns a *Package value or a package source as io.Reader.

If the package does not exist it returns nil and nil. If the package exists but there was an error while loading the package, it returns nil and the error.

If Load returns an io.Reader that implements io.Closer, the Close method will be called after a Read returns either EOF or an error.

func Loaders(loaders ...PackageLoader) PackageLoader

type Packages ¶

type Packages map[string]Package

Packages is a Loader that load packages from a map where the key is a package path and the value is a *Package value.

func (pp Packages) Load(path string) (interface{}, error)

type Program ¶

type Program struct {
	// contains filtered or unexported fields
}

func Load(src io.Reader, loader PackageLoader, options *LoadOptions) (*Program, error)

func (p *Program) Disassemble(w io.Writer, pkgPath string) (int64, error)

func (p *Program) MustRun(options *RunOptions) int

func (p *Program) Run(options *RunOptions) (int, error)

type RunOptions ¶

type RunOptions struct {
	Context   context.Context
	PrintFunc runtime.PrintFunc
	OutOfSpec struct {
		Builtins map[string]interface{}
	}
}

type UntypedBooleanConst ¶

type UntypedBooleanConst = compiler.UntypedBooleanConst

UntypedBooleanConst represents an untyped boolean constant.

type UntypedNumericConst ¶

type UntypedNumericConst = compiler.UntypedNumericConst

UntypedNumericConst represents an untyped numeric constant.

type UntypedStringConst ¶

type UntypedStringConst = compiler.UntypedStringConst

UntypedStringConst represents an untyped string constant.