go-vise

Constrained Size Output Virtual Machine
Info | Log | Files | Refs | README | LICENSE

commit 1844415ae94840dbac2065b9e204f3737e093460
parent 46288b240b1d8feaed9dd416800a3a7cb83869e3
Author: lash <dev@holbrook.no>
Date:   Thu, 13 Apr 2023 09:16:17 +0100

Add input to entryfuncs, return flag delta from entryfunc

Diffstat:
Mengine/engine_test.go | 19+++++++++++++------
Mrender/size_test.go | 24++++++++++++++++--------
Mresource/fs.go | 10++++++----
Mresource/resource.go | 8+++++++-
Mresource/resource_test.go | 23++++++++++++++++-------
Mstate/flag.go | 12++++++++++++
Mstate/state.go | 5+++++
Mvm/runner.go | 35++++++++++++++++++++++++++++++++---
Mvm/runner_test.go | 130+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++------
9 files changed, 228 insertions(+), 38 deletions(-)

diff --git a/engine/engine_test.go b/engine/engine_test.go @@ -32,16 +32,23 @@ func NewFsWrapper(path string, st *state.State) FsWrapper { } } -func(fs FsWrapper) one(sym string, input []byte, ctx context.Context) (string, error) { - return "one", nil +func(fs FsWrapper) one(sym string, input []byte, ctx context.Context) (resource.Result, error) { + return resource.Result{ + Content: "one", + }, nil } -func(fs FsWrapper) inky(sym string, input []byte, ctx context.Context) (string, error) { - return "tinkywinky", nil +func(fs FsWrapper) inky(sym string, input []byte, ctx context.Context) (resource.Result, error) { + return resource.Result{ + Content: "tinkywinky", + }, nil } -func(fs FsWrapper) pinky(sym string, input []byte, ctx context.Context) (string, error) { - return fmt.Sprintf("xyzzy: %x", input), nil +func(fs FsWrapper) pinky(sym string, input []byte, ctx context.Context) (resource.Result, error) { + r := fmt.Sprintf("xyzzy: %x", input) + return resource.Result{ + Content: r, + }, nil } func(fs FsWrapper) FuncFor(sym string) (resource.EntryFunc, error) { diff --git a/render/size_test.go b/render/size_test.go @@ -41,20 +41,28 @@ func funcFor(sym string) (resource.EntryFunc, error) { return nil, fmt.Errorf("unknown func: %s", sym) } -func getFoo(sym string, input []byte, ctx context.Context) (string, error) { - return "inky", nil +func getFoo(sym string, input []byte, ctx context.Context) (resource.Result, error) { + return resource.Result{ + Content: "inky", + }, nil } -func getBar(sym string, input []byte, ctx context.Context) (string, error) { - return "pinky", nil +func getBar(sym string, input []byte, ctx context.Context) (resource.Result, error) { + return resource.Result{ + Content: "pinky", + }, nil } -func getBaz(sym string, input []byte, ctx context.Context) (string, error) { - return "blinky", nil +func getBaz(sym string, input []byte, ctx context.Context) (resource.Result, error) { + return resource.Result{ + Content: "blinky", + }, nil } -func getXyzzy(sym string, input []byte, ctx context.Context) (string, error) { - return "inky pinky\nblinky clyde sue\ntinkywinky dipsy\nlala poo\none two three four five six seven\neight nine ten\neleven twelve", nil +func getXyzzy(sym string, input []byte, ctx context.Context) (resource.Result, error) { + return resource.Result{ + Content: "inky pinky\nblinky clyde sue\ntinkywinky dipsy\nlala poo\none two three four five six seven\neight nine ten\neleven twelve", + }, nil } func TestSizeCheck(t *testing.T) { diff --git a/resource/fs.go b/resource/fs.go @@ -55,18 +55,20 @@ func(fs FsResource) String() string { return fmt.Sprintf("fs resource at path: %s", fs.Path) } -func(fs FsResource) getFunc(sym string, input []byte, ctx context.Context) (string, error) { +func(fs FsResource) getFunc(sym string, input []byte, ctx context.Context) (Result, error) { return fs.getFuncNoCtx(sym, input) } -func(fs FsResource) getFuncNoCtx(sym string, input []byte) (string, error) { +func(fs FsResource) getFuncNoCtx(sym string, input []byte) (Result, error) { fb := sym + ".txt" fp := path.Join(fs.Path, fb) log.Printf("getfunc search dir %s %s for %s", fs.Path, fp, sym) r, err := ioutil.ReadFile(fp) if err != nil { - return "", fmt.Errorf("failed getting data for sym '%s': %v", sym, err) + return Result{}, fmt.Errorf("failed getting data for sym '%s': %v", sym, err) } s := string(r) - return strings.TrimSpace(s), nil + return Result{ + Content: strings.TrimSpace(s), + }, nil } diff --git a/resource/resource.go b/resource/resource.go @@ -4,8 +4,14 @@ import ( "context" ) +type Result struct { + Content string + FlagSet []uint32 + FlagReset []uint32 +} + // EntryFunc is a function signature for retrieving value for a key -type EntryFunc func(sym string, input []byte, ctx context.Context) (string, error) +type EntryFunc func(sym string, input []byte, ctx context.Context) (Result, error) type CodeFunc func(sym string) ([]byte, error) type TemplateFunc func(sym string) (string, error) type FuncForFunc func(sym string) (EntryFunc, error) diff --git a/resource/resource_test.go b/resource/resource_test.go @@ -37,18 +37,27 @@ func funcFor(sym string) (EntryFunc, error) { return nil, fmt.Errorf("unknown func: %s", sym) } -func get(sym string, input []byte, ctx context.Context) (string, error) { +func get(sym string, input []byte, ctx context.Context) (Result, error) { switch sym { case "foo": - return "inky", nil + return Result{ + Content: "inky", + }, nil case "bar": - return "pinky", nil + return Result{ + Content: "pinky", + }, nil case "baz": - return "blinky", nil + return Result{ + Content: "blinky", + }, nil } - return "", fmt.Errorf("unknown sym: %s", sym) + return Result{}, fmt.Errorf("unknown sym: %s", sym) } -func getXyzzy(sym string, input []byte, ctx context.Context) (string, error) { - return "inky pinky\nblinky clyde sue\ntinkywinky dipsy\nlala poo\none two three four five six seven\neight nine ten\neleven twelve", nil +func getXyzzy(sym string, input []byte, ctx context.Context) (Result, error) { + r := "inky pinky\nblinky clyde sue\ntinkywinky dipsy\nlala poo\none two three four five six seven\neight nine ten\neleven twelve" + return Result{ + Content: r, + }, nil } diff --git a/state/flag.go b/state/flag.go @@ -5,4 +5,16 @@ const ( FLAG_INMATCH = 2 FLAG_TERMINATE = 3 FLAG_DIRTY = 4 + FLAG_LOADFAIL = 5 + //FLAG_WRITEABLE = FLAG_LOADFAIL ) + +func IsWriteableFlag(flag uint32) bool { + if flag > 7 { + return true + } + //if flag & FLAG_WRITEABLE > 0 { + // return true + //} + return false +} diff --git a/state/state.go b/state/state.go @@ -112,6 +112,11 @@ func(st *State) ResetFlag(bitIndex uint32) (bool, error) { return true, nil } +// ResetBaseFlags restes all builtin flags not writeable by client. +func(st *State) ResetBaseFlags() { + st.Flags[0] = 0 +} + // GetFlag returns the state of the flag at the given bit field index. // // Fails if bit field index is out of range. diff --git a/vm/runner.go b/vm/runner.go @@ -60,6 +60,7 @@ func(vm *Vm) Run(b []byte, ctx context.Context) ([]byte, error) { log.Printf("terminate set! bailing!") return []byte{}, nil } + vm.st.ResetBaseFlags() _, err = vm.st.SetFlag(state.FLAG_DIRTY) if err != nil { panic(err) @@ -179,7 +180,8 @@ func(vm *Vm) RunCatch(b []byte, ctx context.Context) ([]byte, error) { log.Printf("catch at flag %v, moving to %v", sig, sym) //bitField, d) vm.st.Down(sym) vm.Reset() - b = []byte{} + bh := NewLine(nil, HALT, nil, nil, nil) + b = append(bh, b...) } return b, nil } @@ -430,6 +432,33 @@ func(vm *Vm) refresh(key string, rs resource.Resource, ctx context.Context) (str return "", fmt.Errorf("no retrieve function for external symbol %v", key) } input, _ := vm.st.GetInput() - return fn(key, input, ctx) -} + r, err := fn(key, input, ctx) + if err != nil { + var perr error + _, perr = vm.st.SetFlag(state.FLAG_LOADFAIL) + if perr != nil { + panic(err) + } + return "", err + } + for _, flag := range r.FlagSet { + if !state.IsWriteableFlag(flag) { + continue + } + _, err = vm.st.SetFlag(flag) + if err != nil { + panic(err) + } + } + for _, flag := range r.FlagReset { + if !state.IsWriteableFlag(flag) { + continue + } + _, err = vm.st.ResetFlag(flag) + if err != nil { + panic(err) + } + } + return r.Content, err +} diff --git a/vm/runner_test.go b/vm/runner_test.go @@ -20,16 +20,45 @@ type TestResource struct { state *state.State } -func getOne(sym string, input []byte, ctx context.Context) (string, error) { - return "one", nil +func getOne(sym string, input []byte, ctx context.Context) (resource.Result, error) { + return resource.Result{ + Content: "one", + }, nil } -func getTwo(sym string, input []byte, ctx context.Context) (string, error) { - return "two", nil +func getTwo(sym string, input []byte, ctx context.Context) (resource.Result, error) { + return resource.Result{ + Content: "two", + }, nil } -func getDyn(sym string, input []byte, ctx context.Context) (string, error) { - return dynVal, nil +func getDyn(sym string, input []byte, ctx context.Context) (resource.Result, error) { + return resource.Result{ + Content: dynVal, + }, nil +} + +func getEcho(sym string, input []byte, ctx context.Context) (resource.Result, error) { + r := fmt.Sprintf("echo: %s", input) + return resource.Result{ + Content: r, + }, nil +} + +func setFlag(sym string, input []byte, ctx context.Context) (resource.Result, error) { + s := fmt.Sprintf("ping") + r := resource.Result{ + Content: s, + } + if len(input) > 0 { + r.FlagSet = append(r.FlagSet, uint32(input[0])) + } + if len(input) > 1 { + r.FlagReset = append(r.FlagReset, uint32(input[1])) + } + log.Printf("setflag %v", r) + return r, nil + } type TestStatefulResolver struct { @@ -50,6 +79,8 @@ func (r TestResource) GetTemplate(sym string) (string, error) { return "root", nil case "_catch": return "aiee", nil + case "flagCatch": + return "flagiee", nil } panic(fmt.Sprintf("unknown symbol %s", sym)) return "", fmt.Errorf("unknown symbol %s", sym) @@ -65,21 +96,32 @@ func (r TestResource) FuncFor(sym string) (resource.EntryFunc, error) { return getDyn, nil case "arg": return r.getInput, nil + case "echo": + return getEcho, nil + case "setFlagOne": + return setFlag, nil } return nil, fmt.Errorf("invalid function: '%s'", sym) } -func(r TestResource) getInput(sym string, input []byte, ctx context.Context) (string, error) { +func(r TestResource) getInput(sym string, input []byte, ctx context.Context) (resource.Result, error) { v, err := r.state.GetInput() - return string(v), err + return resource.Result{ + Content: string(v), + }, err } func(r TestResource) GetCode(sym string) ([]byte, error) { var b []byte - if sym == "_catch" { + switch sym { + case "_catch": + b = NewLine(b, MOUT, []string{"0", "repent"}, nil, nil) + b = NewLine(b, HALT, nil, nil, nil) + case "flagCatch": b = NewLine(b, MOUT, []string{"0", "repent"}, nil, nil) b = NewLine(b, HALT, nil, nil, nil) } + return b, nil } @@ -409,3 +451,73 @@ func TestRunReturn(t *testing.T) { t.Fatalf("expected location 'root', got '%s'", location) } } + + +func TestRunLoadInput(t *testing.T) { + st := state.NewState(5) + rs := TestResource{} + ca := cache.NewCache() + vm := NewVm(&st, &rs, ca, nil) + + var err error + + st.Down("root") + st.SetInput([]byte("foobar")) + + b := NewLine(nil, LOAD, []string{"echo"}, []byte{0x00}, nil) + b = NewLine(b, HALT, nil, nil, nil) + + ctx := context.TODO() + + b, err = vm.Run(b, ctx) + if err != nil { + t.Fatal(err) + } + + r, err := ca.Get("echo") + if err != nil { + t.Fatal(err) + } + if r != "echo: foobar" { + t.Fatalf("expected 'echo: foobar', got %s", r) + } +} + +func TestInputBranch(t *testing.T) { + st := state.NewState(5) + rs := TestResource{} + ca := cache.NewCache() + vm := NewVm(&st, &rs, ca, nil) + + var err error + + st.Down("root") + + b := NewLine(nil, LOAD, []string{"setFlagOne"}, []byte{0x00}, nil) + b = NewLine(b, CATCH, []string{"flagCatch"}, []byte{8}, []uint8{0}) + b = NewLine(b, RELOAD, []string{"setFlagOne"}, nil, nil) + b = NewLine(b, CATCH, []string{"flagCatch"}, []byte{8}, []uint8{0}) + b = NewLine(b, CATCH, []string{"one"}, []byte{9}, []uint8{0}) + + ctx := context.TODO() + + st.SetInput([]byte{0x08}) + b, err = vm.Run(b, ctx) + if err != nil { + t.Fatal(err) + } + location, _ := st.Where() + if location != "flagCatch" { + t.Fatalf("expected 'flagCatch', got %s", location) + } + + st.SetInput([]byte{0x09, 0x08}) + b, err = vm.Run(b, ctx) + if err != nil { + t.Fatal(err) + } + location, _ = st.Where() + if location != "one" { + t.Fatalf("expected 'one', got %s", location) + } +}