elvish/eval/builtin_special.go

package eval

//go:genearte ./builtin_modules.bash

// Builtin special forms.

import (
	"fmt"
	"os"

	"github.com/elves/elvish/parse"
	"github.com/elves/elvish/store"
)

type compileBuiltin func(*compiler, *parse.Form) Op

var builtinSpecials map[string]compileBuiltin

// BuiltinSpecialNames contains all names of builtin special forms. It is
// useful for the syntax highlighter.
var BuiltinSpecialNames []string

func init() {
	// Needed to avoid initialization loop
	builtinSpecials = map[string]compileBuiltin{
		"del": compileDel,
		"fn":  compileFn,
		"use": compileUse,
	}
	for k := range builtinSpecials {
		BuiltinSpecialNames = append(BuiltinSpecialNames, k)
	}
}

func doSet(ec *EvalCtx, variables []Variable, values []Value) {
	// TODO Support assignment of mismatched arity in some restricted way -
	// "optional" and "rest" arguments and the like
	if len(variables) != len(values) {
		throw(ErrArityMismatch)
	}

	for i, variable := range variables {
		// TODO Prevent overriding builtin variables e.g. $pid $env
		variable.Set(values[i])
	}
}

// DelForm = 'del' { VariablePrimary }
func compileDel(cp *compiler, fn *parse.Form) Op {
	// Do conventional compiling of all compound expressions, including
	// ensuring that variables can be resolved
	var names, envNames []string
	for _, cn := range fn.Args {
		qname := mustString(cp, cn, "should be a literal variable name")
		splice, ns, name := parseVariable(qname)
		if splice {
			cp.errorf(cn.Begin(), "removing spliced variable makes no sense")
		}
		switch ns {
		case "", "local":
			if !cp.thisScope()[name] {
				cp.errorf(cn.Begin(), "variable $%s not found on current local scope", name)
			}
			delete(cp.thisScope(), name)
			names = append(names, name)
		case "env":
			envNames = append(envNames, name)
		default:
			cp.errorf(cn.Begin(), "can only delete a variable in local: or env:")
		}

	}
	return func(ec *EvalCtx) {
		for _, name := range names {
			delete(ec.local, name)
		}
		for _, name := range envNames {
			// BUG(xiaq): We rely on the fact that os.Unsetenv always returns
			// nil.
			os.Unsetenv(name)
		}
	}
}

// makeFnOp wraps an op such that a return is converted to an ok.
func makeFnOp(op Op) Op {
	return func(ec *EvalCtx) {
		ex := ec.PEval(op)
		if ex != Return {
			// rethrow
			throw(ex)
		}
	}
}

// FnForm = 'fn' StringPrimary LambdaPrimary
//
// fn f []{foobar} is a shorthand for set '&'f = []{foobar}.
func compileFn(cp *compiler, fn *parse.Form) Op {
	if len(fn.Args) == 0 {
		cp.errorf(fn.End(), "should be followed by function name")
	}
	fnName := mustString(cp, fn.Args[0], "must be a literal string")
	varName := FnPrefix + fnName

	if len(fn.Args) == 1 {
		cp.errorf(fn.Args[0].End(), "should be followed by a lambda")
	}
	pn := mustPrimary(cp, fn.Args[1], "should be a lambda")
	if pn.Type != parse.Lambda {
		cp.errorf(pn.Begin(), "should be a lambda")
	}
	if len(fn.Args) > 2 {
		cp.errorf(fn.Args[2].Begin(), "superfluous argument")
	}

	cp.registerVariableSet(":" + varName)
	op := cp.lambda(pn)

	return func(ec *EvalCtx) {
		// Initialize the function variable with the builtin nop
		// function. This step allows the definition of recursive
		// functions; the actual function will never be called.
		ec.local[varName] = NewPtrVariable(&BuiltinFn{"<shouldn't be called>", nop})
		closure := op(ec)[0].(*Closure)
		closure.Op = makeFnOp(closure.Op)
		ec.local[varName].Set(closure)
	}
}

// UseForm = 'use' StringPrimary [ Compound ]
func compileUse(cp *compiler, fn *parse.Form) Op {
	var modname string
	var filenameOp ValuesOp
	var filenameBegin int

	switch len(fn.Args) {
	case 0:
		cp.errorf(fn.Head.End(), "should be module name")
	case 2:
		filenameOp = cp.compound(fn.Args[1])
		filenameBegin = fn.Args[1].Begin()
		fallthrough
	case 1:
		modname = mustString(cp, fn.Args[0], "should be a literal module name")
	default:
		cp.errorf(fn.Args[2].Begin(), "superfluous argument")
	}

	return func(ec *EvalCtx) {
		if _, ok := ec.Evaler.modules[modname]; ok {
			// Module already loaded.
			return
		}

		// Load the source.
		var filename, source string

		if filenameOp != nil {
			// Filename was specified; evaluate it.
			values := filenameOp(ec)
			valuesMust := &muster{ec, "module filename", filenameBegin, values}
			filename = string(valuesMust.mustOneStr())
			var err error
			source, err = readFileUTF8(filename)
			maybeThrow(err)
		} else {
			// No filename; defaulting to $datadir/$modname.elv.
			dataDir, err := store.DataDir()
			maybeThrow(err)
			filename = dataDir + "/" + modname + ".elv"
			if _, err := os.Stat(filename); os.IsNotExist(err) {
				// File does not exist. Try loading from the table of builtin
				// modules.
				var ok bool
				if source, ok = builtinModules[modname]; ok {
					// Source is loaded. Do nothing more.
					filename = "<builtin module>"
				} else {
					throw(fmt.Errorf("cannot load %s: %s does not exist", modname, filename))
				}
			} else {
				// File exists. Load it.
				source, err = readFileUTF8(filename)
				maybeThrow(err)
			}
		}

		// TODO(xiaq): Should handle failures when evaluting the module
		newEc := &EvalCtx{
			ec.Evaler,
			filename, source, "module " + modname,
			Namespace{}, Namespace{},
			ec.ports,
		}

		n, err := parse.Parse(source)
		maybeThrow(err)

		op, err := newEc.Compile(n)
		// TODO the err originates in another source, should add appropriate information.
		maybeThrow(err)

		op(newEc)

		ec.Evaler.modules[modname] = newEc.local
	}
}