start with new forge implementation (forge/sf)

forge/sf.lisp

@@ -0,0 +1,33 @@
+;;;; cl-scopes/forge - may the forge be with you!
+
+;;;; A Forth-like interpreter implemented in Common Lisp.
+
+(defpackage :scopes/forge/sf
+  (:use :common-lisp)
+  (:local-nicknames (:iter :scopes/util/iter))
+  (:export #:*stack*
+           #:add
+           #:pushd #:popd))
+
+(defpackage :sf-builtin)
+(defpackage :sf-user)
+
+(in-package :scopes/forge/sf)
+
+(defvar *stack* nil)
+
+;;;; builtins
+
+(defun reg2 (sym fn)
+  (setf (fdefinition sym) #'(lambda ()
+    (pushd (funcall fn (popd) (popd))))))
+
+(reg2 'add #'+)
+
+;;;; core definitions
+
+(defun pushd (v)
+  (push v *stack*))
+
+(defun popd ()
+  (pop *stack*))

scopes-core.asd

@@ -14,6 +14,7 @@
                                    "forge/forge" "logging" "util/util"))
                (:file "core/message" :depends-on ("shape/shape"))
                (:file "forge/forge")
+               (:file "forge/sf" :depends-on ("util/iter" "util/util"))
                (:file "logging" :depends-on ("config" "util/util"))
                (:file "shape/shape")
                (:file "util/util")
@@ -27,8 +28,10 @@
   :depends-on (:scopes-core)
   :components ((:file "test/test-config")
                (:file "test/test-core")
-               (:file "test/test-forge"))
+               (:file "test/test-forge")
+               (:file "test/test-sf"))
   :perform (test-op (o c) 
     (symbol-call :scopes/test-config :run)
     (symbol-call :scopes/test-core :run)
-    (symbol-call :scopes/test-forge :run)))
+    (symbol-call :scopes/test-forge :run)
+    (symbol-call :scopes/test-sf :run)))

test/test-sf.lisp

@@ -0,0 +1,33 @@
+;;;; cl-scopes/test/test-forge
+
+;;;; testing facility for scopes/forge
+
+(defpackage :scopes/test-sf
+  (:use :common-lisp)
+  (:local-nicknames (:forge :scopes/forge/sf) 
+                    (:util :scopes/util)
+                    (:t :scopes/testing))
+  (:export #:run)
+  (:import-from :scopes/testing #:deftest #:==))
+
+(in-package :scopes/test-sf)
+
+(defun run ()
+  (let ((t:*test-suite* (t:test-suite "forge/sf")))
+        ;(forge:*forge-env* (forge:forge-env)))
+    ;(setf forge:*forge-env* (forge:forge-env))
+    ;(forge:setup-builtins)
+    (test-exec)))
+ 
+(deftest test-exec ()
+  (util:lgi 42)
+  (== (+ 2 1) 3)
+  (forge:pushd 4)
+  (forge:pushd 2)
+  (forge:add)
+  (== (forge:popd) 6)
+  ;(forge:exec-str "4 2 +")
+  ;(== (car (forge:dstack)) 6))
+  (t:show-result))
+
+

util/iter.lisp

@@ -4,6 +4,10 @@
 ;;;; producing items (objects) like: numbers, strings, symbols, lists, ...
 
 (defpackage :scopes/util/iter
-  (:use :common-lisp))
+  (:use :common-lisp)
+  (:export #:list-iterator))
 
 (in-package :scopes/util/iter)
+
+(defclass list-iterator ()
+  ((data :reader data :initarg :data :initform nil)))