From 1f2770033469bf005484df27d3bc8f8e822efa50 Mon Sep 17 00:00:00 2001
From: Helmut Merz <helmutm@cy55.de>
Date: Sat, 29 Jul 2023 14:15:03 +0200
Subject: [PATCH] mimic Def and Const using core definitions

---
 forge/builtins/builtins.go | 12 ++++++++++--
 forge/forge.go             | 38 +++++++++++++++++++++++++++-----------
 tests/forge_test.go        | 18 ++++++++++++++++--
 3 files changed, 53 insertions(+), 15 deletions(-)

diff --git a/forge/builtins/builtins.go b/forge/builtins/builtins.go
index 3825282..ae29bb1 100644
--- a/forge/builtins/builtins.go
+++ b/forge/builtins/builtins.go
@@ -6,7 +6,7 @@ type FE = forge.FE
 type XT = forge.XT
 
 type builtins struct {
-	Add, Dup, Get, Lit, Mult, Put XT
+	Add, Comp, Dup, Get, Here, Lit, Mult, New, Put, Reg XT
 }
 
 func Get(f FE) *builtins {
@@ -24,12 +24,20 @@ func setup(f FE) *builtins {
 	r := func(name string, fct forge.Callable) XT {
 		return forge.Register(voc, forge.GoFunc(name, fct))
 	}
-	return &builtins{
+	b := builtins{
 		Add:  r("+", func(f FE, _ XT) { f.Push(f.Pop().(int) + f.Pop().(int)) }),
+		Comp: r("comp", func(f FE, _ XT) { f.Compile(f.Pop()) }),
 		Dup:  r("dup", func(f FE, _ XT) { f.Push(f.Peek(0)) }),
 		Get:  r("@", func(f FE, _ XT) { f.Push(f.Pop().(forge.FPtr).Value()) }),
+		Here: r("here", func(f FE, _ XT) { f.Push(f.Here()) }),
 		Lit:  r("literal", func(f FE, _ XT) { f.Literal() }),
 		Mult: r("*", func(f FE, _ XT) { f.Push(f.Pop().(int) * f.Pop().(int)) }),
+		New:  r("new", func(f FE, _ XT) { f.New() }),
 		Put:  r("!", func(f FE, _ XT) { f.Pop().(forge.FPtr).Set(f.Pop()) }),
+		Reg: r("reg", func(f FE, _ XT) {
+			f.Push(forge.Register(voc,
+				forge.FCode(f.Pop().(string), f.Pop().(forge.FPtr))))
+		}),
 	}
+	return &b
 }
diff --git a/forge/forge.go b/forge/forge.go
index ba77198..250e2b0 100644
--- a/forge/forge.go
+++ b/forge/forge.go
@@ -62,6 +62,11 @@ func (n name) Name() string {
 	return string(n)
 }
 
+func Register(voc *fvoc, it XT) XT {
+	voc.Register(it.Name(), it)
+	return it
+}
+
 // gofunc: XT consisting only of a function written in Go
 
 type gofunc struct {
@@ -97,7 +102,7 @@ func FCode(n string, c fptr) XT {
 }
 
 func (it *fcode) Fct() Callable {
-	return doDef
+	return doFCode
 }
 
 func (it *fcode) Code() fptr {
@@ -132,12 +137,6 @@ func (it *data) Data() fptr {
 	return it.data
 }
 
-// func Register(voc *fvoc, n string, fct Callable) *xitem {
-func Register(voc *fvoc, it XT) XT {
-	voc.Register(it.Name(), it)
-	return it
-}
-
 // forgeEnv methods
 
 func (f *forgeEnv) Code(items ...fitem) fptr {
@@ -160,6 +159,12 @@ func (f *forgeEnv) Exec(items ...fitem) {
 	f.Call(f.Code(items...))
 }
 
+func (f *forgeEnv) Literal() {
+	f.Push(f.ip.Next().Value())
+}
+
+// definition methods, may become obsolete
+
 func (f *forgeEnv) Def(name string, items ...fitem) XT {
 	code := f.Code(items...)
 	return Register(f.voc, FCode(name, code))
@@ -167,11 +172,22 @@ func (f *forgeEnv) Def(name string, items ...fitem) XT {
 
 func (f *forgeEnv) Create(name string, value fitem, code fptr) XT {
 	data := newScalar().Set(value)
+	//return Register(f.voc, FCode(name, f.Code(b.Lit, data, code))
 	return Register(f.voc, Data(name, data, code))
 }
 
-func (f *forgeEnv) Literal() {
-	f.Push(f.ip.Next().Value())
+// core methods
+
+func (f *forgeEnv) New() {
+	f.cp = newPtr()
+}
+
+func (f *forgeEnv) Compile(it fitem) {
+	f.cp.Append(it)
+}
+
+func (f *forgeEnv) Here() fptr {
+	return f.cp.Clone()
 }
 
 func (f *forgeEnv) Voc() *fvoc {
@@ -192,8 +208,8 @@ func (f *forgeEnv) Peek(d int) fitem {
 
 // basic functions for executable items
 
-func doDef(f *forgeEnv, xt XT) {
-	f.Call(xt.Code().(fptr))
+func doFCode(f *forgeEnv, xt XT) {
+	f.Call(xt.Code())
 }
 
 func doData(f *forgeEnv, xt XT) {
diff --git a/tests/forge_test.go b/tests/forge_test.go
index 0039ce6..4f5ae64 100644
--- a/tests/forge_test.go
+++ b/tests/forge_test.go
@@ -8,14 +8,16 @@ import (
 	"git.sr.ht/~cco/go-scopes/forge/builtins"
 )
 
+var fe = forge.NewFE()
+var b = builtins.Get(fe)
+
 func TestForge(tb *tbase.T) {
 	t := testing.SetUp(tb)
 	t.Run("exec", ExecTest)
+	t.Run("core", CoreTest)
 }
 
 func ExecTest(t *testing.T) {
-	fe := forge.NewFE()
-	b := builtins.Get(fe)
 	c1 := fe.Code(b.Lit, 4, b.Lit, 2, b.Add)
 	fe.Call(c1)
 	t.AssertEqual(fe.Pop(), 6)
@@ -27,3 +29,15 @@ func ExecTest(t *testing.T) {
 	fe.Exec(b.Lit, 3, seven, sq, b.Add)
 	t.AssertEqual(fe.Pop(), 52)
 }
+
+func CoreTest(t *testing.T) {
+	//sq := fe.Def("square", b.Dup, b.Mult)
+	fe.Exec(b.New, b.Here)
+	fe.Exec(b.Lit, b.Dup, b.Comp, b.Lit, b.Mult, b.Comp, b.Lit, "square", b.Reg)
+	sq := fe.Pop()
+	fe.Exec(b.New, b.Here)
+	fe.Exec(b.Lit, b.Lit, b.Comp, b.Lit, 7, b.Comp, b.Lit, "x", b.Reg)
+	seven := fe.Pop()
+	fe.Exec(b.Lit, 3, seven, sq, b.Add)
+	t.AssertEqual(fe.Pop(), 52)
+}