slope/specialForms.go

663 lines
16 KiB
Go
Raw Normal View History

package main
import (
"fmt"
"os"
"path/filepath"
"reflect"
"regexp"
"sort"
"strings"
"git.rawtext.club/sloum/slope/termios"
ln "github.com/peterh/liner"
)
func specialAnd(e []expression, en *env) expression {
if len(e) < 2 {
return exception("Invalid 'and' syntax - too few arguments")
}
var value expression
OuterAnd:
for i := range e[1:] {
switch item := e[i+1].(type) {
case []expression:
value = eval(item, en)
if !AnythingToBool(value).(bool) {
break OuterAnd
}
default:
value = eval(item, en)
if !AnythingToBool(value).(bool) {
break OuterAnd
}
}
}
return value
}
func specialApply(e []expression, en *env) expression {
if len(e) < 3 {
return exception("'apply' expects two arguments: a procedure and an argument list, too few arguments were given")
}
args := eval(e[2], en)
// TODO make this work so that we dont have to eval things here
switch item := args.(type) {
case []expression:
return apply(eval(e[1], en), item, true)
default:
return apply(eval(e[1], en), []expression{item}, true)
}
}
func specialBegin0(e []expression, en *env) expression {
var v expression
for ii, i := range e[1:] {
if ii == 0 {
v = eval(i, en)
} else {
eval(i, en)
}
}
return v
}
func specialBegin(e []expression, en *env) expression {
var v expression
for _, i := range e[1:] {
v = eval(i, en)
}
return v
}
func specialCase(e []expression, en *env) expression {
if len(e) < 3 {
return exception("Invalid 'case' syntax - too few arguments")
}
target := eval(e[1], en)
var value expression
CaseLoop:
for _, exp := range e[2:] {
switch i := exp.(type) {
case []expression:
if len(i) < 2 {
return exception("Invalid 'case' case, cases must take the form: `(<test> <expression>)")
}
if i[0] == "else" || i[0] == symbol("else") {
value = eval(i[1], en)
break CaseLoop
}
if reflect.DeepEqual(eval(i[0], en), target) {
value = eval(i[1], en)
break CaseLoop
}
default:
return exception("Invalid 'case' case, cases must take the form: `(<test> <expression>)")
}
}
// TODO this may not work
if value == nil {
value = make([]expression, 0)
}
return value
}
func specialCond(e []expression, en *env) expression {
if len(e) < 2 {
return exception("Invalid 'cond' syntax - too few arguments")
}
var value expression
CondLoop:
for _, exp := range e[1:] {
switch i := exp.(type) {
case []expression:
if len(i) < 2 {
return exception("Invalid 'cond' case, cases must take the form: `(<test> <expression>)")
}
if i[0] == "else" || i[0] == symbol("else") {
value = eval(i[1], en)
break CondLoop
}
if AnythingToBool(eval(i[0], en)).(bool) {
value = eval(i[1], en)
break CondLoop
}
default:
return exception("Invalid 'cond' case, cases must take the form: `(<test> <expression>)")
}
}
if value == nil {
value = make([]expression, 0)
}
return value
}
func specialDefine(e []expression, en *env) expression {
if len(e) < 3 {
return exception("Invalid 'define' syntax - too few arguments")
}
sym, ok := e[1].(symbol)
if !ok {
e[1] = eval(e[1], en)
sym, ok = e[1].(symbol)
if !ok {
return exception("'define' expects a symbol as its first argument")
}
}
if strings.Contains(string(sym), "::") {
return exception("'define' cannot create a symbol reference within a module, designated by '::' within a symbol name")
}
val := eval(e[2], en)
en.vars[sym] = val
return val
}
func specialEval(e []expression, en *env) expression {
if len(e) < 1 {
return exception("'eval' expects a string and an optional boolean to indicate that a string should be parsed and evaluated, but was not given any arguments")
}
sParse := false
if len(e) >= 3 {
v, ok := e[2].(bool)
if ok {
sParse = v
}
}
switch item := eval(e[1], en).(type) {
case []expression:
if _, ok := item[0].(symbol); !ok {
return item
} else {
value := eval(item, en)
v, ok := value.(string)
if ok && sParse {
p := Parse(v)
return eval(p.([]expression)[0], en)
}
return value
}
case string:
if sParse {
p := Parse(item)
if l, ok := p.([]expression)[0].([]expression); ok {
if _, ok := l[0].(symbol); ok {
return eval(p.([]expression)[0], en)
} else {
return l
}
} else {
return eval(p.([]expression)[0], en)
}
} else {
return item
}
default:
return item
}
}
func specialExists(e []expression, en *env) expression {
if len(e) == 0 {
return exception("'exists?' expects at least one symbol or string, no values were given")
}
var err error
for i := range e[1:] {
doPanic := panicOnException
if doPanic {
panicOnException = false
}
// TODO make this work with interpreter forms
_, ok := e[i].([]expression)
if ok {
_, err = en.Find(symbol(String(eval(e[i+1], en), false)))
} else {
environ := en
symbolAsString := String(e[i+1], false)
if i := strings.Index(symbolAsString, "::"); i >= 0 {
modname := symbolAsString[:i]
alias, ok := altnamespaces[modname]
if !ok {
e, ok2 := namespaces[modname]
if !ok2 {
if doPanic {
panicOnException = true
}
return false
}
environ = &e
} else {
e := namespaces[alias]
environ = &e
}
symbolAsString = symbolAsString[i+2:]
}
_, err = environ.Find(symbol(symbolAsString))
}
if doPanic {
panicOnException = true
}
if err != nil {
return false
}
}
return true
}
func specialFor(e []expression, en *env) expression {
if len(e) < 3 {
return exception("'for' requires at least two arguments: a list of initializers and a test")
}
// Set up args/iterators
args, ok := e[1].([]expression)
if !ok {
return exception("'for' expected a list of arguments and values as its first argument, a non-list value was received")
}
newEnv := &env{make(map[symbol]expression), en}
updates := []expression{symbol("begin")}
for _, v := range args {
arg, ok := v.([]expression)
if varname, varok := arg[0].(symbol); varok && ok && len(arg) >= 2 {
newEnv.vars[varname] = eval(arg[1], en)
} else {
return exception("'for' expected its first argument to be a list of lists, each with a symbol, a value, and an optional update expression. A list was given, but it contained a non-list value")
}
if len(arg) >= 3 {
updates = append(updates, []expression{symbol("set!"), arg[0], arg[2]})
}
}
// Get test and return expression
testReturn, ok := e[2].([]expression)
if !ok || len(testReturn) == 0 {
return exception("'for' expected a list containing a logic test and an optional return value expression for its second argument, a non-list was given")
}
test := testReturn[0]
var returnExpression expression = []expression{symbol("list")}
if len(testReturn) > 1 {
returnExpression = testReturn[1]
}
body := []expression{symbol("begin")}
body = append(body, e[3:]...)
for {
// Check the condition by evaluating the test
if !AnythingToBool(eval(test, newEnv)).(bool) {
break
}
// Run the body code
eval(body, newEnv)
// Run the iteration updates
eval(updates, newEnv)
}
return eval(returnExpression, newEnv)
}
func specialIf(e []expression, en *env) expression {
if len(e) < 3 {
return exception("Invalid 'if' syntax - too few arguments")
}
if AnythingToBool(eval(e[1], en)).(bool) {
return eval(e[2], en)
}
if len(e) > 3 {
return eval(e[3], en)
}
return make([]expression, 0)
}
func specialInspect(e []expression, en *env) expression {
// Make sure we are attached to a tty
if fileInfo, _ := os.Stdout.Stat(); (fileInfo.Mode() & os.ModeCharDevice) == 0 {
return false
}
if fileInfo, _ := os.Stdin.Stat(); (fileInfo.Mode() & os.ModeCharDevice) == 0 {
return false
}
initialState, _ := ln.TerminalMode()
liner := ln.NewLiner()
linerState, _ := ln.TerminalMode()
defer liner.Close()
histFile := ExpandedAbsFilepath(filepath.Join(getModBaseDir(), "..", historyFilename))
if f, e := os.Open(histFile); e == nil {
liner.ReadHistory(f)
f.Close()
}
// Set up completion
liner.SetTabCompletionStyle(ln.TabCircular)
liner.SetCompleter(func(l string) (c []string) {
if len(l) == 0 {
return
}
lastIndex := strings.LastIndexAny(l, "( \n")
c = append(c, completeFromMap(usageStrings, l, lastIndex)...)
c = append(c, completeFromMap(getAllModFuncNames(), l, lastIndex)...)
sort.Strings(c)
return
})
inspectID := "inspect"
if len(e) > 1 {
inspectID = String(eval(e[1], en), false)
}
var text strings.Builder
var cont bool
var raw bool
var match bool
for {
globalenv.vars[symbol("slope-interactive?")] = true
if linerState != nil {
linerState.ApplyMode()
}
in := prompt(liner, cont, inspectID)
if initialState != nil {
initialState.ApplyMode()
}
if in == "uninspect" || in == "(uninspect)" {
break
}
if len(strings.TrimSpace(in)) == 0 && !raw {
continue
}
text.WriteString(in)
text.WriteRune('\n')
var brokenString bool
match, raw, brokenString = stringParensMatch(text.String())
if !match && !brokenString {
cont = true
} else {
cont = false
outputResult(text.String(), en)
text.Reset()
}
}
return true
}
func specialLambda(e []expression, en *env) expression {
if len(e) < 3 {
return exception("'lambda' expects at least three arguments")
}
b := []expression{symbol("begin")}
b = append(b, e[2:]...)
predicates := make(map[symbol]symbol)
switch a := e[1].(type) {
case []expression:
for i, v := range a {
s := String(v, false)
ind := strings.LastIndex(s, "@")
if ind < 1 {
continue
}
a[i] = symbol(s[:ind])
predicates[a[i].(symbol)] = symbol(s[ind+1:])
}
e[1] = a
default:
s := String(e[1], false)
ind := strings.LastIndex(s, "@")
if ind < 1 {
e[1] = []expression{e[1]}
break
}
e[1] = symbol(s[:ind])
predicates[e[1].(symbol)] = symbol(s[ind+1:])
e[1] = []expression{e[1]}
}
return proc{e[1], stringUnescapeEval(b), en, predicates}
}
func specialLoad(e []expression, en *env) expression {
if en.outer != nil {
return exception("'load' is only callable from the global/top-level")
}
files := make([]expression, 0, len(e)-1)
for _, fp := range e[1:] {
var p string
if _, ok := fp.([]expression); ok {
p = String(eval(fp, en), false)
} else {
p = String(fp, false)
}
files = append(files, p)
}
loadFiles(files)
return true
}
func specialLoadMod(e []expression, en *env) expression {
if len(e) < 2 {
return exception("'load-mod' expected a module name, no value was given")
}
fullLoadEnv := env{make(map[symbol]expression), &globalenv}
modName := e[1]
var p string
if _, ok := modName.([]expression); ok {
p = String(eval(modName, en), false)
} else {
p = String(modName, false)
}
modEnv, err := RunModule(p, false)
if err != nil {
return exception(fmt.Sprintf("'load-mod' failed loading module %s: %s", p, err.Error()))
}
for k, v := range modEnv.vars {
fullLoadEnv.vars[k] = v
}
altName := ""
if len(e) > 2 {
if _, ok := modName.([]expression); ok {
altName = String(eval(e[2], en), false)
} else {
altName = String(e[2], false)
}
}
namespaces[p] = fullLoadEnv
if altName != "" {
altnamespaces[altName] = p
}
return true
}
func specialLoadModFile(e []expression, en *env) expression {
fullLoadEnv := env{make(map[symbol]expression), &globalenv}
for _, fp := range e[1:] {
var p string
if _, ok := fp.([]expression); ok {
p = String(eval(fp, en), false)
} else {
p = String(fp, false)
}
modEnv, err := RunModule(p, true)
if err != nil {
return exception(fmt.Sprintf("'load-mod-file' failed loading module %s: %s", p, err.Error()))
}
for k, v := range modEnv.vars {
fullLoadEnv.vars[k] = v
}
}
for k, v := range fullLoadEnv.vars {
globalenv.vars[k] = v
}
return true
}
func specialMacro(e []expression, en *env) expression {
if len(e) < 3 {
return exception("'macro' expects at least three arguments")
}
b := []expression{symbol("begin")}
b = append(b, e[2:]...)
return macro{e[1], b, en}
}
func specialOr(e []expression, en *env) expression {
if len(e) < 2 {
return exception("Invalid 'or' syntax - too few arguments")
}
var value expression
OuterOr:
for i := range e[1:] {
switch item := e[i+1].(type) {
case []expression:
value = eval(item, en)
if AnythingToBool(value).(bool) {
break OuterOr
}
default:
value = eval(item, en)
if AnythingToBool(value).(bool) {
break OuterOr
}
}
}
return value
}
func specialQuote(e []expression) expression {
if len(e) < 2 {
return exception("Invalid 'quote' syntax - too few arguments")
}
return stringUnescapeEval(e[1])
}
func specialSet(e []expression, en *env) expression {
if len(e) < 3 {
return exception("Invalid 'set!' syntax - too few arguments")
}
v, ok := e[1].(symbol)
if !ok {
e[1] = eval(e[1], en)
v, ok = e[1].(symbol)
if !ok {
return exception("'set!' expected a symbol as its first argument, a non-symbol was provided")
}
}
if strings.Contains(string(v), "::") {
return exception("'set!' cannot modify a symbol reference within a module, designated by '::' within a symbol name")
}
val := eval(e[2], en)
ex, err := en.Find(v)
if err != nil {
return exception(err.Error())
}
ex.vars[v] = val
return val
}
func specialUsage(e []expression) expression {
var procSigRE = regexp.MustCompile(`(?s)(\()([^() ]+\b)([^)]*)(\))(?:(\s*=>)([^\n]*))?(.*)`)
var replacer = "\033[40;33;1m$1\033[95m$2\033[92m$3\033[33m$4\033[94m$5\033[36m$6\033[0m$7"
if len(e) < 2 {
// XXX - Branch for viewing list of all std procs
var out strings.Builder
header := "(usage [[procedure: symbol]])\n\n\033[1;4mKnown Symbols\033[0m\n\n"
out.WriteString(procSigRE.ReplaceAllString(header, replacer))
keys := make([]string, 0, len(usageStrings))
for key, _ := range usageStrings {
keys = append(keys, key)
}
var width int = 60
if globalenv.vars[symbol("slope-interactive?")] != false {
width, _ = termios.GetWindowSize()
}
printedWidth := 0
sort.Strings(keys)
for i := range keys {
if printedWidth+26 >= width {
out.WriteRune('\n')
printedWidth = 0
}
out.WriteString(fmt.Sprintf("%-26s", keys[i]))
printedWidth += 26
}
if len(namespaces) > 0 {
out.WriteString("\n\n\033[1;4mKnown Modules\033[0m\n\n")
taken := make(map[string]bool)
for k, v := range altnamespaces {
out.WriteString(fmt.Sprintf("%-12s -> %s\n", v, k))
taken[v] = true
}
for k := range namespaces {
if _, ok := taken[string(k)]; !ok {
out.WriteString(string(k))
out.WriteRune('\n')
}
}
}
SysoutPrint(out.String(), Sysout)
return make([]expression, 0)
} else if len(e) == 2 {
proc, ok := e[1].(string)
if !ok {
p, ok2 := e[1].(symbol)
if !ok2 {
return exception("'usage' expected a string or symbol as its first argument, a non-string non-symbol value was given")
}
proc = string(p)
}
if strings.HasSuffix(proc, "::") {
// XXX - Print list of module procedures
ns := proc[:len(proc)-2]
module := ns
altName, ok := altnamespaces[ns]
if ok {
module = altName
}
useMap, err := GetUsageMap(module)
if err != nil {
return exception("'usage' encountered an error: " + err.Error())
}
SysoutPrint(fmt.Sprintf("\033[1;4m%s's Known Symbols\033[0m\n\n", ns), Sysout)
for k := range useMap {
SysoutPrint(fmt.Sprintf("%v\n", k), Sysout)
}
} else if strings.Contains(proc, "::") {
// XXX - Show info for a module symbol
pair := strings.SplitN(proc, "::", 2)
if len(pair) != 2 {
return exception("'usage' was given an invalid module/symbol format")
}
ns := pair[0]
module := ns
altName, ok := altnamespaces[ns]
if ok {
module = altName
}
useMap, err := GetUsageMap(module)
if err != nil {
return exception("'usage' encountered an error: " + err.Error())
}
subFunc, ok := useMap[pair[1]]
if !ok {
return exception("'usage' could not find the requested symbol within the " + ns + "module's usage data")
}
SysoutPrint(fmt.Sprintf("%v\n", procSigRE.ReplaceAllString(subFunc, replacer)), Sysout)
} else {
// XXX - Show info for a builtin
v, ok := usageStrings[proc]
if !ok {
SysoutPrint(fmt.Sprintf("%q does not have a usage definition\n", proc), Sysout)
} else {
SysoutPrint(fmt.Sprintf("%v\n\n", procSigRE.ReplaceAllString(v, replacer)), Sysout)
}
}
}
return make([]expression, 0)
}