government / cmd / govlisp / main.go

@ 7eeb8a0214368f4491f26f4cf37bd7bf6dc67cd3 | history


// Command govlisp runs GOVERNMENT programs straight from Lisp source, with
// no certificates involved.
//
//	govlisp              interactive REPL
//	govlisp prog.gov.lisp    run a file, printing the value of each non-define form
//
// The REPL has no line editing; wrap it with rlwrap for history and arrow
// keys.
package main

import (
	"fmt"
	"io"
	"os"
	"strings"

	"government/eval"
	"government/sexpr"
)

const (
	exitOK      = 0
	exitRuntime = 1
	exitSyntax  = 2
)

func main() {
	switch len(os.Args) {
	case 1:
		os.Exit(repl(os.Stdin, os.Stdout, isTerminal(os.Stdin)))
	case 2:
		os.Exit(runFile(os.Args[1], os.Stdout, os.Stderr))
	default:
		fmt.Fprintln(os.Stderr, "usage: govlisp [file.gov.lisp]")
		os.Exit(exitSyntax)
	}
}

func isTerminal(f *os.File) bool {
	info, err := f.Stat()
	return err == nil && info.Mode()&os.ModeCharDevice != 0
}

// runFile evaluates every top-level form in path, printing each non-define
// value. It stops at the first error, which it reports with the source
// position of the subexpression that failed.
func runFile(path string, stdout, stderr io.Writer) int {
	src, err := os.ReadFile(path)
	if err != nil {
		fmt.Fprintln(stderr, err)
		return exitSyntax
	}
	r := sexpr.NewReader(string(src))
	var forms []sexpr.Value
	var starts []sexpr.Pos
	for {
		v, pos, err := r.ReadWithPos()
		if err != nil {
			fmt.Fprintf(stderr, "%s:%v\n", path, err)
			return exitSyntax
		}
		if v == nil {
			break
		}
		forms = append(forms, v)
		starts = append(starts, pos)
	}

	top := eval.NewTopLevel()
	for i, form := range forms {
		v, err := top.Eval(form)
		if err != nil {
			pos := starts[i]
			if e, ok := err.(*eval.Error); ok {
				if p, ok := r.Position(e.Expr); ok {
					pos = p
				}
			}
			fmt.Fprintf(stderr, "%s:%v: %v\n", path, pos, err)
			return exitRuntime
		}
		if !isDefine(form) {
			fmt.Fprintln(stdout, sexpr.Print(v))
		}
	}
	return exitOK
}

// repl reads forms from in until end of input. A form may span several
// lines: while the input so far is an unfinished form, it keeps reading.
// An error is reported and the session carries on; definitions made before
// it are kept.
func repl(in io.Reader, out io.Writer, prompts bool) int {
	const (
		prompt       = "gov> "
		continuation = "...> "
	)
	top := eval.NewTopLevel()
	lines := newLineReader(in)
	var entry strings.Builder

	for {
		if prompts {
			if entry.Len() == 0 {
				fmt.Fprint(out, prompt)
			} else {
				fmt.Fprint(out, continuation)
			}
		}
		line, ok := lines.next()
		if !ok {
			if entry.Len() > 0 {
				if _, err := sexpr.ReadAll(entry.String()); err != nil {
					fmt.Fprintf(out, "syntax error: %v\n", err)
				}
			}
			if prompts {
				fmt.Fprintln(out)
			}
			return exitOK
		}
		entry.WriteString(line)
		entry.WriteByte('\n')

		forms, err := sexpr.ReadAll(entry.String())
		if se, ok := err.(*sexpr.SyntaxError); ok && se.Incomplete {
			continue
		}
		entry.Reset()
		if err != nil {
			fmt.Fprintf(out, "syntax error: %v\n", err)
			continue
		}
		for _, form := range forms {
			v, err := top.Eval(form)
			if err != nil {
				fmt.Fprintln(out, describe(err))
				break
			}
			if !isDefine(form) {
				fmt.Fprintln(out, sexpr.Print(v))
			}
		}
	}
}

// describe adds the subexpression that failed to an evaluation error.
func describe(err error) string {
	e, ok := err.(*eval.Error)
	if !ok || e.Expr == nil {
		return err.Error()
	}
	return fmt.Sprintf("%v\n  in %s", err, sexpr.Print(e.Expr))
}

func isDefine(form sexpr.Value) bool {
	p, ok := form.(*sexpr.Pair)
	return ok && p.Car == sexpr.Value(sexpr.Symbol("define"))
}