diff --git a/env/env.go b/env/env.go index 646fcf82..3d57c4b3 100755 --- a/env/env.go +++ b/env/env.go @@ -370,6 +370,10 @@ func (ps *ProgramState) Dump() string { return ps.Ctx.DumpBare(*ps.Idx) } +func (ps *ProgramState) ResetStack() { + ps.Stack = NewEyrStack() +} + func AddToProgramState(ps *ProgramState, ser TSeries, idx *Idxs) *ProgramState { ps.Ser = ser ps.Res = nil @@ -466,7 +470,7 @@ func (s *EyrStack) Push(es *ProgramState, x Object) { //// *s = append(*s, x) if s.I+1 >= STACK_SIZE { es.ErrorFlag = true - es.Res = NewError("stack overflow") + es.Res = NewError("stack overflow (maxed)") return } s.D[s.I] = x @@ -478,10 +482,26 @@ func (s *EyrStack) Push(es *ProgramState, x Object) { func (s *EyrStack) Pop(es *ProgramState) Object { if s.IsEmpty() { es.ErrorFlag = true - es.Res = NewError("stack underflow") + es.Res = NewError("stack underflow (empty)") return es.Res } s.I-- x := s.D[s.I] return x } + +// Pop removes and returns the top element of stack. +func (s *EyrStack) Peek(es *ProgramState, offset int) Object { + if s.IsEmpty() { + es.ErrorFlag = true + es.Res = NewError("stack underflow (empty 2)") + return es.Res + } + if s.I-offset < 0 { + es.ErrorFlag = true + es.Res = NewError("stack underflow (offset)") + return es.Res + } + x := s.D[s.I-offset] + return x +} diff --git a/env/object.go b/env/object.go index 22ad4d60..15239b3d 100644 --- a/env/object.go +++ b/env/object.go @@ -1138,6 +1138,11 @@ func (i Comma) Dump(e Idxs) string { type Void struct{} +func NewVoid() *Void { + o := Void{} + return &o +} + func (i Void) Type() Type { return VoidType } diff --git a/evaldo/builtins.go b/evaldo/builtins.go index d2b9c75a..d1e8fa14 100644 --- a/evaldo/builtins.go +++ b/evaldo/builtins.go @@ -1111,6 +1111,15 @@ var builtins = map[string]*env.Builtin{ }, }, + "_.": { // *** + Argsn: 1, + Doc: "Accepts argument and returns void, meant to be used as drop in Eyr, void is not a valid runtime value.", + Pure: true, + Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { + return *env.NewVoid() + }, + }, + "_+": { // ** Argsn: 2, Doc: "Adds or joins two values together (Integers, Strings, Uri-s and Blocks)", @@ -2364,12 +2373,7 @@ var builtins = map[string]*env.Builtin{ case env.Block: ser := ps.Ser ps.Ser = bloc.Series - switch ps.Dialect { - case env.Rye2Dialect: - EvalBlock(ps) - case env.EyrDialect: - Eyr_EvalBlock(ps, ps.Stack, false) - } + EvalBlock(ps) ps.Ser = ser return ps.Res default: diff --git a/evaldo/builtins_eyr.go b/evaldo/builtins_eyr.go index 8e9f90a6..2d1a7afe 100755 --- a/evaldo/builtins_eyr.go +++ b/evaldo/builtins_eyr.go @@ -2,6 +2,11 @@ package evaldo import ( + // "fmt" + + "fmt" + "slices" + "github.com/refaktor/rye/env" ) @@ -11,7 +16,34 @@ import ( // while loop pogleda naslednji arg, če je literal nastavi arg in poveča argc če je argc nargs potem pokliče frame in iz stacka potegne naslednjega, če ni potem zalopa // če je builtin potem pusha trenuten frame na stack in kreira novega -func Eyr_CallBuiltin(bi env.Builtin, ps *env.ProgramState, arg0_ env.Object, toLeft bool, stack *env.EyrStack) *env.ProgramState { +func Eyr_CallBuiltinPipe(bi env.Builtin, ps *env.ProgramState, arg0_ env.Object) *env.ProgramState { + //arg0 := bi.Cur0 //env.Object(bi.Cur0) + //var arg1 env.Object // := bi.Cur1 + //var arg2 env.Object + + // for now works just with functions that accept block as a first and only argument ... will have to conceptualize other options first + + if bi.Argsn > 0 && bi.Cur0 == nil { + if checkFlagsBi(bi, ps, 0) { + return ps + } + if ps.ErrorFlag || ps.ReturnFlag { + return ps + } + if ps.ErrorFlag { + return ps + } + block := stackToBlock(ps.Stack, true) + if bi.Argsn == 1 { + // fmt.Println("** CALL BI") + ps.Res = bi.Fn(ps, block, nil, nil, nil, nil) + // stack.Push(ps.Res) + } + } + return ps +} + +func Eyr_CallBuiltin(bi env.Builtin, ps *env.ProgramState, arg0_ env.Object, toLeft bool) *env.ProgramState { arg0 := bi.Cur0 //env.Object(bi.Cur0) var arg1 env.Object // := bi.Cur1 var arg2 env.Object @@ -23,11 +55,12 @@ func Eyr_CallBuiltin(bi env.Builtin, ps *env.ProgramState, arg0_ env.Object, toL if ps.ErrorFlag || ps.ReturnFlag { return ps } - arg0 = stack.Pop(ps) + arg0 = ps.Stack.Pop(ps) if ps.ErrorFlag { return ps } if bi.Argsn == 1 { + // fmt.Println("** CALL BI") ps.Res = bi.Fn(ps, arg0, nil, nil, nil, nil) // stack.Push(ps.Res) } @@ -40,7 +73,7 @@ func Eyr_CallBuiltin(bi env.Builtin, ps *env.ProgramState, arg0_ env.Object, toL return ps } - arg1 = stack.Pop(ps) + arg1 = ps.Stack.Pop(ps) if ps.ErrorFlag { return ps } @@ -57,7 +90,7 @@ func Eyr_CallBuiltin(bi env.Builtin, ps *env.ProgramState, arg0_ env.Object, toL return ps } - arg2 = stack.Pop(ps) + arg2 = ps.Stack.Pop(ps) if ps.ErrorFlag { return ps } @@ -70,7 +103,7 @@ func Eyr_CallBuiltin(bi env.Builtin, ps *env.ProgramState, arg0_ env.Object, toL } // This is separate from CallFuncitonArgsN so it can manage pulling args directly off of the eyr stack -func Eyr_CallFunction(fn env.Function, es *env.ProgramState, leftVal env.Object, toLeft bool, session *env.RyeCtx, stack *env.EyrStack) *env.ProgramState { +func Eyr_CallFunction(fn env.Function, es *env.ProgramState, leftVal env.Object, toLeft bool, session *env.RyeCtx) *env.ProgramState { var fnCtx = DetermineContext(fn, es, session) if checkErrorReturnFlag(es) { return es @@ -78,7 +111,7 @@ func Eyr_CallFunction(fn env.Function, es *env.ProgramState, leftVal env.Object, var arg0 env.Object = nil for i := fn.Argsn - 1; i >= 0; i-- { - var stackElem = stack.Pop(es) + var stackElem = es.Stack.Pop(es) // TODO: Consider doing check once outside of loop once this version is ready as a correctness comparison point if es.ErrorFlag { return es @@ -89,34 +122,46 @@ func Eyr_CallFunction(fn env.Function, es *env.ProgramState, leftVal env.Object, fnCtx.Set(fn.Spec.Series.Get(i).(env.Word).Index, stackElem) } + tempCtx := es.Ctx + tempSer := es.Ser + + fn.Body.Series.Reset() + + es.Ctx = fnCtx + es.Ser = fn.Body.Series // setup - psX := env.NewProgramState(fn.Body.Series, es.Idx) + /* psX := env.NewProgramState(fn.Body.Series, es.Idx) psX.Ctx = fnCtx psX.PCtx = es.PCtx psX.Gen = es.Gen psX.Dialect = es.Dialect + psX.Stack = es.Stack - var result *env.ProgramState + var result *env.ProgramState */ // es.Ser.SetPos(0) + // fmt.Println("***") if fn.Argsn > 0 { - result = EvalBlockInjMultiDialect(psX, arg0, arg0 != nil) + EvalBlock(es) + // EvalBlockInjMultiDialect(es, arg0, arg0 != nil) } else { - result = EvalBlock(psX) + EvalBlock(es) } - MaybeDisplayFailureOrError(result, result.Idx) + // MaybeDisplayFailureOrError(result, result.Idx) - if result.ForcedResult != nil { + /* if result.ForcedResult != nil { es.Res = result.ForcedResult result.ForcedResult = nil } else { es.Res = result.Res } - es.Stack.Push(es, es.Res) + es.Stack.Push(es, es.Res) */ + es.Ser = tempSer + es.Ctx = tempCtx es.ReturnFlag = false return es } -func Eyr_EvalObject(es *env.ProgramState, object env.Object, leftVal env.Object, toLeft bool, session *env.RyeCtx, stack *env.EyrStack, bakein bool) *env.ProgramState { +func Eyr_EvalObject(es *env.ProgramState, object env.Object, leftVal env.Object, pipeWord bool, session *env.RyeCtx, bakein bool) *env.ProgramState { //fmt.Print("EVAL OBJECT") switch object.Type() { case env.BuiltinType: @@ -127,36 +172,44 @@ func Eyr_EvalObject(es *env.ProgramState, object env.Object, leftVal env.Object, if checkFlagsBi(bu, es, 333) { return es } - return Eyr_CallBuiltin(bu, es, leftVal, toLeft, stack) + if pipeWord { + es = Eyr_CallBuiltinPipe(bu, es, leftVal) + } else { + es = Eyr_CallBuiltin(bu, es, leftVal, false) + } + if es.Res != nil && es.Res.Type() != env.VoidType { + es.Stack.Push(es, es.Res) + } + return es case env.FunctionType: fn := object.(env.Function) - return Eyr_CallFunction(fn, es, leftVal, toLeft, session, stack) - + return Eyr_CallFunction(fn, es, leftVal, pipeWord, session) default: es.Res = object + es.Stack.Push(es, es.Res) return es } } -func Eyr_EvalWord(es *env.ProgramState, word env.Object, leftVal env.Object, toLeft bool, stack *env.EyrStack) *env.ProgramState { +func Eyr_EvalWord(es *env.ProgramState, word env.Object, leftVal env.Object, pipeWord bool) *env.ProgramState { // LOCAL FIRST found, object, ctx := findWordValue(es, word) if found { - es = Eyr_EvalObject(es, object, leftVal, toLeft, ctx, stack, true) //ww0128a * - stack.Push(es, es.Res) + es = Eyr_EvalObject(es, object, leftVal, pipeWord, ctx, true) //ww0128a * + // es.Stack.Push(es, ¸.Res) return es } else { es.ErrorFlag = true if !es.FailureFlag { - es.Res = *env.NewError2(5, "Word not found: "+word.Inspect(*es.Idx)) + es.Res = env.NewError2(5, "Word not found: "+word.Inspect(*es.Idx)) } return es } } -func Eyr_EvalLSetword(ps *env.ProgramState, word env.LSetword, leftVal env.Object, toLeft bool, stack *env.EyrStack) *env.ProgramState { +func Eyr_EvalLSetword(ps *env.ProgramState, word env.LSetword, leftVal env.Object, toLeft bool) *env.ProgramState { idx := word.Index - val := stack.Pop(ps) + val := ps.Stack.Pop(ps) if ps.ErrorFlag { return ps } @@ -164,71 +217,119 @@ func Eyr_EvalLSetword(ps *env.ProgramState, word env.LSetword, leftVal env.Objec return ps } -func Eyr_EvalExpression(es *env.ProgramState, stack *env.EyrStack) *env.ProgramState { - object := es.Ser.Pop() +func Eyr_EvalExpression(ps *env.ProgramState) *env.ProgramState { + object := ps.Ser.Pop() trace2("Before entering expression") if object != nil { switch object.Type() { case env.IntegerType: - stack.Push(es, object) + // fmt.Println("** INTEGER") + ps.Stack.Push(ps, object) case env.DecimalType: - stack.Push(es, object) + ps.Stack.Push(ps, object) case env.StringType: - stack.Push(es, object) + ps.Stack.Push(ps, object) case env.BlockType: - stack.Push(es, object) + ps.Stack.Push(ps, object) case env.UriType: - stack.Push(es, object) + ps.Stack.Push(ps, object) case env.EmailType: - stack.Push(es, object) + ps.Stack.Push(ps, object) case env.WordType: - rr := Eyr_EvalWord(es, object.(env.Word), nil, false, stack) + // fmt.Println("** WORD") + rr := Eyr_EvalWord(ps, object.(env.Word), nil, false) return rr case env.OpwordType: // + and other operators are basically opwords too - rr := Eyr_EvalWord(es, object.(env.Opword), nil, false, stack) + // fmt.Println("** OPWORD") + rr := Eyr_EvalWord(ps, object.(env.Opword), nil, false) + return rr + case env.PipewordType: // + and other operators are basically opwords too + // fmt.Println("** OPWORD") + rr := Eyr_EvalWord(ps, object.(env.Pipeword), nil, true) return rr case env.CPathType: - rr := Eyr_EvalWord(es, object.(env.CPath), nil, false, stack) + rr := Eyr_EvalWord(ps, object.(env.CPath), nil, false) return rr case env.LSetwordType: - print(stack) - rr := Eyr_EvalLSetword(es, object.(env.LSetword), nil, false, stack) + // print(stack) + rr := Eyr_EvalLSetword(ps, object.(env.LSetword), nil, false) return rr case env.BuiltinType: - return Eyr_EvalObject(es, object, nil, false, nil, stack, false) //ww0128a * + // fmt.Println("** BUILTIN") + return Eyr_EvalObject(ps, object, nil, false, nil, false) //ww0128a * default: - es.ErrorFlag = true - es.Res = env.NewError("Not known type for Eyr") + ps.ErrorFlag = true + ps.Res = env.NewError("Not known type for Eyr") } } else { - es.ErrorFlag = true - es.Res = env.NewError("Not known type (nil)") + ps.ErrorFlag = true + ps.Res = env.NewError("Not known type (nil)") } - return es + return ps } -func Eyr_EvalBlock(ps *env.ProgramState, stack *env.EyrStack, full bool) *env.ProgramState { +func Eyr_EvalBlockInside(ps *env.ProgramState) *env.ProgramState { + // fmt.Println("** EVALB INSIDE") for ps.Ser.Pos() < ps.Ser.Len() { - ps = Eyr_EvalExpression(ps, stack) + // fmt.Println(ps.Ser.Pos()) + ps = Eyr_EvalExpression(ps) if checkFlagsAfterBlock(ps, 101) { + // fmt.Println("yy") return ps } if ps.ReturnFlag || ps.ErrorFlag { + /* fmt.Println(ps.ReturnFlag) + fmt.Println(ps.ErrorFlag) + fmt.Println("xx") */ return ps } } - if stack.I > 1 && full { - ps.Res = *env.NewBlock(*env.NewTSeries(stack.D[0:stack.I])) - } else if stack.I == 1 || (!full && !stack.IsEmpty()) { - ps.Res = stack.Pop(ps) - } else if stack.IsEmpty() { - ps.Res = env.Void{} - } + // fmt.Println("** EVAL BLOCK PS RES") + // fmt.Println(ps.Res) + ps.Res = env.NewVoid() + return ps +} +func Eyr_EvalBlock(ps *env.ProgramState, full bool) *env.ProgramState { + // fmt.Println("** EVALB") + for ps.Ser.Pos() < ps.Ser.Len() { + // fmt.Println(ps.Ser.Pos()) + ps = Eyr_EvalExpression(ps) + if checkFlagsAfterBlock(ps, 101) { + // fmt.Println("yy") + return ps + } + if ps.ReturnFlag || ps.ErrorFlag { + /* fmt.Println(ps.ReturnFlag) + fmt.Println(ps.ErrorFlag) + fmt.Println("xx") */ + return ps + } + } + if full { + ps.Res = stackToBlock(ps.Stack, false) + } else { + ps.Res = ps.Stack.Peek(ps, 0) + } + // fmt.Println("** EVAL BLOCK PS RES") + // fmt.Println(ps.Res) return ps } +func stackToBlock(stack *env.EyrStack, reverse bool) env.Block { + real := stack.D[0:stack.I] + cpy := make([]env.Object, stack.I) + copy(cpy, real) + fmt.Println(real) + if reverse { + fmt.Println("REVE") + slices.Reverse(cpy) + } + fmt.Println(cpy) + return *env.NewBlock(*env.NewTSeries(cpy)) +} + var Builtins_eyr = map[string]*env.Builtin{ "eyr": { @@ -237,11 +338,10 @@ var Builtins_eyr = map[string]*env.Builtin{ Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch bloc := arg0.(type) { case env.Block: - stack := env.NewEyrStack() ser := ps.Ser ps.Ser = bloc.Series ps.Dialect = env.EyrDialect - Eyr_EvalBlock(ps, stack, false) + Eyr_EvalBlock(ps, false) ps.Ser = ser return ps.Res default: @@ -256,11 +356,10 @@ var Builtins_eyr = map[string]*env.Builtin{ Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch bloc := arg0.(type) { case env.Block: - stack := env.NewEyrStack() ser := ps.Ser ps.Ser = bloc.Series ps.Dialect = env.EyrDialect - Eyr_EvalBlock(ps, stack, true) + Eyr_EvalBlock(ps, true) ps.Ser = ser return ps.Res default: @@ -280,9 +379,8 @@ var Builtins_eyr = map[string]*env.Builtin{ ps.Dialect = env.EyrDialect ser := ps.Ser ps.Ser = bloc.Series - stack := env.NewEyrStack() for i := 0; int64(i) < cond.Value; i++ { - ps = Eyr_EvalBlock(ps, stack, false) + ps = Eyr_EvalBlock(ps, false) ps.Ser.Reset() } ps.Ser = ser diff --git a/evaldo/builtins_math.go b/evaldo/builtins_math.go index dd8b8f06..96dcf805 100644 --- a/evaldo/builtins_math.go +++ b/evaldo/builtins_math.go @@ -796,6 +796,22 @@ var Builtins_math = map[string]*env.Builtin{ return *env.NewDecimal(float64(math.Pi)) }, }, + "deg->rad": { + Argsn: 1, + Doc: "Convert degrees to radians.", + Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { + var fa float64 + switch a := arg0.(type) { + case env.Decimal: + fa = a.Value + case env.Integer: + fa = float64(a.Value) + default: + return MakeArgError(ps, 1, []env.Type{env.IntegerType, env.DecimalType}, "deg->rad") + } + return *env.NewDecimal(fa * float64(math.Pi) / 180.0) + }, + }, "is-near": { Argsn: 2, Doc: "Returns true if two decimals are close.", @@ -848,10 +864,11 @@ var Builtins_math = map[string]*env.Builtin{ res := DialectMath(ps, arg0) switch block := res.(type) { case env.Block: - stack := env.NewEyrStack() // TODO -- stack moved to PS ... look it up if it requires changes here + // stack := env.NewEyrStack() // TODO -- stack moved to PS ... look it up if it requires changes here + ps.ResetStack() ser := ps.Ser ps.Ser = block.Series - Eyr_EvalBlock(ps, stack, false) + Eyr_EvalBlock(ps, false) ps.Ser = ser return ps.Res default: diff --git a/evaldo/evaldo.go b/evaldo/evaldo.go index e9346688..d5985491 100644 --- a/evaldo/evaldo.go +++ b/evaldo/evaldo.go @@ -49,7 +49,7 @@ func NewProgramState(ser env.TSeries, idx env.Idxs) *ProgramState { func EvalBlock(ps *env.ProgramState) *env.ProgramState { switch ps.Dialect { case env.EyrDialect: - return Eyr_EvalBlock(ps, ps.Stack, false) // TODO ps.Stack is already in ps ... refactor + return Eyr_EvalBlockInside(ps) // TODO ps.Stack is already in ps ... refactor default: return EvalBlockInj(ps, nil, false) } @@ -76,7 +76,7 @@ func EvalBlockInCtxInj(ps *env.ProgramState, ctx *env.RyeCtx, inj env.Object, in func EvalBlockInjMultiDialect(ps *env.ProgramState, inj env.Object, injnow bool) *env.ProgramState { // TODO temp name -- refactor switch ps.Dialect { case env.EyrDialect: - return Eyr_EvalBlock(ps, ps.Stack, false) // TODO ps.Stack is already in ps ... refactor + return Eyr_EvalBlockInside(ps) // TODO ps.Stack is already in ps ... refactor default: return EvalBlockInj(ps, inj, injnow) } @@ -427,6 +427,9 @@ func findWordValue(ps *env.ProgramState, word1 env.Object) (bool, env.Object, *e case env.Opword: object, found := ps.Ctx.Get(word.Index) return found, object, nil + case env.Pipeword: + object, found := ps.Ctx.Get(word.Index) + return found, object, nil case env.CPath: currCtx := ps.Ctx i := 1 diff --git a/evaldo/repl.go b/evaldo/repl.go index c2d10d5a..f500c13c 100644 --- a/evaldo/repl.go +++ b/evaldo/repl.go @@ -208,7 +208,7 @@ func (r *Repl) evalLine(es *env.ProgramState, code string) string { EvalBlockInj(es, r.prevResult, true) } else if r.dialect == "eyr" { es.Dialect = env.EyrDialect - Eyr_EvalBlock(es, r.stack, true) + Eyr_EvalBlock(es, true) } else if r.dialect == "math" { idxx, _ := es.Idx.GetIndex("math") s1, ok := es.Ctx.Get(idxx) @@ -222,10 +222,11 @@ func (r *Repl) evalLine(es *env.ProgramState, code string) string { res := DialectMath(es, block1) switch block := res.(type) { case env.Block: - stack := env.NewEyrStack() + //stack := env.NewEyrStack() + es.ResetStack() ser := es.Ser es.Ser = block.Series - Eyr_EvalBlock(es, stack, false) + Eyr_EvalBlock(es, false) es.Ser = ser } } diff --git a/loader/loader.go b/loader/loader.go index 72f61aa0..89b9df61 100644 --- a/loader/loader.go +++ b/loader/loader.go @@ -448,7 +448,7 @@ func newParser() *Parser { // TODO -- add string eaddress path url time LSETWORD <- ":" LETTER LETTERORNUM* LMODWORD <- "::" LETTER LETTERORNUM* GETWORD <- "?" LETTER LETTERORNUM* - PIPEWORD <- "\\" LETTER LETTERORNUM* / "|" LETTER LETTERORNUM* / PIPEARROWS / "|" NORMOPWORDS + PIPEWORD <- "/" LETTER LETTERORNUM* / "|" LETTER LETTERORNUM* / PIPEARROWS / "|" NORMOPWORDS ONECHARPIPE <- "|" ONECHARWORDS OPWORD <- "." LETTER LETTERORNUM* / "." NORMOPWORDS / OPARROWS / ONECHARWORDS / "[*" LETTERORNUM* TAGWORD <- "'" LETTER LETTERORNUM*