Trying to get cbasic.lisp to compile; WIP

6 files changed, 34 insertions, 22 deletions

diff --git a/cabs-syn.lisp b/cabs-syn.lisp
index 2b6d30a..60b1a65 100644
--- a/cabs-syn.lisp
+++ b/cabs-syn.lisp
@@ -30,11 +30,11 @@
 
 (defclass <exp-var> (<expression>) ((var :accessor var)))
 (defclass <exp-str> (<expression>) ((str :accessor str)))
-(defclass <exp-unr> (<expression>) ((op :accessor op) (exp :accessor exp)))
+(defclass <exp-unr> (<expression>) ((op :accessor op) (expr :accessor expr)))
 (defclass <exp-bin> (<expression>) ((exp1 :accessor exp1) (op :accessor op) (exp2 :accessor exp2)))
 
 (defclass <command> () () (:metaclass <abstract-class>))
-(defclass <cmd-rem> (<command>) ((rem :accessor rem)))
+(defclass <cmd-rem> (<command>) ((remark :accessor remark)))
 (defclass <cmd-goto> (<command>) ((goto :accessor goto)))
 (defclass <cmd-print> (<command>) ((expr :accessor expr)))
 (defclass <cmd-input> (<command>) ((var :accessor var)))
@@ -54,7 +54,8 @@
     ((not) 1)
     ((uminus) 7)))
 
