diff --git a/ast/eval.go b/ast/eval.go index e82a89b..cbbae5d 100644 --- a/ast/eval.go +++ b/ast/eval.go @@ -17,7 +17,9 @@ package ast -import "gitlab.com/whom/shs/log" +import ( + "gitlab.com/whom/shs/log" +) /* determines whether or not to execute a system binary * when a function cannot be found in the functable diff --git a/ast/func_table.go b/ast/func_table.go index 734f9ee..81e006b 100644 --- a/ast/func_table.go +++ b/ast/func_table.go @@ -18,7 +18,6 @@ package ast import ( - "fmt" "gitlab.com/whom/shs/log" ) @@ -38,8 +37,18 @@ type Function struct { // number of times user has called this function TimesCalled int - // number of args required - Args int + // list of types (LIST, NUMBER, STRING, etc) representing args + Args []Token_t + NumArgs int // -1 means infinite + + // lazy arg checking (use NumArgs instead of args) + ArgLazy bool + + // dont fail on undefined symbol (passed to eval when parsing args) + SymLazy bool + + // dont eval args at all, leave that to the function + EvalLazy bool } /* holds a mapping of key to function @@ -52,24 +61,58 @@ type FuncTable *map[string]*Function * makes sure correct arguments are passed in */ func (f Function) ParseFunction(args *Token) bool { - // handle infinite args - if f.Args < 0 { + inc := 0 + for iter := args; iter != nil; iter = iter.Next { + inc += 1 + if inc > len(f.Args) { + log.Log(log.ERR, + "too many arguments", + "ftable") + return false + } + + if iter.Tag != f.Args[inc - 1] { + log.Log(log.ERR, + "argument is " + GetTagAsStr(iter.Tag) + + " should be " + GetTagAsStr(f.Args[inc - 1]), + "ftable") + return false + } + } + + if inc < len(f.Args) { + log.Log(log.ERR, + "not enough args given", + "ftable") + return false + } + + return true +} + +/* same as ParseFunction but only evaluates the number of args + */ +func (f Function) LazyParseFunction(args *Token) bool { + if f.NumArgs < 0 { return true } - i := f.Args + total := 0 for iter := args; iter != nil; iter = iter.Next { - i -= 1 + total += 1 } - if i != 0 { + if total < f.NumArgs { log.Log(log.ERR, - "Incorrect number of arguments", - "eval") - log.Log(log.DEBUG, - fmt.Sprintf("Function %s expects %d arguments. You've provided %d arguments.", - f.Name, f.Args, f.Args - i), - "eval") + "expected more arguments, try calling info on function", + "ftable") + return false + } + + if total > f.NumArgs { + log.Log(log.ERR, + "too many args. try calling info on function", + "ftable") return false } @@ -80,7 +123,19 @@ func (f Function) ParseFunction(args *Token) bool { * calls ParseFunction and increments TimesCalled */ func (f Function) CallFunction(args *Token, vt VarTable, ft FuncTable) *Token { - if !f.ParseFunction(args) { + n_args := args + if !f.EvalLazy { + n_args = args.Eval(ft, vt, f.SymLazy) + } + + passes := false + if f.ArgLazy { + passes = f.LazyParseFunction(n_args) + } else { + passes = f.ParseFunction(n_args) + } + + if !passes { log.Log(log.ERR, "Couldnt call " + f.Name, "eval") @@ -88,7 +143,7 @@ func (f Function) CallFunction(args *Token, vt VarTable, ft FuncTable) *Token { } f.TimesCalled += 1 - return f.Function(args, vt, ft) + return f.Function(n_args, vt, ft) } /* searches for function mapped to argument in FuncTable diff --git a/ast/lex.go b/ast/lex.go index 3031cab..7c33bac 100644 --- a/ast/lex.go +++ b/ast/lex.go @@ -162,14 +162,22 @@ func lex(input string) *Token { // comment case case ';': + i = matchLineEnd(i) start_pos = i + 1 - i = matchLineEnd(start_pos) + + // this isnt to handle string escaping + // its only to make sure that escaped spaces stay in + // the same token. + case '\\': + if i != len(input) - 1 && input[i+1] == ' '{ + // eat the backslash + input = input[:i] + input[i+1:] + } } if needs_alloc { needs_alloc = false if (i < 0) { - // TODO: Maybe not overload this. start_pos = i goto error } @@ -186,8 +194,6 @@ func lex(input string) *Token { return ret error: - // TODO: Hook into error module - // TODO: Finalize and GC alloced tokens if start_pos == -1 { log.Log(log.ERR, "Unmatched string delimiter in input. discarding.", @@ -209,6 +215,11 @@ error: func StrIsNumber(arg string) bool { dotCount := 0 + // negative nums + if len(arg) > 1 && arg[0] == '-' { + arg = arg[1:] + } + for _, char := range arg { if !unicode.IsDigit(char) { if char == '.' && dotCount == 0 { diff --git a/cmd/shs.go b/cmd/shs.go index 82fbf8d..bad550c 100644 --- a/cmd/shs.go +++ b/cmd/shs.go @@ -95,7 +95,7 @@ func main() { } dyn_prompt := ast.GetFunction("_SH_PROMPT", funcs) - if dyn_prompt == nil || dyn_prompt.Args != 0 { + if dyn_prompt == nil || dyn_prompt.NumArgs != 0 { dyn_prompt = nil } @@ -149,6 +149,11 @@ func main() { fmt.Printf(prePrompt) text, err := line.Prompt(prompt) if err != nil && err != liner.ErrPromptAborted{ + // must be a better way to do this check + if err.Error() == "EOF" { + return + } + log.Log(log.ERR, "couldnt read user input: " + err.Error(), "repl") continue } diff --git a/stdlib/arith.go b/stdlib/arith.go index d516551..fb1e6d6 100644 --- a/stdlib/arith.go +++ b/stdlib/arith.go @@ -36,14 +36,6 @@ import ( * Example: (number "3.4") */ func NumCast(in *ast.Token, a ast.VarTable, f ast.FuncTable) *ast.Token { - in = in.Eval(f, a, false) - if in.Tag != ast.STRING { - log.Log(log.ERR, - "only a string can successfully be cast to a number", - "number_cast") - return nil - } - if !ast.StrIsNumber(in.Value()) { log.Log(log.ERR, "string failed number cast", @@ -64,9 +56,6 @@ func NumCast(in *ast.Token, a ast.VarTable, f ast.FuncTable) *ast.Token { */ func Add(in *ast.Token, a ast.VarTable, f ast.FuncTable) *ast.Token { var res float64 - - in = in.Eval(f, a, false) - for i := in; i != nil; i = i.Next { if i.Tag != ast.NUMBER { log.Log(log.ERR, "Non-number given to ADD", "add") @@ -112,9 +101,6 @@ func Add(in *ast.Token, a ast.VarTable, f ast.FuncTable) *ast.Token { func Sub(in *ast.Token, a ast.VarTable, f ast.FuncTable) *ast.Token { var res float64 var sub float64 - - in = in.Eval(f, a, false) - for i := in; i != nil; i = i.Next { if i.Tag != ast.NUMBER { log.Log(log.ERR, "Non-number given to SUB", "sub") @@ -166,9 +152,6 @@ func Sub(in *ast.Token, a ast.VarTable, f ast.FuncTable) *ast.Token { */ func Mult(in *ast.Token, a ast.VarTable, f ast.FuncTable) *ast.Token { res := 1.0 - - in = in.Eval(f, a, false) - for i := in; i != nil; i = i.Next { if i.Tag != ast.NUMBER { log.Log(log.ERR, "Non-number given to MULT", "mult") @@ -214,9 +197,6 @@ func Mult(in *ast.Token, a ast.VarTable, f ast.FuncTable) *ast.Token { */ func Div(in *ast.Token, a ast.VarTable, f ast.FuncTable) *ast.Token { var res float64 - - in = in.Eval(f, a, false) - for i := in; i != nil; i = i.Next { inner := 0.0 diff --git a/stdlib/bool.go b/stdlib/bool.go index d6b07e6..833de51 100644 --- a/stdlib/bool.go +++ b/stdlib/bool.go @@ -30,14 +30,6 @@ import ( * Example: (bool "F") */ func BoolCast(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token { - in = in.Eval(ft, vt, false) - if in.Tag == ast.LIST || in.Tag == ast.NUMBER { - log.Log(log.ERR, - "only strings successfully cast to bool", - "bool cast") - return nil - } - body := in.Value() if body != ast.TRUE && body != ast.FALSE { log.Log(log.ERR, @@ -52,13 +44,6 @@ func BoolCast(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token { } func Not(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token { - in = in.Eval(ft, vt, false) - - if in.Tag != ast.BOOL { - log.Log(log.ERR, "non-bool argument to 'not'", "not") - return nil - } - out := ast.TRUE if in.Value() == ast.TRUE { out = ast.FALSE @@ -69,10 +54,9 @@ func Not(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token { return t } +// Lazy args this func Eq(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token { out := ast.TRUE - - in = in.Eval(ft, vt, false) second := in.Next if in.Tag != second.Tag { @@ -155,13 +139,6 @@ func Lt(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token { out := ast.TRUE second := in.Next - in = in.Eval(ft, vt, false) - - if in.Tag != ast.NUMBER || second.Tag != ast.NUMBER { - log.Log(log.ERR, "non-number argument to numeric boolean operator", ">/<=") - return nil - } - l, _ := strconv.ParseInt(in.Value(), 10, 64) r, _ := strconv.ParseInt(second.Value(), 10, 64) @@ -178,13 +155,6 @@ func Gt(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token { out := ast.TRUE second := in.Next - in = in.Eval(ft, vt, false) - - if in.Tag != ast.NUMBER || second.Tag != ast.NUMBER { - log.Log(log.ERR, "non-number argument to numeric boolean operator", ">/<=") - return nil - } - l, _ := strconv.ParseInt(in.Value(), 10, 64) r, _ := strconv.ParseInt(second.Value(), 10, 64) diff --git a/stdlib/filesys.go b/stdlib/filesys.go index 182cdca..861a4a7 100644 --- a/stdlib/filesys.go +++ b/stdlib/filesys.go @@ -54,20 +54,6 @@ func AbsPath(arg string) string { * (cd (concat HOME "/go")) */ func Cd(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token { - in = in.Eval(ft, vt, true) - - if in == nil { - log.Log(log.ERR, - "arguments to cd evaluated to nil!", - "cd") - return nil - } - - if in.Tag == ast.LIST { - log.Log(log.ERR, "Couldnt change dir to a list", "cd") - return nil - } - err := os.Chdir(in.Value()) if err != nil { log.Log(log.ERR, err.Error(), "cd") @@ -84,14 +70,6 @@ func Cd(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token { * (fexists test) */ func Fexists(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token { - in = in.Eval(ft, vt, false) - if in == nil || in.Tag != ast.STRING { - log.Log(log.ERR, - "argument to fexists must be a string", - "fexists") - return nil - } - filename := in.Value() out := ast.TRUE @@ -115,7 +93,6 @@ func Fexists(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token { * (fread (concat HOME ".shsrc")) */ func Fread(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token { - in = in.Eval(ft, vt, false) exists := Fexists(in, vt, ft) // some waste, extra use of Eval if exists == nil || exists.Tag != ast.BOOL || exists.Value() == ast.FALSE { log.Log(log.ERR, @@ -146,26 +123,12 @@ func Fread(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token { * (fwrite "test" "one two three") */ func Fwrite(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token { - in = in.Eval(ft, vt, false) - if in == nil || in.Tag == ast.SYMBOL || in.Tag == ast.LIST { - log.Log(log.ERR, - "first argument must be a filename", - "fwrite") - return nil - } - text := in.Next - if text == nil || text.Tag == ast.SYMBOL || text.Tag == ast.LIST { - log.Log(log.ERR, - "second argument must be stringable", - "fwrite") - return nil - } - err := ioutil.WriteFile( AbsPath(in.Value()), []byte(text.Value()), 0644) + if err != nil { log.Log(log.ERR, "error writing file: " + err.Error(), @@ -183,22 +146,7 @@ func Fwrite(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token { * (fwrite "test" "one two three") */ func Fappend(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token { - in = in.Eval(ft, vt, false) - if in == nil || in.Tag == ast.SYMBOL || in.Tag == ast.LIST { - log.Log(log.ERR, - "first argument must be a filename", - "fappend") - return nil - } - text := in.Next - if text == nil || text.Tag == ast.SYMBOL || text.Tag == ast.LIST { - log.Log(log.ERR, - "second argument must be stringable", - "fappend") - return nil - } - exists := Fexists(in, vt, ft) if exists.Value() == ast.FALSE { log.Log(log.ERR, @@ -212,14 +160,15 @@ func Fappend(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token { AbsPath(in.Value()), os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644) + if err != nil { log.Log(log.ERR, "couldnt open file for append: " + err.Error(), "fappend") return nil } - defer f.Close() + defer f.Close() if _, err := f.WriteString(text.Value()); err != nil { log.Log(log.ERR, "error appending to file: " + err.Error(), diff --git a/stdlib/funcs.go b/stdlib/funcs.go index 63f3130..2e39599 100644 --- a/stdlib/funcs.go +++ b/stdlib/funcs.go @@ -113,7 +113,8 @@ func DeclFunc(input *ast.Token, vars ast.VarTable, funcs ast.FuncTable) *ast.Tok Function: inner, Name: name.Value(), TimesCalled: 0, - Args: numArgs, + NumArgs: numArgs, + ArgLazy: true, } return nil } diff --git a/stdlib/list.go b/stdlib/list.go index 748414b..5e34364 100644 --- a/stdlib/list.go +++ b/stdlib/list.go @@ -18,6 +18,8 @@ package stdlib import ( + "fmt" + "strconv" "gitlab.com/whom/shs/ast" "gitlab.com/whom/shs/log" ) @@ -28,12 +30,7 @@ import ( * in event a not-list is passed in, returns the arg. */ func Expand(input *ast.Token, vars ast.VarTable, funcs ast.FuncTable) *ast.Token { - if input.Tag != ast.LIST { - log.Log(log.INFO, "expand called on not a list", "expand") - return input - } - - return input.Eval(funcs, vars, false).Expand() + return input.Expand() } /* L_APPEND (append from repl) @@ -68,3 +65,187 @@ func L_append(input *ast.Token, vars ast.VarTable, funcs ast.FuncTable) *ast.Tok return src } + +/* Len + * Returns length of list or string as a number + * Returns nil if not a list or string + * + * Example: () -> 0 + * Example: (1 2 3) -> 3 + */ +func Len(input *ast.Token, vars ast.VarTable, funcs ast.FuncTable) *ast.Token { + if input.Tag != ast.LIST && input.Tag != ast.STRING { + log.Log(log.ERR, + "must provide list or strinig", + "head") + return nil + } + + length := 0 + if input.Tag == ast.STRING { + length = len(input.Value()) + + } else { + for iter := input.Expand(); iter != nil; iter = iter.Next { + length += 1 + } + } + + ret := &ast.Token{Tag: ast.NUMBER} + ret.Set(fmt.Sprintf("%d", length)) + return ret +} + +/* Takes two arguments + * An index and a list + * Returns element indexed by index arg + * can return nil if index is out of bounds + * + * Example (index 2 (1 2 3)) -> 2 + */ +func Index(in *ast.Token, vars ast.VarTable, funcs ast.FuncTable) *ast.Token { + idx, err := strconv.ParseInt(in.Value(), 10, 64) + if err != nil || idx < 0 { + log.Log(log.ERR, + "index must be a positive integer: " + err.Error(), + "index") + return nil + } + + series := in.Next.Expand() + iter := &series + i := int64(0) + for i <= idx { + if *iter == nil { + log.Log(log.ERR, + "index out of bounds", + "index") + return nil + } + + if i < idx { + iter = &((*iter).Next) + } + + i += 1 + } + + ret := (*iter).Copy() + ret.Next = nil + return ret +} + +/* Head + * Returns first element in the list + * Returns nil if input is not a list or if list is empty + * + * Example: (head (2 3 4)) -> 2 + */ +func Head(input *ast.Token, vars ast.VarTable, funcs ast.FuncTable) *ast.Token { + li := input.Expand().Copy() + if li != nil { + li.Next = nil + } + + return li +} + +/* Tail + * Returns last element in a list + * Returns nil if not a list + * + * Example: (tail (2 3 4)) -> 4 + */ +func Tail(input *ast.Token, vars ast.VarTable, funcs ast.FuncTable) *ast.Token { + iter := input.Expand() + for iter != nil && iter.Next != nil { + iter = iter.Next + } + + return iter.Copy() +} + +/* Slice + * Takes 3 args and returns a list + * Arg 1: starting index of sublist + * Arg 2: end index of sublist + * Arg 3: source list + * returns sublist, or nil if non list applied, or nil if start or end arent INTEGERS + * first index in a list is 0 + * + * Example: (slice 1 2 (1 2 3)) -> (2 3) + * Example: (slice 0 0 (1 2 3)) -> (1) + */ +func Slice(input *ast.Token, vars ast.VarTable, funcs ast.FuncTable) *ast.Token { + start := input + end := input.Next + source := end.Next + + st, err := strconv.ParseInt(start.Value(), 10, 64) + en, errr := strconv.ParseInt(end.Value(), 10, 64) + + if err != nil { + log.Log(log.ERR, + "couldnt parse integer from start value: " + err.Error(), + "slice") + return nil + } + + if errr != nil { + log.Log(log.ERR, + "couldnt parse integer from end value: " + errr.Error(), + "slice") + return nil + } + + if st < 0 || en < 0 { + log.Log(log.ERR, + "both indices must be positive", + "slice") + return nil + } + + if st > en { + log.Log(log.ERR, + "end index must be greater than start index", + "slice") + return nil + } + + en = en - st + var inner *ast.Token + buildIter := &inner + sourceIter := source.Expand() + + for st > 0 { + if sourceIter == nil { + log.Log(log.ERR, + "start index out of bounds", + "slice") + return nil + } + + sourceIter = sourceIter.Next + st -= 1 + } + + for en >= 0 { + if sourceIter == nil { + log.Log(log.ERR, + "end index out of bounds", + "slice") + return nil + } + + *buildIter = sourceIter.Copy() + (*buildIter).Next = nil + + buildIter = &((*buildIter).Next) + sourceIter = sourceIter.Next + en -= 1 + } + + ret := &ast.Token{Tag: ast.LIST} + ret.Direct(inner) + return ret +} diff --git a/stdlib/shell.go b/stdlib/shell.go index e67a4bd..823bff3 100644 --- a/stdlib/shell.go +++ b/stdlib/shell.go @@ -225,8 +225,8 @@ func LaunchProcess( * Example (l vim file.txt) */ func Call(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token { - in = in.Eval(ft, vt, true) if in == nil { + log.Log(log.ERR, "no arguments given", "call") return nil } @@ -261,11 +261,6 @@ func Call(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token { * Example: (bg vim file.txt) */ func Bgcall(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token { - in = in.Eval(ft, vt, true) - if in == nil { - return nil - } - if in.Tag == ast.LIST { log.Log(log.ERR, "couldnt exec, target bin is a list", "call") return nil @@ -304,14 +299,6 @@ func Fg(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token { return nil } - in = in.Eval(ft, vt, false) - if in.Tag != ast.NUMBER && in.Tag != ast.STRING { - log.Log(log.ERR, - "must supply a number or string to fg", - "fg") - return nil - } - pid, err := strconv.ParseFloat(in.Value(), 64) if err != nil { log.Log(log.ERR, @@ -374,12 +361,6 @@ func Jobs(in *ast.Token, vt ast.VarTable, fg ast.FuncTable) *ast.Token { * Example: ($ echo hello world) */ func ReadCmd(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token { - in = in.Eval(ft, vt, true) - - if in == nil { - return nil - } - if in.Tag == ast.LIST { log.Log(log.ERR, "couldnt exec, target bin is a list", "call") return nil @@ -434,13 +415,6 @@ func GetExit(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token { * (this function not added to functable in stdlib.go) */ func Kill(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token { - in = in.Eval(ft, vt, true) - - if in.Tag == ast.LIST { - log.Log(log.ERR, "non-number argument to kill function", "kill") - return nil - } - pid, err := strconv.ParseInt(in.Value(), 10, 64) if err != nil { log.Log(log.ERR, "error parsing arg to kill: " + err.Error(), "kill") diff --git a/stdlib/stdlib.go b/stdlib/stdlib.go index 292b7da..7781a96 100644 --- a/stdlib/stdlib.go +++ b/stdlib/stdlib.go @@ -20,7 +20,6 @@ package stdlib import ( "os" "fmt" - "gitlab.com/whom/shs/log" "gitlab.com/whom/shs/ast" "gitlab.com/whom/shs/util" ) @@ -32,227 +31,334 @@ func GenFuncTable() ast.FuncTable { var stdlib ast.FuncTable stdlib = &map[string]*ast.Function{ "if": &ast.Function{ - Function: ShsIf, + Function: ShsIf, Name: "if", - TimesCalled: 0, - Args: 3, + NumArgs: 3, + EvalLazy: true, + ArgLazy: true, }, "while": &ast.Function{ - Function: ShsWhile, + Function: ShsWhile, Name: "while", - TimesCalled: 0, - Args: -1, + NumArgs: -1, + EvalLazy: true, + ArgLazy: true, }, "progn": &ast.Function{ Function: ShsProgn, - Name: "shs_progn", - TimesCalled: 0, - Args: -1, + Name: "shs_progn", + NumArgs: -1, + EvalLazy: true, + ArgLazy: true, }, "func": &ast.Function{ - Function: DeclFunc, - Name: "decl_func", - TimesCalled: 0, - Args: 3, + Function: DeclFunc, + Name: "decl_func", + Args: []ast.Token_t{ + ast.SYMBOL, + ast.LIST, + ast.LIST, + }, + EvalLazy: true, + }, + + "len": &ast.Function{ + Function: Len, + Name: "len", + NumArgs: 1, + ArgLazy: true, + }, + + "index": &ast.Function{ + Function: Index, + Name: "index", + Args: []ast.Token_t{ + ast.NUMBER, + ast.LIST, + }, + }, + + "head": &ast.Function{ + Function: Head, + Name: "head", + Args: []ast.Token_t{ + ast.LIST, + }, + }, + + "tail": &ast.Function{ + Function: Tail, + Name: "tail", + Args: []ast.Token_t{ + ast.LIST, + }, + }, + + "slice": &ast.Function{ + Function: Slice, + Name: "slice", + Args: []ast.Token_t{ + ast.NUMBER, + ast.NUMBER, + ast.LIST, + }, }, "export": &ast.Function{ - Function: Export, - Name: "export", - TimesCalled: 0, - Args: 2, + Function: Export, + Name: "export", + EvalLazy: true, + ArgLazy: true, + NumArgs: 2, }, "input": &ast.Function{ - Function: Input, - Name: "input", - TimesCalled: 0, - Args: 1, + Function: Input, + Name: "input", + Args: []ast.Token_t{ + ast.STRING, + }, }, "load": &ast.Function{ - Function: Load, - Name: "load", - TimesCalled: 0, - Args: 1, + Function: Load, + Name: "load", + Args: []ast.Token_t{ + ast.STRING, + }, }, "bool": &ast.Function{ - Function: BoolCast, - Name: "bool", - TimesCalled: 0, - Args: 1, + Function: BoolCast, + Name: "bool", + Args: []ast.Token_t{ + ast.STRING, + }, }, "string": &ast.Function{ - Function: StrCast, - Name: "string", - TimesCalled: 0, - Args: 1, + Function: StrCast, + Name: "string", + NumArgs: 1, + ArgLazy: true, }, "number": &ast.Function{ - Function: NumCast, - Name: "number", - TimesCalled: 0, - Args: 1, + Function: NumCast, + Name: "number", + Args: []ast.Token_t{ + ast.STRING, + }, }, - "...": &ast.Function{ - Function: Expand, - Name: "...", - TimesCalled: 0, - Args: 1, + "...": &ast.Function{ + Function: Expand, + Name: "...", + Args: []ast.Token_t{ + ast.LIST, + }, }, "append": &ast.Function{ - Function: L_append, - Name: "append", - TimesCalled: 0, - Args: -1, + Function: L_append, + Name: "append", + NumArgs: -1, + ArgLazy: true, + }, + + "join": &ast.Function{ + Function: Join, + Name: "join", + Args: []ast.Token_t{ + ast.STRING, + ast.LIST, + }, + }, + + "split": &ast.Function{ + Function: Split, + Name: "split", + Args: []ast.Token_t{ + ast.STRING, + ast.STRING, + }, + }, + + "replace": &ast.Function{ + Function: Replace, + Name: "replace", + Args: []ast.Token_t{ + ast.STRING, + ast.STRING, + ast.STRING, + }, + }, + + "substr": &ast.Function{ + Function: Substr, + Name: "substr", + Args: []ast.Token_t{ + ast.NUMBER, + ast.NUMBER, + ast.STRING, + }, }, "exit": &ast.Function{ - Function: ExitShell, - Name: "exit", - TimesCalled: 0, - Args: 0, + Function: ExitShell, + Name: "exit", + Args: []ast.Token_t{}, }, "eq": &ast.Function{ - Function: Eq, - Name: "==", - TimesCalled: 0, - Args: 2, + Function: Eq, + Name: "==", + NumArgs: 2, + ArgLazy: true, }, "ne": &ast.Function{ - Function: Ne, - Name: "!=", - TimesCalled: 0, - Args: 2, + Function: Ne, + Name: "!=", + NumArgs: 2, + ArgLazy: true, }, "<": &ast.Function{ - Function: Lt, - Name: "<", - TimesCalled: 0, - Args: 2, + Function: Lt, + Name: "<", + Args: []ast.Token_t{ + ast.NUMBER, + ast.NUMBER, + }, }, ">": &ast.Function{ - Function: Gt, - Name: ">", - TimesCalled: 0, - Args: 2, + Function: Gt, + Name: ">", + Args: []ast.Token_t{ + ast.NUMBER, + ast.NUMBER, + }, }, "<=": &ast.Function{ - Function: Lte, - Name: "<=", - TimesCalled: 0, - Args: 2, + Function: Lte, + Name: "<=", + Args: []ast.Token_t{ + ast.NUMBER, + ast.NUMBER, + }, }, ">=": &ast.Function{ - Function: Gte, - Name: ">=", - TimesCalled: 0, - Args: 2, + Function: Gte, + Name: ">=", + Args: []ast.Token_t{ + ast.NUMBER, + ast.NUMBER, + }, }, "!": &ast.Function{ - Function: Not, - Name: "!", - TimesCalled: 0, - Args: 1, + Function: Not, + Name: "!", + Args: []ast.Token_t{ + ast.BOOL, + }, }, "+": &ast.Function{ - Function: Add, - Name: "add", - TimesCalled: 0, - Args: -1, + Function: Add, + Name: "add", + NumArgs: -1, + ArgLazy: true, }, "-": &ast.Function{ - Function: Sub, - Name: "sub", - TimesCalled: 0, - Args: -1, + Function: Sub, + Name: "sub", + NumArgs: -1, + ArgLazy: true, }, "*": &ast.Function{ - Function: Mult, + Function: Mult, Name: "mult", - TimesCalled: 0, - Args: -1, + NumArgs: -1, + ArgLazy: true, }, "/": &ast.Function{ - Function: Div, - Name: "div", - TimesCalled: 0, - Args: -1, + Function: Div, + Name: "div", + NumArgs: -1, + ArgLazy: true, }, "cd": &ast.Function{ - Function: Cd, - Name: "changedir", - TimesCalled: 0, - Args: 1, + Function: Cd, + Name: "changedir", + SymLazy: true, + Args: []ast.Token_t{ + ast.STRING, + }, }, "concat": &ast.Function{ Function: Concat, - Name:"concatenate", - TimesCalled: 0, - Args: -1, + Name: "concatenate", + NumArgs: -1, + ArgLazy: true, }, "print": &ast.Function{ - Function: PrintStr, - Name: "print", - TimesCalled: 0, - Args: 1, + Function: PrintStr, + Name: "print", + Args: []ast.Token_t{ + ast.STRING, + }, }, "l": &ast.Function{ - Function: Call, + Function: Call, Name: "call", - TimesCalled: 0, - Args: -1, + NumArgs: -1, + ArgLazy: true, + SymLazy: true, }, "bg": &ast.Function{ - Function: Bgcall, - Name: "background call", - TimesCalled: 0, - Args: -1, + Function: Bgcall, + Name: "background call", + NumArgs: -1, + ArgLazy: true, + SymLazy: true, }, "fg": &ast.Function{ - Function: Fg, - Name: "foreground", - TimesCalled: 0, - Args: 1, + Function: Fg, + Name: "foreground", + Args: []ast.Token_t{ + ast.NUMBER, + }, }, "$": &ast.Function{ - Function: ReadCmd, - Name: "read cmd", - TimesCalled: 0, - Args: -1, + Function: ReadCmd, + Name: "read cmd", + NumArgs: -1, + ArgLazy: true, + SymLazy: true, }, "?": &ast.Function{ - Function: GetExit, - Name:"get exit code", - TimesCalled: 0, - Args: 0, + Function: GetExit, + Name: "get exit code", + Args: []ast.Token_t{}, }, /* @@ -260,51 +366,56 @@ func GenFuncTable() ast.FuncTable { "kill": &ast.Function{ Function: kill, Name: "kill job", - TimesCalled: 0, Args: 1, }, */ "jobs": &ast.Function{ - Function: Jobs, - Name: "list jobs", - TimesCalled: 0, - Args: 0, + Function: Jobs, + Name: "list jobs", + Args: []ast.Token_t{}, }, "info": &ast.Function{ - Function: ShInfo, - Name: "Shell Info", - TimesCalled: 0, - Args: 1, + Function: ShInfo, + Name: "Shell Info", + Args: []ast.Token_t{ + ast.SYMBOL, + }, }, "fexists": &ast.Function{ - Function: Fexists, - Name: "file exists", - TimesCalled: 0, - Args: 1, + Function: Fexists, + Name: "file exists", + Args: []ast.Token_t{ + ast.STRING, + }, }, "fread": &ast.Function{ - Function: Fread, - Name: "read file", - TimesCalled: 0, - Args: 1, + Function: Fread, + Name: "read file", + Args: []ast.Token_t{ + ast.STRING, + }, }, "fwrite": &ast.Function{ - Function: Fwrite, - Name: "write file", - TimesCalled: 0, - Args: 2, + Function: Fwrite, + Name: "write file", + Args: []ast.Token_t{ + ast.STRING, + ast.STRING, + }, }, "fappend": &ast.Function{ - Function: Fappend, - Name:"append to file", - TimesCalled: 0, - Args: 2, + Function: Fappend, + Name: "append to file", + Args: []ast.Token_t{ + ast.STRING, + ast.STRING, + }, }, } @@ -327,32 +438,32 @@ func ExitShell(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token { * Example: (info append) */ func ShInfo(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token { - switch in.Tag { - case ast.BOOL: - fmt.Printf("BOOL LITERAL\nValue: %s\n", in.Value()) - case ast.STRING: - fmt.Printf("STRING LITERAL \nValue: %s\n", in.Value()) - case ast.NUMBER: - fmt.Printf("NUMBER LITERAL \nValue: %s\n", in.Value()) - case ast.LIST: - fmt.Printf("LIST \nString Value: %s, AST:\n", in.String()) - ast.PrintSExprsIndividually(in) - case ast.SYMBOL: - repr := ast.GetVar(in.Value(), vt) - if repr != nil { - fmt.Printf("VARIABLE\nTYPE: %s\nVALUE: %s\n", ast.GetTagAsStr(repr.Tag), repr.Value()) - break - } - - funct := ast.GetFunction(in.Value(), ft) - if funct != nil { - fmt.Printf("FUNCTION\nNAME: %s\nTIMES CALLED: %s\nNUM ARGS: %d\n", funct.Name, funct.TimesCalled, funct.Args) - break - } - - fmt.Printf("UNKNOWN SYMBOL\n") + repr := ast.GetVar(in.Value(), vt) + if repr != nil { + fmt.Printf("VARIABLE\nTYPE: %s\nVALUE: %s\n", ast.GetTagAsStr(repr.Tag), repr.Value()) + return nil } + funct := ast.GetFunction(in.Value(), ft) + if funct != nil { + fmt.Printf("FUNCTION\nNAME: %s\nTIMES CALLED: %s\n\n", funct.Name, funct.TimesCalled) + if funct.ArgLazy { + fmt.Printf("function does not evaluate args by type\nARG COUNT: %s\n", funct.NumArgs) + } else { + fmt.Printf("function evaluates args by type\nARGS: ") + for _, i := range(funct.Args) { + fmt.Printf(ast.GetTagAsStr(i)) + } + } + + fmt.Printf("SYMLAZY: %t\n", funct.SymLazy) + fmt.Printf("(can undefined symbols be passed in)\n") + fmt.Printf("EVALLAZY: %t\n", funct.EvalLazy) + fmt.Printf("(are all forms in evaluated before function call)\n") + return nil + } + + fmt.Printf("UNKNOWN SYMBOL\n") return nil } @@ -364,14 +475,6 @@ func ShInfo(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token { * Example: (print (input)) */ func Input(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token { - in = in.Eval(ft, vt, false) - if in.Tag != ast.STRING && in.Tag != ast.NUMBER { - log.Log(log.ERR, - "argument to input must be a string or number", - "input") - return nil - } - prompt := in.Value() var output string @@ -389,14 +492,6 @@ func Input(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token { * Example: (load "myscript.shs") */ func Load(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token { - in = in.Eval(ft, vt, true) - if in.Tag != ast.STRING { - log.Log(log.ERR, - "argument to load must be a string", - "load") - return nil - } - bp := in.Value() bp = AbsPath(bp) util.LoadScript(bp, vt, ft) diff --git a/stdlib/string.go b/stdlib/string.go index 3cae616..b3d7a72 100644 --- a/stdlib/string.go +++ b/stdlib/string.go @@ -19,6 +19,7 @@ package stdlib import ( "fmt" + "strings" "strconv" "gitlab.com/whom/shs/ast" "gitlab.com/whom/shs/log" @@ -29,8 +30,6 @@ import ( * Example: (concat "hello" " " "world") */ func Concat(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token { - in = in.Eval(ft, vt, false) - var res string for i := in; i != nil; i = i.Next { if i.Tag == ast.LIST { @@ -53,12 +52,148 @@ func Concat(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token { * Example: (string 1) -> 1.0 */ func StrCast(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token { - body := in.Eval(ft, vt, false).String() + body := in.String() res := &ast.Token{ Tag: ast.STRING } res.Set(body) return res } +/* Takes 2 arguments, a string and a delimiter + * returns a list of substrings found delimited by the delimiter from the parent string + * Filters out all empty segments between delimiters + * + * Example: (split "/path/to/file" "/") -> ("path" "to" "file") + */ +func Split(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token { + body := in.Value() + delim := in.Next.Value() + + var res *ast.Token + builder := &res + strtoks := strings.Split(body, delim) + for _, i := range strtoks { + if i == "" { + continue + } + + *builder = &ast.Token{Tag: ast.STRING} + (*builder).Set(i) + builder = &(*builder).Next + } + + return res +} + +/* Takes three args + * 1. source string + * 2. token to be replaced + * 3. token to swap in place + * All three args are strings + * Returns final string + */ +func Replace(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token { + body := in.Value() + sub := in.Next.Value() + tok := in.Next.Next.Value() + + body = strings.ReplaceAll(body, sub, tok) + + res := &ast.Token{Tag: ast.STRING} + res.Set(body) + return res +} + +/* Takes two args, a delimiter and a list of strings + * Returns the list of strings concatenated together with the delimiter in between each element + * On error returns nil + * + * Example: (join ", " ("apple" "ananas" "pear")) -> "apple, ananas, pear" + */ +func Join(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token { + delim := in + strs := in.Next + de := delim.Value() + res := "" + + for i := strs.Expand(); i != nil; i = i.Next { + if i.Tag != ast.STRING { + log.Log(log.ERR, + "all items to be joined must be strings", + "join") + return nil + } + + res += i.Value() + if i.Next != nil { + res += de + } + } + + ret := &ast.Token{Tag: ast.STRING} + ret.Set(res) + return ret +} + +/* takes three arguments: + * 1. start index + * 2. end index + * 3. source + * Returns a substring from source delimited by args 1 and 2. + * First two args must be integers (4 or 4.0 but not 4.3) + * + * Example: (substr 1 5 "Linus Torvalds") -> "inus " + */ +func Substr(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token { + start := in + end := start.Next + str := end.Next + + ed_idx := 0 + st_idx, err := strconv.Atoi(start.Value()) + ed_idx, err = strconv.Atoi(end.Value()) + if err != nil { + log.Log(log.ERR, + "error parsing args: " + err.Error(), + "substr") + return nil + } + + strlen := len(str.Value()) + if st_idx < 0 { + st_idx += strlen + } + + if ed_idx < 0 { + ed_idx += strlen + } + + if st_idx < 0 || st_idx >= strlen { + log.Log(log.ERR, + "first index out of bounds", + "substr") + return nil + } + + if ed_idx < 0 || ed_idx >= strlen { + log.Log(log.ERR, + "last index out of bounds", + "substr") + return nil + } + + if st_idx > ed_idx { + log.Log(log.ERR, + "start must be less than end", + "substr") + return nil + } + + res := str.Value()[st_idx:ed_idx] + ret := &ast.Token{Tag: ast.STRING} + ret.Set(res) + return ret +} + /* Takes one arg, returns nil * Prints a string to stdout * Unquotes string so user can add escaped chars like \n, \t, etc @@ -66,7 +201,7 @@ func StrCast(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token { * Example: (print "Line: \n, Tab: \t") */ func PrintStr(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token { - body := in.Eval(ft, vt, false).String() + body := in.String() if body[0] != body[len(body)-1] && body[0] != '"' { body = "`" + body + "`" } diff --git a/stdlib/vars.go b/stdlib/vars.go index 52938f2..3856378 100644 --- a/stdlib/vars.go +++ b/stdlib/vars.go @@ -34,6 +34,12 @@ func Export(input *ast.Token, vars ast.VarTable, funcs ast.FuncTable) *ast.Token name := input form := name.Next.Eval(funcs, vars, false) + + // error in eval process + if form == nil { + return nil + } + if name.Tag != ast.SYMBOL { log.Log(log.ERR, "first arg should be a symbol", diff --git a/util/shell_complete.go b/util/shell_complete.go index 86410d8..197b51b 100644 --- a/util/shell_complete.go +++ b/util/shell_complete.go @@ -80,7 +80,8 @@ func ShellCompleter(line string, vt ast.VarTable, ft ast.FuncTable) []string { completions := []string{} for _, i := range compSource { if strings.HasPrefix(i, tail) { - completions = append(completions, head + i) + str := strings.ReplaceAll(i, " ", "\\ ") + completions = append(completions, head + str) } }