@ f98307e213f9f3c11b00c8edc3c367c315b9819a | 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"))
}