-(defun priority-binop (bin-op  (cond ((member bin-op '(mult div)) 6)
+(defun priority-binop (bin-op)
+  (cond ((member bin-op '(mult div)) 6)
     ((member bin-op '(plus minus)) 5)
     ((eql bin-op 'mod) 4)
     ((member bin-op '(equal less lesseq great greateq diff)) 3)
diff --git a/cbasic.lisp b/cbasic.lisp
index 5183859..0f2d63c 100644
--- a/cbasic.lisp
+++ b/cbasic.lisp
@@ -2,7 +2,7 @@
 ;;; initially following the design of
 ;;; https://caml.inria.fr/pub/docs/oreilly-book/html/book-ora058.html
 ;;; then later I can optimise following
-;;; https://github.com/Henry/BuddKaminInterpreters and
+;;; https://github.com/Henry/BuddKaminInterpreters and *maybe*
 ;;; https://oleksandrmanzyuk.wordpress.com/2014/06/18/from-object-algebras-to-finally-tagless-interpreters-2/
 ;;;
 ;;; A BASIC interpreter already exists at
@@ -12,14 +12,19 @@
 
 ;; Because this is the main package,
 ;; 1) ql:quickload QuickLisp dependencies and
+(ql:quickload "closer-mop")
 ;; 2) load local dependencies here.
 (load "cutil.lisp")
+(load "cabs-syn.lisp")
+(load "clex.lisp")
 (load "cparse.lisp")
+;;
 ;; Use require & defpackage in each package from then on.
 ;; NB: must have no circular dependencies, and topologically sort the loads.
 ;;
-;; TODO: it's easier to just get started with ASDF
+;; TODO: is it easier to just get started with ASDF?
 ;;       ( https://lisp-lang.org/learn/writing-libraries )
+;;       Although this is beyond OpenLisp.
 
 (require "cparse")
 (defpackage #:cbasic
@@ -32,7 +37,7 @@
 ;;; but try to keep the number of top-level functions the same as in OCaml.
 
 (defun one-command (st)
-  (format (standard-output) "> ")
+  (format *standard-output* "> ")
   (with-handler #'error-handler
     (let ((l (parse (read-line))))
       (case (car l)
@@ -47,8 +52,8 @@
 
 (defun main ()
   (catch 'end (lambda ()
-                (format (standard-output) "BASIC version 0.1~%~%")
+                (format *standard-output* "BASIC version 0.1~%~%")
                 (for ((st (create (class <state>))))
                      (catch 'error (one-command st)))))
-  (format (standard-output) "See you later...~%"))
+  (format *standard-output* "See you later...~%"))
 (provide "cbasic")
diff --git a/clex.lisp b/clex.lisp
index 3ce6aaa..442f1cd 100644
--- a/clex.lisp
+++ b/clex.lisp
@@ -1,5 +1,5 @@
 (defpackage #:clex
-  (:use #:common-lisp #:util)
+  (:use #:common-lisp #:cutil)
   (:export
    #:<lint>
    #:<lsymbol>
@@ -10,27 +10,27 @@
 (defclass <lexeme> () () (:metaclass <abstract-class>))
 (defclass <lint> (<lexeme>) ((int :reader int)))
 (defclass <lident> (<lexeme>) ((ident :reader ident)))
-(defclass <lsymbol> (<lexeme>) ((symbol :reader symbol)))
-(defclass <lstring> (<lexeme>) ((string :reader string)))
+(defclass <lsymbol> (<lexeme>) ((lsymbol :reader lsymbol)))
+(defclass <lstring> (<lexeme>) ((lstring :reader lstring)))
 (defclass <lend> (<lexeme>) ())
 
-(defclass <string-lexer> () ((string :initarg :s :accessor string)
+(defclass <string-lexer> () ((lstring :initarg :s :accessor lstring)
                              (current :initform 0 :accessor current)
                              (size :accessor size)))
 
 (defmethod initialize-object :after ((self <string-lexer>) initargs)
-   (setf (size self) (length (str self))))
+   (setf (size self) (length (lstring self))))
 
 (defgeneric forward (cl &rest args))
 (defmethod forward ((cl <string-lexer>) &rest args)
    (let ((incr (if (null args)
                    1
                    (car args))))
-        (setf (curr cl) (+ (curr cl) incr))))
+        (setf (current cl) (+ (current cl) incr))))
 
 (defgeneric extract (pred cl))
 (defmethod extract (pred (cl <string-lexer>))
-   (let* ((st (string cl))
+   (let* ((st (lstring cl))
           (pos (current cl))
           (ext (lambda (n)
                   (if (and (< n (size cl)) (pred (elt st n)))
@@ -38,7 +38,7 @@
                       n)))
           (res (ext pos)))
          (setf (current cl) res)
-         (subseq (string cl) pos (- res pos))))
+         (subseq (lstring cl) pos (- res pos))))
 
 (defgeneric extract-int (cl))
 (defmethod extract-int ((cl <string-lexer>))
diff --git a/cparse.lisp b/cparse.lisp
index 5c8c6bb..602dc76 100644
--- a/cparse.lisp
+++ b/cparse.lisp
@@ -5,7 +5,7 @@
 (in-package #:cparse)
 
 (defclass <exp-elem> () () (:metaclass <abstract-class>))
-(defclass <elem-exp> (<exp-elem>) ((exp :accessor exp)))
+(defclass <elem-exp> (<exp-elem>) ((expr :accessor expr)))
 (defclass <elem-bin> (<exp-elem>) ((bin-op :accessor bin-op)))
 (defclass <elem-unr> (<exp-elem>) ((unr-op :accessor unr-op)))
 (defclass <elem-lp> (<exp-elem) ())
@@ -40,5 +40,4 @@
 		  (make-instance (find-class '<phrase-p-end>)))
 		 (t (error "Parse error"))))
 	  (t (error "Parse error")))))
-
-		 
+(provide "cparse")
diff --git a/cutil.lisp b/cutil.lisp
index 2f10099..e651b11 100644
--- a/cutil.lisp
+++ b/cutil.lisp
@@ -1,5 +1,5 @@
 (defpackage #:cutil
-  (:use #:common-lisp :closer-mop)
+  (:use #:common-lisp)
   (:export
    #:<abstract-class>))
 (in-package #:cutil)
@@ -7,8 +7,15 @@
 (defclass <abstract-class> (standard-class) ())
 (defmethod make-instance ((self <abstract-class>) &key)
   (error "Cannot instantiate abstract class ~A" (class-name self)))
+
+;;; These are copied from cl-abstract-classes in Quicklisp.
+;;; It turns out you do need both.
+;;; Maybe someday I'll understand why :-)
 (defmethod closer-mop:validate-superclass ((class <abstract-class>)
-					   (superclass standard-class))
+					   (superclass cl:standard-class))
+  t)
+(defmethod closer-mop:validate-superclass ((class cl:standard-class)
+					   (superclass <abstract-class>))
   t)
 
 (provide "cutil")
diff --git a/doc/breaking_rules.md b/doc/breaking_rules.md
index b8887b3..93e6915 100644
--- a/doc/breaking_rules.md
+++ b/doc/breaking_rules.md
@@ -78,7 +78,7 @@ Reasons for choosing Common Lisp include:
 * Although the official ANSI standard is moribund,
   quasi-standard libaries are recommended on the
   [awesome list](https://github.com/CodyReichert/awesome-cl),
-  or [portability layers](https://github.com/CodyReichert/awesome-cl#portability-layers).
+  or [portability layers](http://portability.cl/).
 * Contrary to a lot of other languages, it is fairly paradigm-agnostic.
 
 At the same time, I want a clean subset of CL,