diff --git a/.gitignore b/.gitignore index a0db7e2..795f8a4 100644 --- a/.gitignore +++ b/.gitignore @@ -21,3 +21,7 @@ Sysout*.lsp *.pdf src/beowulf/scratch.clj + +.portal/vs-code.edn + +.portal/ diff --git a/README.md b/README.md index 364cfe3..47aee7e 100644 --- a/README.md +++ b/README.md @@ -48,11 +48,20 @@ Because Lisp is the only computer language worth learning, and if a thing is worth learning, it's worth learning properly; which means going back to the beginning and trying to understand that. -Because there is, so far as I know, no working implementation of Lisp 1.5 -for modern machines. - Because I'm barking mad, and this is therapy. +#### There are other barking mad people out there + +Since I wrote Beowulf, I've become aware of other modern reimplementations of Lisp 1.5: + +1. [Kenichi Sasagawa's in C](https://github.com/sasagawa888/lisp1.5); +2. [Ichigo Lisp, in JavaScript, which compiles to Web Assembly](https://github.com/zick/IchigoLisp); +3. [Geert Bosch's implementation in ADA](https://github.com/GeertBosch/lisp); + +There are probably others. + +In addition, [this](https://github.com/informatimago/lisp-1-5) appears to be a transcription of the original IBM 709 card deck for the Lisp 1.5 system. There's an IBM 709 emulator [here](https://github.com/Bertoid1311/B7094) on which it might be possible to actually run this. + ### Status Working Lisp interpreter, but some key features not yet implemented. @@ -77,7 +86,7 @@ You are of course welcome to fork the project and do whatever you like with it! Invoke with - java -jar target/uberjar/beowulf-0.3.0-standalone.jar --help + java -jar target/uberjar/beowulf-0.3.1-standalone.jar --help (Obviously, check your version number) @@ -338,7 +347,7 @@ even has a working compiler! ### History resources -I'm compiling a [list of links to historical documents on Lisp 1.5](https://simon-brooke.github.io/beowulf/docs/further_reading.html). +I'm compiling a [list of links to historical documents on Lisp 1.5](https://simon-brooke.github.io/beowulf/docs/codox/further_reading.html). ## License diff --git a/doc/lisp1.5.md b/doc/lisp1.5.md index 6042cc8..4a566ed 100644 --- a/doc/lisp1.5.md +++ b/doc/lisp1.5.md @@ -961,19 +961,15 @@ But if eval is given (QUOTE X), X should not be evaluated. QUOTE is a special fo that prevents its argument from being evaluated. A special form differs from a function in two ways. Its arguments are not evaluated before the special form sees them. COND, for example, has a very special way of -``` - evaluating its arguments by using evcon. The second way which special forms differ -from functions is that they may have an indefinite number of arguments. Special forrrls -have indicators on their property lists called FEXPR and FSUBR for LISP -defined forms +from functions is that they may have an indefinite number of arguments. Special forms +have indicators on their property lists called FEXPR and FSUBR for LISP-defined forms and machine language coded forms, respectively. -``` -2.6 Programming for the Interpreter -``` +### 2.6 Programming for the Interpreter The purpose of this section is to help the programmer avoid certain common errors. -Example 1 +Example 1: CAR fn: CAR args: ((A B)) The value is A. Note that the interpreter expects a list of arguments. The one argu- @@ -981,20 +977,18 @@ ment for car is (A B). The extra pair of parentheses is necessary. One could write (LAMBDA (X) (CAR X)) instead of just CAR. This is correct but unnecessary. -``` -Example 2 +Example 2: CONS fn: CONS -args: (A (B. C)) -The value is cons[^;(^. c)] = (A. (B. C)). -The print program will write this as (A B. C). -``` +args: (A (B . C)) +The value is cons[a; cons[b; c]] = (A . (B . C)). +The print program will write this as (A B . C). Example (^3) - fn: CONS -args: ((CAR (QUOTE (A. B))) (CDR (QUOTE (C. D)))) -The value of this computation will be ((CAR (QUOTE (A. B))). (CDR (QUOTE (C. D)))). -This is not what the programmer expected. He expected (CAR (QUOTE (A. B))) to -evaluate to A, and expected (A. D) as the value of cons. +args: ((CAR (QUOTE (A . B))) (CDR (QUOTE (C . D)))) +The value of this computation will be ((CAR (QUOTE (A . B))) . (CDR (QUOTE (C . D)))). +This is not what the programmer expected. He expected (CAR (QUOTE (A . B))) to +evaluate to A, and expected (A . D) as the value of cons. * The interpreter expects a ---- list of arguments. ------- It does not expect a list of expressions -- that will evaluate to the arguments. Tworcorrect ways of writing this function are listed @@ -1721,6 +1715,7 @@ represented in storage only once, The following simple example has been included to illustrate the exact construction of list structures. Two types of list structures are shown, and a function for deriving one from the other is given in LISP. + We assume that we have a list of the form n, = ((A B C) (D E F),... , (X Y z)), @@ -2709,7 +2704,9 @@ If `deflist` or `define` is used twice on the same object with the same indicato The function attrib concatenates its two arguments by changing the last element of its first argument to point to the second argument. Thus it is commonly used to tack something onto the end of a property list. The value of attrib is the second argument. For example -attrib[~~; (EXPR (LAMBDA (X) (COND ((ATOM X) X) (T (FF (CAR x))))))] +``` +attrib[FF; (EXPR (LAMBDA (X) (COND ((ATOM X) X) (T (FF (CAR x))))))] +``` would put EXPR followed by the LAMBDA expression for FF onto the end of the prop- erty list for FF. diff --git a/docs/cloverage/beowulf/bootstrap.clj.html b/docs/cloverage/beowulf/bootstrap.clj.html index 20afabb..a9efdd4 100644 --- a/docs/cloverage/beowulf/bootstrap.clj.html +++ b/docs/cloverage/beowulf/bootstrap.clj.html @@ -38,1213 +38,1465 @@ 011    objects."
- 012    (:require [clojure.string :as s] + 012    (:require [beowulf.cons-cell :refer [F make-beowulf-list make-cons-cell
- 013              [clojure.tools.trace :refer :all] + 013                                         pretty-print T]]
- 014              [beowulf.cons-cell :refer [make-beowulf-list make-cons-cell NIL T F]])) + 014              [beowulf.host :refer [ASSOC ATOM CAAR CAADR CADAR CADDR CADR CAR CDR +
+ + 015                                    CONS ERROR GET LIST NUMBERP PAIRLIS traced?]] +
+ + 016              [beowulf.oblist :refer [*options* NIL]] +
+ + 017              [clojure.string :as s] +
+ + 018              [clojure.tools.trace :refer [deftrace]]) +
+ + 019    (:import [beowulf.cons_cell ConsCell] +
+ + 020             [clojure.lang Symbol]))
- 015   + 021  
- 016  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -
- - 017  ;;; -
- - 018  ;;; This file is essentially Lisp as defined in Chapter 1 (pages 1-14) of the -
- - 019  ;;; Lisp 1.5 Programmer's Manual; that is to say, a very simple Lisp language, -
- - 020  ;;; which should, I believe, be sufficient in conjunction with the functions -
- - 021  ;;; provided by `beowulf.host`, be sufficient to bootstrap the full Lisp 1.5 -
- - 022  ;;; interpreter. + 022  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
023  ;;;
- 024  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + 024  ;;; Copyright (C) 2022-2023 Simon Brooke +
+ + 025  ;;; +
+ + 026  ;;; This program is free software; you can redistribute it and/or +
+ + 027  ;;; modify it under the terms of the GNU General Public License +
+ + 028  ;;; as published by the Free Software Foundation; either version 2 +
+ + 029  ;;; of the License, or (at your option) any later version. +
+ + 030  ;;;  +
+ + 031  ;;; This program is distributed in the hope that it will be useful, +
+ + 032  ;;; but WITHOUT ANY WARRANTY; without even the implied warranty of +
+ + 033  ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the +
+ + 034  ;;; GNU General Public License for more details. +
+ + 035  ;;;  +
+ + 036  ;;; You should have received a copy of the GNU General Public License +
+ + 037  ;;; along with this program; if not, write to the Free Software +
+ + 038  ;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA. +
+ + 039  ;;; +
+ + 040  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
- 025   + 041   +
+ + 042  (declare APPLY EVAL EVCON prog-eval) +
+ + 043   +
+ + 044  ;;;; The PROGram feature ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +
+ + 045  
- 026  (declare EVAL) -
- - 027   -
- - 028  (def oblist + 046  (def ^:dynamic
- 029    "The default environment." + 047    *depth* +
+ + 048    "Stack depth. Unfortunately we need to be able to pass round depth for  +
+ + 049     functions which call EVAL/APPLY but do not know about depth." +
+ + 050    0) +
+ + 051   +
+ + 052  (defn- trace-indent +
+ + 053    ([] (trace-indent *depth*)) +
+ + 054    ([d] (s/join (repeat d " ")))) +
+ + 055   +
+ + 056  (def find-target +
+ + 057    (memoize +
+ + 058     (fn [target body] +
+ + 059       (loop [body' body]
- 030    (atom NIL)) + 060         (cond
- - 031   + + 061           (= body' NIL) (throw (ex-info (str "Mislar GO miercels: `" target "`")
- - 032  (def ^:dynamic *options* + + 062                                         {:phase :lisp
- 033    "Command line options from invocation." -
- - 034    {}) -
- - 035   -
- - 036  (defmacro NULL + 063                                          :function 'PROG
- 037    "Returns `T` if and only if the argument `x` is bound to `NIL`; else `F`." + 064                                          :type :lisp
- 038    [x] + 065                                          :code :A6
- 039    `(if (= ~x NIL) T F)) -
- - 040   -
- - 041  (defmacro ATOM -
- - 042    "Returns `T` if and only is the argument `x` is bound to and atom; else `F`. -
- - 043    It is not clear to me from the documentation whether `(ATOM 7)` should return -
- - 044    `T` or `F`. I'm going to assume `T`." -
- - 045    [x] -
- - 046    `(if (or (symbol? ~x) (number? ~x)) T F)) -
- - 047   -
- - 048  (defmacro ATOM? -
- - 049    "The convention of returning `F` from predicates, rather than `NIL`, is going -
- - 050    to tie me in knots. This is a variant of `ATOM` which returns `NIL` -
- - 051    on failure." -
- - 052    [x] -
- - 053    `(if (or (symbol? ~x) (number? ~x)) T NIL)) -
- - 054   -
- - 055  (defn CAR -
- - 056    "Return the item indicated by the first pointer of a pair. NIL is treated -
- - 057    specially: the CAR of NIL is NIL." -
- - 058    [x] -
- - 059    (cond -
- - 060      (= x NIL) NIL -
- - 061      (instance? beowulf.cons_cell.ConsCell x) (.CAR x) -
- - 062      :else -
- - 063      (throw -
- - 064        (Exception. -
- - 065          (str "Cannot take CAR of `" x "` (" (.getName (.getClass x)) ")"))))) -
- - 066   -
- - 067  (defn CDR -
- - 068    "Return the item indicated by the second pointer of a pair. NIL is treated -
- - 069    specially: the CDR of NIL is NIL." -
- - 070    [x] -
- - 071    (cond -
- - 072      (= x NIL) NIL -
- - 073      (instance? beowulf.cons_cell.ConsCell x) (.CDR x) -
- - 074      :else -
- - 075      (throw -
- - 076        (Exception. -
- - 077          (str "Cannot take CDR of `" x "` (" (.getName (.getClass x)) ")"))))) -
- - 078   -
- - 079  (defn uaf -
- - 080    "Universal access function; `l` is expected to be an arbitrary list, `path` -
- - 081    a (clojure) list of the characters `a` and `d`. Intended to make declaring -
- - 082    all those fiddly `#'c[ad]+r'` functions a bit easier" -
- - 083    [l path] -
- - 084    (cond -
- - 085      (= l NIL) NIL + 066                                          :target target}))
- 086      (empty? path) l -
- - 087      :else (case (last path) -
- - 088              \a (uaf (CAR l) (butlast path)) -
- - 089              \d (uaf (CDR l) (butlast path))))) -
- - 090   -
- - 091  (defn CAAR [x] (uaf x (seq "aa"))) -
- - 092  (defn CADR [x] (uaf x (seq "ad"))) -
- - 093  (defn CDDR [x] (uaf x (seq "dd"))) -
- - 094  (defn CDAR [x] (uaf x (seq "da"))) -
- - 095   -
- - 096  (defn CAAAR [x] (uaf x (seq "aaa"))) -
- - 097  (defn CAADR [x] (uaf x (seq "aad"))) -
- - 098  (defn CADAR [x] (uaf x (seq "ada"))) -
- - 099  (defn CADDR [x] (uaf x (seq "add"))) -
- - 100  (defn CDDAR [x] (uaf x (seq "dda"))) -
- - 101  (defn CDDDR [x] (uaf x (seq "ddd"))) -
- - 102  (defn CDAAR [x] (uaf x (seq "daa"))) -
- - 103  (defn CDADR [x] (uaf x (seq "dad"))) -
- - 104   -
- - 105  (defn CAAAAR [x] (uaf x (seq "aaaa"))) -
- - 106  (defn CAADAR [x] (uaf x (seq "aada"))) -
- - 107  (defn CADAAR [x] (uaf x (seq "adaa"))) -
- - 108  (defn CADDAR [x] (uaf x (seq "adda"))) -
- - 109  (defn CDDAAR [x] (uaf x (seq "ddaa"))) -
- - 110  (defn CDDDAR [x] (uaf x (seq "ddda"))) -
- - 111  (defn CDAAAR [x] (uaf x (seq "daaa"))) -
- - 112  (defn CDADAR [x] (uaf x (seq "dada"))) -
- - 113  (defn CAAADR [x] (uaf x (seq "aaad"))) -
- - 114  (defn CAADDR [x] (uaf x (seq "aadd"))) -
- - 115  (defn CADADR [x] (uaf x (seq "adad"))) -
- - 116  (defn CADDDR [x] (uaf x (seq "addd"))) -
- - 117  (defn CDDADR [x] (uaf x (seq "ddad"))) -
- - 118  (defn CDDDDR [x] (uaf x (seq "dddd"))) -
- - 119  (defn CDAADR [x] (uaf x (seq "daad"))) -
- - 120  (defn CDADDR [x] (uaf x (seq "dadd"))) -
- - 121   + 067           (= (.getCar body') target) body'
- 122  (defn EQ -
- - 123    "Returns `T` if and only if both `x` and `y` are bound to the same atom, -
- - 124    else `F`." -
- - 125    [x y] -
- - 126    (if (and (= (ATOM x) T) (= x y)) T F)) + 068           :else (recur (.getCdr body')))))))
- 127   + 069  
- 128  (defn EQUAL + 070  (defn- prog-cond
- 129    "This is a predicate that is true if its two arguments are identical + 071    "Like `EVCON`, q.v. except using `prog-eval` instead of `EVAL` and not
- 130    S-expressions, and false if they are different. (The elementary predicate + 072     throwing an error if no clause matches."
- 131    `EQ` is defined only for atomic arguments.) The definition of `EQUAL` is + 073    [clauses vars env depth]
- - 132    an example of a conditional expression inside a conditional expression. + + 074    (loop [clauses' clauses] +
+ + 075      (if-not (= clauses' NIL) +
+ + 076        (let [test (prog-eval (CAAR clauses') vars env depth)] +
+ + 077          (if (not (#{NIL F} test)) +
+ + 078            (prog-eval (CADAR clauses') vars env depth) +
+ + 079            (recur (.getCdr clauses')))) +
+ + 080        NIL)))
- 133   + 081  
- - 134    NOTE: returns `F` on failure, not `NIL`" -
- - 135    [x y] + + 082  (defn- merge-vars [vars env]
- 136    (cond + 083    (reduce
- - 137      (= (ATOM x) T) (EQ x y) + + 084     #(make-cons-cell
- - 138      (= (EQUAL (CAR x) (CAR y)) T) (EQUAL (CDR x) (CDR y)) + + 085       (make-cons-cell %2 (@vars %2))
- 139      :else F)) + 086       env) +
+ + 087     env +
+ + 088     (keys @vars))) +
+ + 089   +
+ + 090  (defn prog-eval +
+ + 091    "Like `EVAL`, q.v., except handling symbols, and expressions starting +
+ + 092     `GO`, `RETURN`, `SET` and `SETQ` specially." +
+ + 093    [expr vars env depth] +
+ + 094    (cond +
+ + 095      (number? expr) expr +
+ + 096      (symbol? expr) (@vars expr) +
+ + 097      (instance? ConsCell expr) (case (CAR expr) +
+ + 098                                  COND (prog-cond (CDR expr) +
+ + 099                                                  vars env depth) +
+ + 100                                  GO (let [target (CADR expr)] +
+ + 101                                       (when (traced? 'PROG) +
+ + 102                                         (println "  PROG:GO: Goto " target)) +
+ + 103                                       (make-cons-cell +
+ + 104                                        '*PROGGO* target)) +
+ + 105                                  RETURN (let [val (prog-eval +
+ + 106                                                    (CADR expr) +
+ + 107                                                    vars env depth)] +
+ + 108                                           (when (traced? 'PROG) +
+ + 109                                             (println "  PROG:RETURN: Returning " +
+ + 110                                                      val)) +
+ + 111                                           (make-cons-cell +
+ + 112                                            '*PROGRETURN* +
+ + 113                                            val)) +
+ + 114                                  SET (let [var (prog-eval (CADR expr) +
+ + 115                                                           vars env depth) +
+ + 116                                            val (prog-eval (CADDR expr) +
+ + 117                                                           vars env depth)] +
+ + 118                                        (when (traced? 'PROG) +
+ + 119                                          (println "  PROG:SET: Setting " +
+ + 120                                                   var " to " val)) +
+ + 121                                        (swap! vars +
+ + 122                                               assoc +
+ + 123                                               var +
+ + 124                                               val) +
+ + 125                                        val) +
+ + 126                                  SETQ (let [var (CADDR expr) +
+ + 127                                             val (prog-eval var +
+ + 128                                                            vars env depth)] +
+ + 129                                         (when (traced? 'PROG) +
+ + 130                                           (println "  PROG:SETQ: Setting " var " to " val)) +
+ + 131                                         (swap! vars +
+ + 132                                                assoc +
+ + 133                                                (CADR expr) +
+ + 134                                                val) +
+ + 135                                         val) +
+ + 136                                   ;; else +
+ + 137                                  (beowulf.bootstrap/EVAL expr +
+ + 138                                                          (merge-vars vars env) +
+ + 139                                                          depth))))
140  
- 141  (defn SUBST + 141  (defn PROG
- 142    "This function gives the result of substituting the S-expression `x` for + 142    "The accursed `PROG` feature. See page 71 of the manual.
- 143    all occurrences of the atomic symbol `y` in the S-expression `z`." + 143     
- 144    [x y z] -
- - 145    (cond -
- - 146      (= (EQUAL y z) T) x -
- - 147      (= (ATOM? z) T) z ;; NIL is a symbol + 144     Lisp 1.5 introduced `PROG`, and most Lisps have been stuck with it ever 
- 148      :else + 145     since. It introduces imperative programming into what should be a pure 
- - 149      (make-cons-cell (SUBST x y (CAR z)) (SUBST x y (CDR z))))) + + 146     functional language, and consequently it's going to be a pig to implement. +
+ + 147      +
+ + 148     Broadly, `PROG` is a variadic pseudo function called as a `FEXPR` (or  +
+ + 149     possibly an `FSUBR`, although I'm not presently sure that would even work.)
150  
- - 151  (defn APPEND + + 151     The arguments, which are unevaluated, are a list of forms, the first of 
- 152    "Append the the elements of `y` to the elements of `x`. -
- - 153   + 152     which is expected to be a list of symbols which will be treated as names 
- 154    All args are assumed to be `beowulf.cons-cell/ConsCell` objects. + 153     of variables within the program, and the rest of which (the 'program body')
- 155    See page 11 of the Lisp 1.5 Programmers Manual." + 154     are either lists or symbols. Lists are treated as Lisp expressions which
- 156    [x y] -
- - 157    (cond -
- - 158      (= x NIL) y + 155     may be evaulated in turn. Symbols are treated as targets for the `GO` 
- 159      :else -
- - 160      (make-cons-cell (CAR x) (APPEND (CDR x) y)))) -
- - 161   -
- - 162   -
- - 163  (defn MEMBER + 156     statement. 
- 164    "This predicate is true if the S-expression `x` occurs among the elements + 157        
- 165    of the list `y`. + 158     **GO:**  +
+ + 159     A `GO` statement takes the form of `(GO target)`, where  +
+ + 160     `target` should be one of the symbols which occur at top level among that +
+ + 161     particular invocation of `PROG`s arguments. A `GO` statement may occur at  +
+ + 162     top level in a PROG, or in a clause of a `COND` statement in a `PROG`, but +
+ + 163     not in a function called from the `PROG` statement. When a `GO` statement +
+ + 164     is evaluated, execution should transfer immediately to the expression which +
+ + 165     is the argument list immediately following the symbol which is its target.
166  
- 167    All args are assumed to be symbols or `beowulf.cons-cell/ConsCell` objects. + 167     If the target is not found, an error with the code `A6` should be thrown. +
+ + 168  
- 168    See page 11 of the Lisp 1.5 Programmers Manual." + 169     **RETURN:** 
- 169    [x y] + 170     A `RETURN` statement takes the form `(RETURN value)`, where 
- - 170    (cond + + 171     `value` is any value. Following the evaluation of a `RETURN` statement, 
- - 171      (= y NIL) F ;; NOTE: returns F on falsity, not NIL + + 172     the `PROG` should immediately exit without executing any further 
- - 172      (= (EQUAL x (CAR y)) T) T -
- - 173      :else (MEMBER x (CDR y)))) + + 173     expressions, returning the  value.
174  
+ + 175     **SET and SETQ:** +
+ + 176     In addition to the above, if a `SET` or `SETQ` expression is encountered +
+ + 177     in any expression within the `PROG` body, it should affect not the global +
+ + 178     object list but instead only the local variables of the program. +
+ + 179   +
+ + 180     **COND:** +
+ + 181     In **strict** mode, when in normal execution, a `COND` statement none of  +
+ + 182     whose clauses match should not return `NIL` but should throw an error with +
+ + 183     the code `A3`... *except* that inside a `PROG` body, it should not do so. +
+ + 184     *sigh*. +
+ + 185   +
+ + 186     **Flow of control:** +
+ + 187     Apart from the exceptions specified above, expressions in the program body +
+ + 188     are evaluated sequentially. If execution reaches the end of the program  +
+ + 189     body, `NIL` is returned. +
+ + 190   +
+ + 191     Got all that? +
+ + 192   +
+ + 193     Good." +
+ + 194    [program env depth] +
+ + 195    (let [trace (traced? 'PROG) +
+ + 196          vars (atom (reduce merge (map #(assoc {} % NIL) (.getCar program)))) +
- 175  (defn PAIRLIS + 197          body (.getCdr program)
- - 176    "This function gives the list of pairs of corresponding elements of the + + 198          targets (set (filter symbol? body))]
- - 177    lists `x` and `y`, and APPENDs this to the list `a`. The resultant list + + 199      (when trace (do
- - 178    of pairs, which is like a table with two columns, is called an + + 200                    (println "Program:")
- - 179    association list. -
- - 180   -
- - 181    Eessentially, it builds the environment on the stack, implementing shallow -
- - 182    binding. -
- - 183   -
- - 184    All args are assumed to be `beowulf.cons-cell/ConsCell` objects. -
- - 185    See page 12 of the Lisp 1.5 Programmers Manual." -
- - 186    [x y a] + + 201                    (pretty-print program))) ;; for debugging
- 187    (cond + 202      (loop [cursor body]
- - 188      ;; the original tests only x; testing y as well will be a little more + + 203        (let [step (if (= NIL cursor) NIL (.getCar cursor))]
- - 189      ;; robust if `x` and `y` are not the same length. + + 204          (when trace (do (println "Executing step: " step)
- - 190      (or (= NIL x) (= NIL y)) a + + 205                          (println "  with vars: " @vars)))
- - 191      :else (make-cons-cell + + 206          (cond (= cursor NIL) NIL +
+ + 207                (symbol? step) (recur (.getCdr cursor))
- 192              (make-cons-cell (CAR x) (CAR y)) + 208                :else (let [v (prog-eval (.getCar cursor) vars env depth)]
- - 193              (PAIRLIS (CDR x) (CDR y) a)))) -
- - 194   -
- - 195  (defn ASSOC -
- - 196    "If a is an association list such as the one formed by PAIRLIS in the above -
- - 197    example, then assoc will produce the first pair whose first term is x. Thus -
- - 198    it is a table searching function. -
- - 199   -
- - 200    All args are assumed to be `beowulf.cons-cell/ConsCell` objects. -
- - 201    See page 12 of the Lisp 1.5 Programmers Manual." -
- - 202    [x a] -
- - 203    (cond + + 209                        (when trace (println "  --> " v))
- 204      (= NIL a) NIL ;; this clause is not present in the original but is added for + 210                        (if (instance? ConsCell v)
- - 205      ;; robustness. -
- - 206      (= (EQUAL (CAAR a) x) T) (CAR a) -
- - 207      :else -
- - 208      (ASSOC x (CDR a)))) -
- - 209   + + 211                          (case (.getCar v)
- 210  (defn- SUB2 + 212                            *PROGGO* (let [target (.getCdr v)]
- - 211    "Internal to `SUBLIS`, q.v., which SUBSTitutes into a list from a store. -
- - 212    ? I think this is doing variable binding in the stack frame?" -
- - 213    [a z] -
- - 214    (cond -
- - 215      (= NIL a) z -
- - 216      (= (CAAR a) z) (CDAR a) ;; TODO: this looks definitely wrong -
- - 217      :else -
- - 218      (SUB2 (CDR a) z))) -
- - 219   + + 213                                       (if (targets target)
- 220  (defn SUBLIS + 214                                         (recur (find-target target body)) +
+ + 215                                         (throw (ex-info (str "Uncynlic GO miercels `" +
+ + 216                                                              target "`") +
+ + 217                                                         {:phase :lisp
- 221    "Here `a` is assumed to be an association list of the form + 218                                                          :function 'PROG +
+ + 219                                                          :args program
- 222    `((ul . vl)...(un . vn))`, where the `u`s are atomic, and `y` is any + 220                                                          :type :lisp
- 223    S-expression. What `SUBLIS` does, is to treat the `u`s as variables when + 221                                                          :code :A6 +
+ + 222                                                          :target target +
+ + 223                                                          :targets targets})))) +
+ + 224                            *PROGRETURN* (.getCdr v)
- 224    they occur in `y`, and to SUBSTitute the corresponding `v`s from the pair + 225                          ;; else
- - 225    list. + + 226                            (recur (.getCdr cursor)))
- - 226   -
- - 227    My interpretation is that this is variable binding in the stack frame. + + 227                          (recur (.getCdr cursor)))))))))
228  
- 229    All args are assumed to be `beowulf.cons-cell/ConsCell` objects. -
- - 230    See page 12 of the Lisp 1.5 Programmers Manual." -
- - 231    [a y] -
- - 232    (cond -
- - 233      (= (ATOM? y) T) (SUB2 a y) -
- - 234      :else -
- - 235      (make-cons-cell (SUBLIS a (CAR y)) (SUBLIS a (CDR y))))) + 229  ;;;; Tracing execution ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
- 236   + 230  
- 237  (defn interop-interpret-q-name + 231  (defn- trace-call
- 238    "For interoperation with Clojure, it will often be necessary to pass + 232    "Show a trace of a call to the function named by this `function-symbol` 
- 239    qualified names that are not representable in Lisp 1.5. This function + 233    with these `args` at this depth."
- 240    takes a sequence in the form `(PART PART PART... NAME)` and returns + 234    [function-symbol args depth]
- - 241    a symbol in the form `PART.PART.PART/NAME`. This symbol will then be -
- - 242    tried in both that form and lower-cased. Names with hyphens or -
- - 243    underscores cannot be represented with this scheme." -
- - 244    [l] -
- - 245    (if -
- - 246      (seq? l) -
- - 247      (symbol -
- - 248        (s/reverse + + 235    (when (traced? function-symbol)
- 249          (s/replace-first + 236      (let [indent (trace-indent depth)]
- - 250            (s/reverse -
- - 251              (s/join "." (map str l))) -
- - 252            "." -
- - 253            "/"))) -
- - 254      l)) + + 237        (println (str indent "> " function-symbol " " args)))))
- 255   + 238  
- - 256  (deftrace INTEROP + + 239  (defn- trace-response
- 257    "Clojure (or other host environment) interoperation API. `fn-symbol` is expected + 240    "Show a trace of this `response` from the function named by this
- 258    to be either + 241     `function-symbol` at this depth." +
+ + 242    [function-symbol response depth] +
+ + 243    (when (traced? function-symbol) +
+ + 244      (let [indent (apply str (trace-indent depth))] +
+ + 245        (println (str "<" indent " " function-symbol " " response)))) +
+ + 246    response) +
+ + 247   +
+ + 248  ;;;; Support functions for interpreter ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +
+ + 249   +
+ + 250  (defn value +
+ + 251    "Seek a value for this symbol `s` by checking each of these indicators in +
+ + 252     turn." +
+ + 253    ([s] +
+ + 254     (value s (list 'APVAL 'EXPR 'FEXPR 'SUBR 'FSUBR))) +
+ + 255    ([s indicators] +
+ + 256     (when (symbol? s) +
+ + 257       (first (remove #(= % NIL) (map #(GET s %) +
+ + 258                                      indicators))))))
259  
- - 260    1. a symbol bound in the host environment to a function; or + + 260  (defn SASSOC
- 261    2. a sequence (list) of symbols forming a qualified path name bound to a + 261    "Like `ASSOC`, but with an action to take if no value is found.
- 262       function. -
- - 263   + 262     
- 264    Lower case characters cannot normally be represented in Lisp 1.5, so both the + 263     From the manual, page 60:
- 265    upper case and lower case variants of `fn-symbol` will be tried. If the + 264     
- 266    function you're looking for has a mixed case name, that is not currently + 265     'The function `sassoc` searches `y`, which is a list of dotted pairs, for 
- 267    accessible. -
- - 268   + 266     a pair whose first element that is `x`. If such a pair is found, the value 
- 269    `args` is expected to be a Lisp 1.5 list of arguments to be passed to that + 267     of `sassoc` is this pair. Otherwise the function `u` of no arguments is 
- 270    function. Return value must be something acceptable to Lisp 1.5, so either + 268     taken as the value of `sassoc`.'"
- 271    a symbol, a number, or a Lisp 1.5 list. -
- - 272   -
- - 273    If `fn-symbol` is not found (even when cast to lower case), or is not a function, -
- - 274    or the value returned cannot be represented in Lisp 1.5, an exception is thrown -
- - 275    with `:cause` bound to `:interop` and `:detail` set to a value representing the -
- - 276    actual problem." -
- - 277    [fn-symbol args] -
- - 278    (let -
- - 279      [q-name (if -
- - 280                (seq? fn-symbol) -
- - 281                (interop-interpret-q-name fn-symbol) -
- - 282                fn-symbol) + 269    [x y u]
- 283       l-name (symbol (s/lower-case q-name)) -
- - 284       f (cond -
- - 285              (try -
- - 286                (fn? (eval l-name)) -
- - 287                (catch java.lang.ClassNotFoundException e nil)) (eval l-name) -
- - 288              (try -
- - 289                (fn? (eval q-name)) -
- - 290                (catch java.lang.ClassNotFoundException e nil)) (eval q-name) -
- - 291               :else (throw -
- - 292                       (ex-info -
- - 293                         (str "INTEROP: unknown function `" fn-symbol "`") + 270    (let [v (ASSOC x y)]
- 294                         {:cause :interop -
- - 295                          :detail :not-found -
- - 296                           :name fn-symbol -
- - 297                           :also-tried l-name}))) -
- - 298        result (eval (cons f args))] -
- - 299      (cond + 271      (if-not (= v NIL) v
- 300        (instance? beowulf.cons_cell.ConsCell result) result -
- - 301        (seq? result) (make-beowulf-list result) -
- - 302        (symbol? result) result -
- - 303        (string? result) (symbol result) -
- - 304        (number? result) result -
- - 305        :else (throw -
- - 306                (ex-info -
- - 307                  (str "INTEROP: Cannot return `" result "` to Lisp 1.5.") -
- - 308                  {:cause :interop -
- - 309                   :detail :not-representable -
- - 310                   :result result}))))) + 272              (APPLY u NIL NIL))))
- 311   + 273   +
+ + 274   +
+ + 275  ;;;; APPLY ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +
+ + 276  
- 312  (defn APPLY + 277  (defn try-resolve-subroutine
- 313    "For bootstrapping, at least, a version of APPLY written in Clojure. + 278    "Attempt to resolve this `subr` with these `args`."
- 314    All args are assumed to be symbols or `beowulf.cons-cell/ConsCell` objects. -
- - 315    See page 13 of the Lisp 1.5 Programmers Manual." -
- - 316    [function args environment] -
- - 317    (cond -
- - 318      (= -
- - 319        (ATOM? function) -
- - 320        T)(cond -
- - 321             ;; TODO: doesn't check whether `function` is bound in the environment; -
- - 322             ;; we'll need that before we can bootstrap. -
- - 323             (= function 'CAR) (CAAR args) -
- - 324             (= function 'CDR) (CDAR args) + 279    [subr args]
- 325             (= function 'CONS) (make-cons-cell (CAR args) (CADR args)) + 280    (when (and subr (not= subr NIL))
- - 326             (= function 'ATOM) (if (ATOM? (CAR args)) T NIL) -
- - 327             (= function 'EQ) (if (= (CAR args) (CADR args)) T NIL) + + 281      (try @(resolve subr)
- 328             :else -
- - 329             (APPLY + 282           (catch Throwable any
- 330               (EVAL function environment) -
- - 331               args -
- - 332               environment)) -
- - 333      (= (first function) 'LAMBDA) (EVAL -
- - 334                                     (CADDR function) + 283             (throw (ex-info "þegnung (SUBR) ne āfand"
- 335                                     (PAIRLIS (CADR function) args environment)) -
- - 336      (= (first function) 'LABEL) (APPLY -
- - 337                                    (CADDR function) + 284                             {:phase :apply
- 338                                    args + 285                              :function subr
- 339                                    (make-cons-cell + 286                              :args args +
+ + 287                              :type :beowulf}
- 340                                      (make-cons-cell -
- - 341                                        (CADR function) -
- - 342                                        (CADDR function)) -
- - 343                                      environment)))) + 288                             any))))))
- 344   + 289  
- - 345  (defn- EVCON + + 290  (defn- apply-symbolic
- 346    "Inner guts of primitive COND. All args are assumed to be + 291    "Apply this `funtion-symbol` to these `args` in this `environment` and 
- 347    `beowulf.cons-cell/ConsCell` objects. + 292     return the result."
- 348    See page 13 of the Lisp 1.5 Programmers Manual." -
- - 349    [clauses env] -
- - 350    (if -
- - 351      (not= (EVAL (CAAR clauses) env) NIL) -
- - 352      (EVAL (CADAR clauses) env) -
- - 353      (EVCON (CDR clauses) env))) -
- - 354   -
- - 355  (defn- EVLIS -
- - 356    "Map `EVAL` across this list of `args` in the context of this -
- - 357    `env`ironment.All args are assumed to be `beowulf.cons-cell/ConsCell` objects. -
- - 358    See page 13 of the Lisp 1.5 Programmers Manual." -
- - 359    [args env] -
- - 360    (cond + 293    [^Symbol function-symbol args ^ConsCell environment depth]
- 361      (= NIL args) NIL + 294    (trace-call function-symbol args depth)
- - 362      :else + + 295    (let [lisp-fn (value function-symbol '(EXPR FEXPR))  ;; <-- should these be handled differently? I think so!
- - 363      (make-cons-cell -
- - 364        (EVAL (CAR args) env) -
- - 365        (EVLIS (CDR args) env)))) -
- - 366   -
- - 367  (deftrace traced-eval -
- - 368    "Essentially, identical to EVAL except traced." -
- - 369    [expr env] -
- - 370    (cond -
- - 371      (= -
- - 372        (ATOM? expr) T) -
- - 373      (CDR (ASSOC expr env)) -
- - 374      (= -
- - 375        (ATOM? (CAR expr)) -
- - 376        T)(cond -
- - 377             (= (CAR expr) 'QUOTE) (CADR expr) -
- - 378             (= (CAR expr) 'COND) (EVCON (CDR expr) env) -
- - 379             :else (APPLY -
- - 380                     (CAR expr) -
- - 381                     (EVLIS (CDR expr) env) -
- - 382                     env)) -
- - 383      :else (APPLY -
- - 384              (CAR expr) -
- - 385              (EVLIS (CDR expr) env) -
- - 386              env))) -
- - 387   -
- - 388  (defn EVAL -
- - 389    "For bootstrapping, at least, a version of EVAL written in Clojure. -
- - 390    All args are assumed to be symbols or `beowulf.cons-cell/ConsCell` objects. -
- - 391    See page 13 of the Lisp 1.5 Programmers Manual." -
- - 392    [expr env] + + 296          args' (cond (= NIL args) args
- 393    (cond + 297                      (empty? args) NIL
- 394      (true? (:trace *options*)) -
- - 395      (traced-eval expr env) -
- - 396      (= -
- - 397        (ATOM? expr) T) -
- - 398      (CDR (ASSOC expr env)) -
- - 399      (= -
- - 400        (ATOM? (CAR expr)) -
- - 401        T)(cond -
- - 402             (= (CAR expr) 'QUOTE) (CADR expr) -
- - 403             (= (CAR expr) 'COND) (EVCON (CDR expr) env) -
- - 404             :else (APPLY -
- - 405                     (CAR expr) -
- - 406                     (EVLIS (CDR expr) env) -
- - 407                     env)) -
- - 408      :else (APPLY + 298                      (instance? ConsCell args) args
- 409              (CAR expr) + 299                      :else (make-beowulf-list args))
- - 410              (EVLIS (CDR expr) env) + + 300          subr (value function-symbol '(SUBR FSUBR)) +
+ + 301          host-fn (try-resolve-subroutine subr args') +
+ + 302          result (cond (and lisp-fn +
+ + 303                            (not= lisp-fn NIL)) (APPLY lisp-fn args' environment depth) +
+ + 304                       host-fn (try +
+ + 305                                 (apply host-fn (when (instance? ConsCell args') args')) +
+ + 306                                 (catch Exception any +
+ + 307                                   (throw (ex-info (str "Uncynlic þegnung: " +
+ + 308                                                        (.getMessage any)) +
+ + 309                                                   {:phase :apply +
+ + 310                                                    :function function-symbol +
+ + 311                                                    :args args +
+ + 312                                                    :type :beowulf} +
+ + 313                                                   any)))) +
+ + 314                       :else (ex-info "þegnung ne āfand" +
+ + 315                                      {:phase :apply +
+ + 316                                       :function function-symbol +
+ + 317                                       :args args +
+ + 318                                       :type :beowulf}))] +
+ + 319      (trace-response function-symbol result depth) +
+ + 320      result)) +
+ + 321   +
+ + 322  ;; (LABEL ARGS  +
+ + 323  ;;        (COND ((COND ((ONEP (LENGTH ARGS)) ARGS)  +
+ + 324  ;;                     (T (ATTRIB (CAR ARGS) (APPLY CONC (CDR ARGS) NIL))))  +
+ + 325  ;;               ARGS)))  +
+ + 326  ;; ((1 2 3 4) (5 6 7 8) (9 10 11 12))  +
+ + 327  ;; NIL +
+ + 328  ;; (def function (make-beowulf-list '(LABEL ARGS (COND  +
+ + 329  ;;    ((COND ((ONEP (LENGTH ARGS)) ARGS)  +
+ + 330  ;;           (T (ATTRIB (CAR ARGS)  +
+ + 331  ;;                      (APPLY CONC (CDR ARGS) NIL)))) +
+ + 332  ;;     ARGS))))) +
+ + 333  ;; (def args (make-beowulf-list '((1 2 3 4) (5 6 7 8) (9 10 11 12)))) +
+ + 334   +
+ + 335  ;; function +
+ + 336  ;; (CADR function) +
+ + 337  ;; (CADDR function) +
+ + 338   +
+ + 339  (defn apply-label +
+ + 340    "Apply in the special case that the first element in the function is `LABEL`." +
+ + 341    [function args environment depth] +
+ + 342    (EVAL +
+ + 343     (CADDR function) +
+ + 344     (CONS +
+ + 345      (CONS (CADR function) args) +
+ + 346      environment) +
+ + 347     depth)) +
+ + 348   +
+ + 349  ;; (apply-label function args NIL 1) +
+ + 350  ;; (APPLY function args NIL 1) +
+ + 351   +
+ + 352  (defn- apply-lambda +
+ + 353    "Apply in the special case that the first element in the function is `LAMBDA`." +
+ + 354    [function args environment depth] +
+ + 355    (EVAL +
+ + 356     (CADDR function) +
+ + 357     (PAIRLIS (CADR function) args environment) depth)) +
+ + 358   +
+ + 359  (defn APPLY +
+ + 360    "Apply this `function` to these `arguments` in this `environment` and return +
+ + 361     the result. +
+ + 362      +
+ + 363     For bootstrapping, at least, a version of APPLY written in Clojure. +
+ + 364     All args are assumed to be symbols or `beowulf.cons-cell/ConsCell` objects. +
+ + 365     See page 13 of the Lisp 1.5 Programmers Manual." +
+ + 366    ([function args environment] +
+ + 367     (APPLY function args environment *depth*)) +
+ + 368    ([function args environment depth] +
+ + 369     (binding [*depth* (inc depth)] +
+ + 370       (trace-call 'APPLY (list function args environment) depth) +
+ + 371       (let [result (cond +
+ + 372                      (= NIL function) (if (:strict *options*)
- 411              env))) + 373                                         NIL +
+ + 374                                         (throw (ex-info "NIL sí ne þegnung" +
+ + 375                                                         {:phase :apply +
+ + 376                                                          :function "NIL" +
+ + 377                                                          :args args +
+ + 378                                                          :type :beowulf}))) +
+ + 379                      (= (ATOM function) T) (apply-symbolic function args environment (inc depth)) +
+ + 380                      :else (case (first function) +
+ + 381                              LABEL (apply-label function args environment depth) +
+ + 382                              FUNARG (APPLY (CADR function) args (CADDR function) depth) +
+ + 383                              LAMBDA (apply-lambda function args environment depth) +
+ + 384                              ;; else +
+ + 385                              ;; OK, this is *not* what is says in the manual... +
+ + 386                              ;; COND (EVCON ???) +
+ + 387                              (throw (ex-info "Ungecnáwen wyrþan sí þegnung-weard" +
+ + 388                                              {:phase :apply +
+ + 389                                               :function function +
+ + 390                                               :args args +
+ + 391                                               :type :beowulf}))))] +
+ + 392         (trace-response 'APPLY result depth) +
+ + 393         result))))
- 412   + 394   +
+ + 395  ;;;; EVAL ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
- 413   + 396   +
+ + 397  (defn- EVCON +
+ + 398    "Inner guts of primitive COND. All `clauses` are assumed to be +
+ + 399    `beowulf.cons-cell/ConsCell` objects. Note that tests in Lisp 1.5 +
+ + 400     often return `F`, not `NIL`, on failure. If no clause matches, +
+ + 401     then, strictly, we throw an error with code `:A3`.
- 414   + 402   +
+ + 403     See pages 13 and 71 of the Lisp 1.5 Programmers Manual." +
+ + 404    [clauses env depth] +
+ + 405    (loop [clauses' clauses] +
+ + 406      (if-not (= clauses' NIL) +
+ + 407        (let [test (EVAL (CAAR clauses') env depth)] +
+ + 408          (if (not (#{NIL F} test)) +
+ + 409           ;; (and (not= test NIL) (not= test F)) +
+ + 410            (EVAL (CADAR clauses') env depth) +
+ + 411            (recur (.getCdr clauses')))) +
+ + 412        (if (:strict *options*) +
+ + 413          (throw (ex-info "Ne ġefōg dǣl in COND" +
+ + 414                          {:phase :eval +
+ + 415                           :function 'COND +
+ + 416                           :args (list clauses) +
+ + 417                           :type :lisp +
+ + 418                           :code :A3})) +
+ + 419          NIL)))) +
+ + 420   +
+ + 421  (defn- EVLIS +
+ + 422    "Map `EVAL` across this list of `args` in the context of this +
+ + 423    `env`ironment.All args are assumed to be `beowulf.cons-cell/ConsCell` objects. +
+ + 424    See page 13 of the Lisp 1.5 Programmers Manual." +
+ + 425    [args env depth] +
+ + 426    (cond +
+ + 427      (= NIL args) NIL +
+ + 428      :else +
+ + 429      (make-cons-cell +
+ + 430       (EVAL (CAR args) env depth) +
+ + 431       (EVLIS (CDR args) env depth)))) +
+ + 432   +
+ + 433  (defn- eval-symbolic +
+ + 434    [expr env depth] +
+ + 435    (let [v (ASSOC expr env) +
+ + 436          indent (apply str (repeat depth "-"))] +
+ + 437      (when (traced? 'EVAL) +
+ + 438        (println (str indent ": EVAL: sceald bindele: " (or v "nil")))) +
+ + 439      (if (instance? ConsCell v) +
+ + 440        (.getCdr v) +
+ + 441        (let [v' (value expr)] +
+ + 442          (when (traced? 'EVAL) +
+ + 443            (println (str indent ": EVAL: deóp bindele: (" expr " . " (or v' "nil") ")"))) +
+ + 444          (if v' +
+ + 445            v' +
+ + 446            (throw (ex-info (format "Ne tácen-bindele āfand: `%s`" expr) +
+ + 447                            {:phase :eval +
+ + 448                             :function 'EVAL +
+ + 449                             :args (list expr env depth) +
+ + 450                             :type :lisp +
+ + 451                             :code :A8}))))))) +
+ + 452   +
+ + 453  (defn EVAL +
+ + 454    "Evaluate this `expr` and return the result. If `environment` is not passed, +
+ + 455     it defaults to the current value of the global object list. The `depth` +
+ + 456     argument is part of the tracing system and should not be set by user code. +
+ + 457   +
+ + 458     All args are assumed to be numbers, symbols or `beowulf.cons-cell/ConsCell`  +
+ + 459     objects. However, if called with just a single arg, `expr`, I'll assume it's +
+ + 460     being called from the Clojure REPL and will coerce the `expr` to `ConsCell`." +
+ + 461    ([expr] +
+ + 462     (let [expr' (if (and (coll? expr) (not (instance? ConsCell expr))) +
+ + 463                   (make-beowulf-list expr) +
+ + 464                   expr)] +
+ + 465       (EVAL expr' NIL 0))) +
+ + 466    ([expr env depth] +
+ + 467     (trace-call 'EVAL (list expr env depth) depth) +
+ + 468     (let [result (cond +
+ + 469                    (= NIL expr) NIL ;; it was probably a mistake to make Lisp  +
+ + 470                                     ;; NIL distinct from Clojure nil +
+ + 471                    (= (NUMBERP expr) T) expr +
+ + 472                    (symbol? expr) (eval-symbolic expr env depth) +
+ + 473                    (string? expr) (if (:strict *options*) +
+ + 474                                     (throw +
+ + 475                                      (ex-info +
+ + 476                                       (str "EVAL: strings not allowed in strict mode: \"" expr "\"") +
+ + 477                                       {:phase  :eval +
+ + 478                                        :detail :strict +
+ + 479                                        :expr   expr})) +
+ + 480                                     (symbol expr)) +
+ + 481                    (= (ATOM (CAR expr)) T) (case (CAR expr) +
+ + 482                                              COND (EVCON (CDR expr) env depth) +
+ + 483                                              FUNCTION (LIST 'FUNARG (CADR expr)) +
+ + 484                                              PROG (PROG (CDR expr) env depth) +
+ + 485                                              QUOTE (CADR expr) +
+ + 486             ;; else  +
+ + 487                                              (APPLY +
+ + 488                                               (CAR expr) +
+ + 489                                               (EVLIS (CDR expr) env depth) +
+ + 490                                               env +
+ + 491                                               depth)) +
+ + 492                    :else (EVAL (CONS (CDR (SASSOC (CAR expr) env (fn [] (ERROR 'A9)))) +
+ + 493                                      (CDR expr)) +
+ + 494                                env +
+ + 495                                (inc depth)))] +
+ + 496       (trace-response 'EVAL result depth) +
+ + 497       result))) +
+ + 498  
diff --git a/docs/cloverage/beowulf/cons_cell.clj.html b/docs/cloverage/beowulf/cons_cell.clj.html index 5a58211..aaf1230 100644 --- a/docs/cloverage/beowulf/cons_cell.clj.html +++ b/docs/cloverage/beowulf/cons_cell.clj.html @@ -11,466 +11,820 @@ 002    "The fundamental cons cell on which all Lisp structures are built.
- 003    Lisp 1.5 lists do not necessarily have a sequence as their CDR, so + 003    Lisp 1.5 lists do not necessarily have a sequence as their CDR, and
- 004    cannot be implemented on top of Clojure lists.") + 004    must have both CAR and CDR mutable, so cannot be implemented on top +
+ + 005    of Clojure lists." +
+ + 006    (:require [beowulf.oblist :refer [NIL]]))
- 005   -
- - 006  (def NIL + 007  
- 007    "The canonical empty list symbol." + 008  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
- - 008    (symbol "NIL")) + + 009  ;;; +
+ + 010  ;;; Copyright (C) 2022-2023 Simon Brooke +
+ + 011  ;;; +
+ + 012  ;;; This program is free software; you can redistribute it and/or +
+ + 013  ;;; modify it under the terms of the GNU General Public License +
+ + 014  ;;; as published by the Free Software Foundation; either version 2 +
+ + 015  ;;; of the License, or (at your option) any later version. +
+ + 016  ;;;  +
+ + 017  ;;; This program is distributed in the hope that it will be useful, +
+ + 018  ;;; but WITHOUT ANY WARRANTY; without even the implied warranty of +
+ + 019  ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the +
+ + 020  ;;; GNU General Public License for more details. +
+ + 021  ;;;  +
+ + 022  ;;; You should have received a copy of the GNU General Public License +
+ + 023  ;;; along with this program; if not, write to the Free Software +
+ + 024  ;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA. +
+ + 025  ;;; +
+ + 026  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
- 009   -
- - 010  (def T -
- - 011    "The canonical true value." -
- - 012    (symbol "T")) ;; true. -
- - 013   -
- - 014  (def F -
- - 015    "The canonical false value - different from `NIL`, which is not canonically -
- - 016    false in Lisp 1.5." -
- - 017    (symbol "F")) ;; false as distinct from nil -
- - 018   -
- - 019  (deftype ConsCell [CAR CDR] -
- - 020    clojure.lang.ISeq -
- - 021    (cons [this x] (ConsCell. x this)) -
- - 022    (first [this] (.CAR this)) -
- - 023    ;; next and more must return ISeq: -
- - 024    ;; https://github.com/clojure/clojure/blob/master/src/jvm/clojure/lang/ISeq.java -
- - 025    (more [this] (if -
- - 026                   (seq? (.CDR this)) -
- - 027                   (.CDR this) -
- - 028                   clojure.lang.PersistentList/EMPTY)) -
- - 029    (next [this] (if -
- - 030                   (seq? (.CDR this)) -
- - 031                   (.CDR this) -
- - 032                   nil ;; next returns nil when empty -
- - 033                   )) -
- - 034   -
- - 035    clojure.lang.Seqable -
- - 036    (seq [this] this) -
- - 037   -
- - 038    ;; for some reason this marker protocol is needed otherwise compiler complains -
- - 039    ;; that `nth not supported on ConsCell` -
- - 040    clojure.lang.Sequential -
- - 041   -
- - 042    clojure.lang.IPersistentCollection -
- - 043    (count [this] (if -
- - 044                    (coll? (.CDR this)) -
- - 045                    (inc (.count (.CDR this))) -
- - 046                    1)) -
- - 047    (empty [this] false) ;; a cons cell is by definition not empty. -
- - 048    (equiv [this other] (if -
- - 049                          (seq? other) -
- - 050                          (and -
- - 051                            (if -
- - 052                              (and -
- - 053                                (seq? (first this)) -
- - 054                                (seq? (first other))) -
- - 055                              (.equiv (first this) (first other)) -
- - 056                              (= (first this) (first other))) -
- - 057                            (if -
- - 058                              (and -
- - 059                                (seq? (rest this)) -
- - 060                                (seq? (rest other))) -
- - 061                              (.equiv (rest this) (rest other)) -
- - 062                              (= (rest this) (rest other)))) -
- - 063                          false))) -
- - 064   + 027  
- 065  (defn- to-string + 028  (declare cons-cell?)
- - 066    "Printing ConsCells gave me a *lot* of trouble. This is an internal function -
- - 067    used by the print-method override (below) in order that the standard Clojure -
- - 068    `print` and `str` functions will print ConsCells correctly. The argument -
- - 069    `cell` must, obviously, be an instance of `ConsCell`." -
- - 070    [cell] -
- - 071    (loop [c cell -
- - 072           n 0 -
- - 073           s "("] + + 029  
- 074      (if + 030  (def T
- - 075        (instance? beowulf.cons_cell.ConsCell c) -
- - 076        (let [car (.CAR c) -
- - 077              cdr (.CDR c) -
- - 078              cons? (instance? beowulf.cons_cell.ConsCell cdr) -
- - 079              ss (str -
- - 080                   s + + 031    "The canonical true value."
- 081                   (to-string car) + 032    (symbol "T")) ;; true. +
+ + 033   +
+ + 034  (def F +
+ + 035    "The canonical false value - different from `NIL`, which is not canonically +
+ + 036    false in Lisp 1.5." +
+ + 037    (symbol "F")) ;; false as distinct from nil +
+ + 038   +
+ + 039  ;;;; The actual cons-cell ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +
+ + 040   +
+ + 041  (defprotocol MutableSequence +
+ + 042    "Like a sequence, but mutable." +
+ + 043    (rplaca +
+ + 044      [this value] +
+ + 045      "replace the first element of this sequence with this value") +
+ + 046    (rplacd +
+ + 047      [this value] +
+ + 048      "replace the rest (but-first; cdr) of this sequence with this value") +
+ + 049    (getCar +
+ + 050      [this] +
+ + 051      "Return the first element of this sequence.") +
+ + 052    (getCdr +
+ + 053      [this] +
+ + 054      "like `more`, q.v., but returns List `NIL` not Clojure `nil` when empty.") +
+ + 055    (getUid +
+ + 056      [this] +
+ + 057      "Returns a unique identifier for this object")) +
+ + 058   +
+ + 059  (deftype ConsCell [^:unsynchronized-mutable CAR ^:unsynchronized-mutable CDR uid] +
+ + 060    ;; Note that, because the CAR and CDR fields are unsynchronised mutable - i.e. +
+ + 061    ;; plain old Java instance variables which can be written as well as read - +
+ + 062    ;; ConsCells are NOT thread safe. This does not matter, since Lisp 1.5 is +
+ + 063    ;; single threaded. +
+ + 064    MutableSequence +
+ + 065   +
+ + 066    (rplaca [this value] +
+ + 067      (if +
+ + 068       (or +
+ + 069        (satisfies? MutableSequence value) ;; can't reference +
+ + 070                ;; beowulf.cons_cell.ConsCell, +
+ + 071                ;; because it is not yet +
+ + 072                ;; defined +
+ + 073        (cons-cell? value) +
+ + 074        (number? value) +
+ + 075        (symbol? value)) +
+ + 076        (do +
+ + 077          (set! (. this CAR) value) +
+ + 078          this) +
+ + 079        (throw (ex-info +
+ + 080                (str "Uncynlic miercels in RPLACA: `" value "` (" (type value) ")") +
+ + 081                {:cause  :bad-value +
+ + 082                 :detail :rplaca})))) +
+ + 083   +
+ + 084    (rplacd [this value] +
+ + 085      (if +
+ + 086       (or +
+ + 087        (satisfies? MutableSequence value) +
+ + 088        (cons-cell? value) +
+ + 089        (number? value) +
+ + 090        (symbol? value)) +
+ + 091        (do +
+ + 092          (set! (. this CDR) value) +
+ + 093          this) +
+ + 094        (throw (ex-info +
+ + 095                (str "Uncynlic miercels in RPLACD: `" value "` (" (type value) ")") +
+ + 096                {:cause  :bad-value +
+ + 097                 :detail :rplaca})))) +
+ + 098   +
+ + 099    (getCar [this] +
+ + 100      (. this CAR)) +
+ + 101    (getCdr [this] +
+ + 102      (. this CDR)) +
+ + 103    (getUid [this] +
+ + 104      (. this uid)) +
+ + 105   +
+ + 106    clojure.lang.ISeq +
+ + 107    (cons [this x] (ConsCell. x this (gensym "c"))) +
+ + 108    (first [this] (.CAR this)) +
+ + 109    ;; next and more must return ISeq: +
+ + 110    ;; https://github.com/clojure/clojure/blob/master/src/jvm/clojure/lang/ISeq.java +
+ + 111    (more [this] (if +
+ + 112                  (seq? (.getCdr this)) +
+ + 113                   (.getCdr this) +
+ + 114                   clojure.lang.PersistentList/EMPTY)) +
+ + 115    (next [this] (if +
+ + 116                  (seq? (.getCdr this)) +
+ + 117                   (.getCdr this) +
+ + 118                   nil ;; next returns nil when empty +
+ + 119                   )) +
+ + 120   +
+ + 121    clojure.lang.Seqable +
+ + 122    (seq [this] this) +
+ + 123   +
+ + 124    ;; for some reason this marker protocol is needed otherwise compiler complains +
+ + 125    ;; that `nth not supported on ConsCell` +
+ + 126    clojure.lang.Sequential +
+ + 127   +
+ + 128    clojure.lang.IPersistentCollection +
+ + 129    (empty [this] (= this NIL)) ;; a cons cell is by definition not empty. +
+ + 130    (equiv [this other] (if +
+ + 131                         (seq? other) +
+ + 132                          (and +
+ + 133                           (if
- 082                   (cond + 134                            (and
- - 083                     cons? + + 135                             (seq? (first this))
- - 084                     " " -
- - 085                     (or (nil? cdr) (= cdr 'NIL)) -
- - 086                     ")" -
- - 087                     :else + + 136                             (seq? (first other)))
- 088                     (str " . " (to-string cdr) ")")))] + 137                             (.equiv (first this) (first other))
- - 089          (if + + 138                             (= (first this) (first other)))
- - 090            cons? + + 139                           (if
- - 091            (recur cdr (inc n) ss) -
- - 092            ss)) + + 140                            (and
- 093        (str c)))) -
- - 094   -
- - 095  (defn pretty-print -
- - 096    "This isn't the world's best pretty printer but it sort of works." -
- - 097    ([^beowulf.cons_cell.ConsCell cell] -
- - 098     (println (pretty-print cell 80 0))) -
- - 099    ([^beowulf.cons_cell.ConsCell cell width level] -
- - 100     (loop [c cell -
- - 101            n (inc level) -
- - 102            s "("] -
- - 103       (if -
- - 104         (instance? beowulf.cons_cell.ConsCell c) -
- - 105         (let [car (.CAR c) -
- - 106               cdr (.CDR c) -
- - 107               cons? (instance? beowulf.cons_cell.ConsCell cdr) -
- - 108               print-width (count (print-str c)) -
- - 109               indent (apply str (repeat n "  ")) -
- - 110               ss (str -
- - 111                    s -
- - 112                    (pretty-print car width n) -
- - 113                    (cond -
- - 114                      cons? -
- - 115                      (if -
- - 116                        (< (+ (count indent) print-width) width) -
- - 117                        " " -
- - 118                        (str "\n" indent)) -
- - 119                      (or (nil? cdr) (= cdr 'NIL)) -
- - 120                      ")" -
- - 121                      :else -
- - 122                      (str " . " (pretty-print cdr width n) ")")))] -
- - 123           (if -
- - 124             cons? -
- - 125             (recur cdr n ss) -
- - 126             ss)) -
- - 127         (str c))))) -
- - 128   -
- - 129   -
- - 130   + 141                             (seq? (.getCdr this))
- 131  (defmethod clojure.core/print-method -
- - 132    ;;; I have not worked out how to document defmethod without blowing up the world. -
- - 133    beowulf.cons_cell.ConsCell -
- - 134    [this writer] -
- - 135    (.write writer (to-string this))) -
- - 136   -
- - 137   -
- - 138  (defmacro make-cons-cell -
- - 139    "Construct a new instance of cons cell with this `car` and `cdr`." -
- - 140    [car cdr] -
- - 141    `(ConsCell. ~car ~cdr)) -
- - 142   -
- - 143  (defn make-beowulf-list -
- - 144    "Construct a linked list of cons cells with the same content as the -
- - 145    sequence `x`." -
- - 146    [x] -
- - 147    (cond -
- - 148      (empty? x) NIL -
- - 149      (coll? x) (ConsCell. -
- - 150                  (if -
- - 151                    (seq? (first x)) -
- - 152                    (make-beowulf-list (first x)) + 142                             (seq? (.getCdr other)))
- 153                    (first x)) + 143                             (.equiv (.getCdr this) (.getCdr other))
- - 154                  (make-beowulf-list (rest x))) + + 144                             (= (.getCdr this) (.getCdr other))))
- 155      :else + 145                          false)) +
+ + 146   +
+ + 147    clojure.lang.Counted +
+ + 148    (count [this] (loop [cell this +
+ + 149                         result 1] +
+ + 150                    (if +
+ + 151                     (and (coll? (.getCdr cell)) (not= NIL (.getCdr cell))) +
+ + 152                      (recur (.getCdr cell) (inc result)) +
+ + 153                      result))) +
+ + 154   +
+ + 155    java.lang.Object +
+ + 156    (toString [this] +
+ + 157      (str "("
- 156      NIL)) + 158           (. this CAR) +
+ + 159           (cond +
+ + 160             (instance? ConsCell (. this CDR)) (str " " (subs (.toString (. this CDR)) 1)) +
+ + 161             (= NIL (. this CDR)) ")" +
+ + 162             :else (str " . " (. this CDR) ")"))))) +
+ + 163   +
+ + 164  ;;;; Printing. Here be dragons! ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +
+ + 165   +
+ + 166  (defn- to-string +
+ + 167    "Printing ConsCells gave me a *lot* of trouble. This is an internal function +
+ + 168    used by the print-method override (below) in order that the standard Clojure +
+ + 169    `print` and `str` functions will print ConsCells correctly. The argument +
+ + 170    `cell` must, obviously, be an instance of `ConsCell`." +
+ + 171    ;; TODO: I am deeply suspicious both of this and the defmethod which depends  +
+ + 172    ;; on it. I *think* they are implicated in the `COPY` bug. If the `toString` +
+ + 173    ;; override in `ConsCell` was right, neither of these would be necessary. +
+ + 174    ;; see https://github.com/simon-brooke/beowulf/issues/5 +
+ + 175    [cell] +
+ + 176    (loop [c cell +
+ + 177           n 0 +
+ + 178           s "("] +
+ + 179      (if +
+ + 180       (instance? beowulf.cons_cell.ConsCell c) +
+ + 181        (let [car (.first c) +
+ + 182              cdr (.getCdr c) +
+ + 183              cons? (and +
+ + 184                     (instance? beowulf.cons_cell.ConsCell cdr) +
+ + 185                     (not (nil? cdr)) +
+ + 186                     (not= cdr NIL)) +
+ + 187              ss (str +
+ + 188                  s +
+ + 189                  (to-string car) +
+ + 190                  (cond +
+ + 191                    (or (nil? cdr) (= cdr NIL)) ")" +
+ + 192                    cons?  " " +
+ + 193                    :else (str " . " (to-string cdr) ")")))] +
+ + 194          (if +
+ + 195           cons? +
+ + 196            (recur cdr (inc n) ss) +
+ + 197            ss)) +
+ + 198        (str c)))) +
+ + 199   +
+ + 200  (defmethod clojure.core/print-method +
+ + 201    ;;; I have not worked out how to document defmethod without blowing up the world. +
+ + 202    beowulf.cons_cell.ConsCell +
+ + 203    [this writer] +
+ + 204    (.write writer (to-string this))) +
+ + 205   +
+ + 206  (defn pretty-print +
+ + 207    "This isn't the world's best pretty printer but it sort of works." +
+ + 208    ([cell] +
+ + 209     (println (pretty-print cell 80 0))) +
+ + 210    ([cell width level] +
+ + 211     (loop [c cell +
+ + 212            n (inc level) +
+ + 213            s "("] +
+ + 214       (if +
+ + 215        (instance? beowulf.cons_cell.ConsCell c) +
+ + 216         (let [car (.first c) +
+ + 217               cdr (.getCdr c) +
+ + 218               tail? (instance? beowulf.cons_cell.ConsCell cdr) +
+ + 219               print-width (count (print-str c)) +
+ + 220               indent (apply str (repeat n "  ")) +
+ + 221               ss (str +
+ + 222                   s +
+ + 223                   (pretty-print car width n) +
+ + 224                   (cond +
+ + 225                     (or (nil? cdr) (= cdr NIL)) +
+ + 226                     ")" +
+ + 227                     tail? +
+ + 228                     (if +
+ + 229                      (< (+ (count indent) print-width) width) +
+ + 230                       " " +
+ + 231                       (str "\n" indent)) +
+ + 232                     :else +
+ + 233                     (str " . " (pretty-print cdr width n) ")")))] +
+ + 234           (if +
+ + 235            tail? +
+ + 236             (recur cdr n ss) +
+ + 237             ss)) +
+ + 238         (str c))))) +
+ + 239   +
+ + 240  (defn cons-cell? +
+ + 241    "Is this object `o` a beowulf cons-cell?" +
+ + 242    [o] +
+ + 243    (instance? beowulf.cons_cell.ConsCell o)) +
+ + 244   +
+ + 245  (defn make-cons-cell +
+ + 246    "Construct a new instance of cons cell with this `car` and `cdr`." +
+ + 247    [car cdr] +
+ + 248    (try +
+ + 249      (ConsCell. car cdr (gensym "c")) +
+ + 250      (catch Exception any +
+ + 251        (throw (ex-info "Ne meahte cræfte cons cell" {:car car +
+ + 252                                                         :cdr cdr} any))))) +
+ + 253   +
+ + 254  (defn make-beowulf-list +
+ + 255    "Construct a linked list of cons cells with the same content as the +
+ + 256    sequence `x`." +
+ + 257    [x] +
+ + 258    (try +
+ + 259      (cond +
+ + 260        (empty? x) NIL +
+ + 261        (instance? ConsCell x) (make-cons-cell (.getCar x) (.getCdr x)) +
+ + 262        (coll? x) (ConsCell. +
+ + 263                   (if +
+ + 264                    (coll? (first x)) +
+ + 265                     (make-beowulf-list (first x)) +
+ + 266                     (first x)) +
+ + 267                   (make-beowulf-list (rest x)) +
+ + 268                   (gensym "c")) +
+ + 269        :else +
+ + 270        NIL) +
+ + 271      (catch Exception any +
+ + 272        (throw (ex-info "Ne meahte cræfte Beowulf líste" +
+ + 273                        {:content x} +
+ + 274                        any)))))
diff --git a/docs/cloverage/beowulf/core.clj.html b/docs/cloverage/beowulf/core.clj.html index 13189d9..adf35d5 100644 --- a/docs/cloverage/beowulf/core.clj.html +++ b/docs/cloverage/beowulf/core.clj.html @@ -11,238 +11,394 @@ 002    "Essentially, the `-main` function and the bootstrap read-eval-print loop."
- 003    (:require [beowulf.bootstrap :refer [EVAL oblist *options*]] + 003    (:require [beowulf.bootstrap :refer [EVAL]]
- 004              [beowulf.read :refer [READ]] + 004              [beowulf.io :refer [default-sysout SYSIN]]
- 005              [clojure.java.io :as io] + 005              [beowulf.oblist :refer [*options* NIL]]
- 006              [clojure.pprint :refer [pprint]] + 006              [beowulf.read :refer [READ read-from-console]]
- 007              [clojure.tools.cli :refer [parse-opts]] + 007              [clojure.java.io :as io]
- 008              [environ.core :refer [env]]) + 008              [clojure.pprint :refer [pprint]]
- 009    (:gen-class)) + 009              [clojure.string :refer [trim]] +
+ + 010              [clojure.tools.cli :refer [parse-opts]]) +
+ + 011    (:gen-class))
- 010   -
- - 011  (def cli-options -
- - 012    [["-h" "--help"] -
- - 013     ["-p PROMPT" "--prompt PROMPT" "Set the REPL prompt to PROMPT" + 012  
- 014      :default "Sprecan::"] -
- - 015     ["-r INITFILE" "--read INITFILE" "Read Lisp functions from the file INITFILE" -
- - 016      :validate [#(and -
- - 017                    (.exists (io/file %)) + 013  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
- 018                    (.canRead (io/file %))) + 014  ;;;
- 019                 "Could not find initfile"]] + 015  ;;; Copyright (C) 2022-2023 Simon Brooke
- - 020     ["-s" "--strict" "Strictly interpret the Lisp 1.5 language, without extensions."] + + 016  ;;;
- - 021     ["-t" "--trace" "Trace Lisp evaluation."]]) + + 017  ;;; This program is free software; you can redistribute it and/or +
+ + 018  ;;; modify it under the terms of the GNU General Public License +
+ + 019  ;;; as published by the Free Software Foundation; either version 2 +
+ + 020  ;;; of the License, or (at your option) any later version. +
+ + 021  ;;;  +
+ + 022  ;;; This program is distributed in the hope that it will be useful, +
+ + 023  ;;; but WITHOUT ANY WARRANTY; without even the implied warranty of +
+ + 024  ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the +
+ + 025  ;;; GNU General Public License for more details. +
+ + 026  ;;;  +
+ + 027  ;;; You should have received a copy of the GNU General Public License +
+ + 028  ;;; along with this program; if not, write to the Free Software +
+ + 029  ;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA. +
+ + 030  ;;; +
+ + 031  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
- 022   -
- - 023  (defn repl -
- - 024    "Read/eval/print loop." -
- - 025    [prompt] -
- - 026    (loop [] -
- - 027      (print prompt) + 032  
- 028      (flush) -
- - 029      (try -
- - 030        (let [input (read-line)] -
- - 031          (cond -
- - 032            (= input "quit") (throw (ex-info "\nFærwell!" {:cause :quit})) -
- - 033            input (println (str ">  " (print-str (EVAL (READ input) @oblist)))) -
- - 034            :else (println))) + 033  (def stop-word 
- 035        (catch + 034    "The word which, if submitted an an input line, will cause Beowulf to quit.
- 036          Exception + 035     Question: should this be `forlǣte`?"
- 037          e + 036    "STOP")
- - 038          (let [data (ex-data e)] -
- - 039            (println (.getMessage e)) + + 037  
- 040            (if -
- - 041              data + 038  (def cli-options
- 042              (case (:cause data) -
- - 043                :parse-failure (println (:failure data)) + 039    [["-f FILEPATH" "--file-path FILEPATH"
- 044                :strict nil ;; the message, which has already been printed, is enough. + 040      "Set the path to the directory for reading and writing Lisp files."
- - 045                :quit (throw e) + + 041      :validate [#(and (.exists (io/file %))
- - 046                ;; default + + 042                       (.isDirectory (io/file %)) +
+ + 043                       (.canRead (io/file %))
- 047                (pprint data)))))) -
- - 048      (recur))) -
- - 049   -
- - 050  (defn -main + 044                       (.canWrite (io/file %)))
- 051    "Parse options, print the banner, read the init file if any, and enter the -
- - 052    read/eval/print loop." -
- - 053    [& opts] -
- - 054    (let [args (parse-opts opts cli-options)] -
- - 055      (println -
- - 056        (str -
- - 057          "\nHider wilcuman. Béowulf is mín nama.\n" -
- - 058          (if -
- - 059            (System/getProperty "beowulf.version") -
- - 060            (str "Síðe " (System/getProperty "beowulf.version") "\n")) -
- - 061          (if -
- - 062            (:help (:options args)) + 045                 "File path must exist and must be a directory."]]
- 063            (:summary args)) + 046     ["-h" "--help"]
- - 064          (if (:errors args) -
- - 065            (apply str (interpose "; " (:errors args)))) + + 047     ["-p PROMPT" "--prompt PROMPT" "Set the REPL prompt to PROMPT"
- 066          "\nSprecan 'quit' tó laéfan\n")) + 048      :default "Sprecan::"]
- - 067      (binding [*options* (:options args)] + + 049     ["-r SYSOUTFILE" "--read SYSOUTFILE" "Read Lisp system from file SYSOUTFILE"
- 068        (try + 050      :default default-sysout +
+ + 051      :validate [#(and +
+ + 052                   (.exists (io/file %)) +
+ + 053                   (.canRead (io/file %))) +
+ + 054                 "Could not find sysout file"]] +
+ + 055     ["-s" "--strict" "Strictly interpret the Lisp 1.5 language, without extensions."] +
+ + 056     ["-t" "--time" "Time evaluations."] +
+ + 057     ["-x" "--testing" "Disable the jline reader - useful when piping input."]]) +
+ + 058   +
+ + 059  (defn- re  +
+ + 060    "Like REPL, but it isn't a loop and doesn't print." +
+ + 061    [input] +
+ + 062    (EVAL (READ input) NIL 0)) +
+ + 063   +
+ + 064  (defn repl +
+ + 065    "Read/eval/print loop." +
+ + 066    [prompt] +
+ + 067    (loop []  +
+ + 068      (flush) +
+ + 069      (try
- 069          (repl (str (:prompt (:options args)) " ")) -
- - 070          (catch -
- - 071            Exception -
- - 072            e + 070        (if-let [input (trim (read-from-console prompt))]
- 073            (let [data (ex-data e)] + 071          (if (= input stop-word)
- - 074              (if + + 072            (throw (ex-info "\nFærwell!" {:cause :quit}))
- - 075                data + + 073            (println  +
+ + 074             (str ">  " 
- 076                (case (:cause data) + 075                  (print-str (if (:time *options*) +
+ + 076                               (time (re input)) +
+ + 077                               (re input))))))  +
+ + 078          (println))
- 077                  :quit nil + 079        (catch
- 078                  ;; default + 080         Exception +
+ + 081         e +
+ + 082          (let [data (ex-data e)] +
+ + 083            (println (.getMessage e)) +
+ + 084            (when +
+ + 085             data +
+ + 086              (case (:cause data) +
+ + 087                :parse-failure (println (:failure data)) +
+ + 088                :strict nil ;; the message, which has already been printed, is enough. +
+ + 089                :quit (throw e) +
+ + 090                ;; default
- 079                  (pprint data)) + 091                (pprint data)))))) +
+ + 092      (recur))) +
+ + 093   +
+ + 094  (defn -main +
+ + 095    "Parse options, print the banner, read the init file if any, and enter the +
+ + 096    read/eval/print loop." +
+ + 097    [& opts] +
+ + 098    (let [args (parse-opts opts cli-options)] +
+ + 099      (println +
+ + 100       (str +
+ + 101        "\nHider wilcuman. Béowulf is mín nama.\n" +
+ + 102        (when +
+ + 103         (System/getProperty "beowulf.version") +
+ + 104          (str "Síðe " (System/getProperty "beowulf.version") "\n")) +
+ + 105        (when +
+ + 106         (:help (:options args)) +
+ + 107          (:summary args)) +
+ + 108        (when (:errors args) +
+ + 109          (apply str (interpose "; " (:errors args)))) +
+ + 110        "\nSprecan '" stop-word "' tó laéfan\n")) +
+ + 111       +
+ + 112      (binding [*options* (:options args)] +
+ + 113        ;; (pprint *options*) +
+ + 114        (when (:read *options*) +
+ + 115          (try (SYSIN (:read *options*)) +
+ + 116               (catch Throwable any
- 080                (println e)))))))) + 117                 (println any)))) +
+ + 118        (try +
+ + 119          (repl (:prompt (:options args))) +
+ + 120          (catch +
+ + 121           Exception +
+ + 122           e +
+ + 123            (let [data (ex-data e)] +
+ + 124              (if +
+ + 125               data +
+ + 126                (case (:cause data) +
+ + 127                  :quit nil +
+ + 128                  ;; default +
+ + 129                  (do +
+ + 130                    (println "STÆFLEAHTER: " (.getMessage e)) +
+ + 131                    (pprint data))) +
+ + 132                (println e))))))))
diff --git a/docs/cloverage/beowulf/host.clj.html b/docs/cloverage/beowulf/host.clj.html index 3acdcf2..69b2501 100644 --- a/docs/cloverage/beowulf/host.clj.html +++ b/docs/cloverage/beowulf/host.clj.html @@ -14,10 +14,1816 @@ 003     be) implemented in Lisp 1.5, which therefore need to be implemented in the
- 004     host language, in this case Clojure.") + 004     host language, in this case Clojure." +
+ + 005    (:require [beowulf.cons-cell :refer [F make-beowulf-list make-cons-cell +
+ + 006                                         pretty-print T]] ;; note hyphen - this is Clojure... +
+ + 007              [beowulf.gendoc :refer [open-doc]] +
+ + 008              [beowulf.oblist :refer [*options* NIL oblist]] +
+ + 009              [clojure.set :refer [union]] +
+ + 010              [clojure.string :refer [upper-case]]) +
+ + 011    (:import [beowulf.cons_cell ConsCell] ;; note underscore - same namespace, but Java. +
+ + 012             ))
- 005   + 013   +
+ + 014  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +
+ + 015  ;;; +
+ + 016  ;;; Copyright (C) 2022-2023 Simon Brooke +
+ + 017  ;;; +
+ + 018  ;;; This program is free software; you can redistribute it and/or +
+ + 019  ;;; modify it under the terms of the GNU General Public License +
+ + 020  ;;; as published by the Free Software Foundation; either version 2 +
+ + 021  ;;; of the License, or (at your option) any later version. +
+ + 022  ;;;  +
+ + 023  ;;; This program is distributed in the hope that it will be useful, +
+ + 024  ;;; but WITHOUT ANY WARRANTY; without even the implied warranty of +
+ + 025  ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the +
+ + 026  ;;; GNU General Public License for more details. +
+ + 027  ;;;  +
+ + 028  ;;; You should have received a copy of the GNU General Public License +
+ + 029  ;;; along with this program; if not, write to the Free Software +
+ + 030  ;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA. +
+ + 031  ;;; +
+ + 032  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +
+ + 033   +
+ + 034  ;; these are CANDIDATES to be host-implemented. only a subset of them MUST be. +
+ + 035  ;; those which can be implemented in Lisp should be, since that aids +
+ + 036  ;; portability. +
+ + 037   +
+ + 038   +
+ + 039  (defn lax? +
+ + 040    "Are we in lax mode? If so. return true; is not, throw an exception with  +
+ + 041     this `symbol`." +
+ + 042    [symbol] +
+ + 043    (when (:strict *options*) +
+ + 044      (throw (ex-info (format "%s ne āfand innan Lisp 1.5" symbol) +
+ + 045                      {:type :strict +
+ + 046                       :phase :host +
+ + 047                       :function symbol}))) +
+ + 048    true) +
+ + 049   +
+ + 050  ;;;; Basic operations on cons cells ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +
+ + 051   +
+ + 052  (defn CONS +
+ + 053    "Construct a new instance of cons cell with this `car` and `cdr`." +
+ + 054    [car cdr] +
+ + 055    (beowulf.cons_cell.ConsCell. car cdr (gensym "c"))) +
+ + 056   +
+ + 057  (defn CAR +
+ + 058    "Return the item indicated by the first pointer of a pair. NIL is treated +
+ + 059    specially: the CAR of NIL is NIL." +
+ + 060    [x] +
+ + 061    (cond +
+ + 062      (= x NIL) NIL +
+ + 063      (instance? ConsCell x) (or (.getCar x) NIL) +
+ + 064      :else  (throw (ex-info +
+ + 065                     (str "Ne can tace CAR of `" x "` (" (.getName (.getClass x)) ")") +
+ + 066                     {:phase :host +
+ + 067                      :function 'CAR +
+ + 068                      :args (list x) +
+ + 069                      :type :beowulf})))) +
+ + 070   +
+ + 071  (defn CDR +
+ + 072    "Return the item indicated by the second pointer of a pair. NIL is treated +
+ + 073    specially: the CDR of NIL is NIL." +
+ + 074    [x] +
+ + 075    (cond +
+ + 076      (= x NIL) NIL +
+ + 077      (instance? ConsCell x) (or (.getCdr x) NIL) +
+ + 078      :else  (throw (ex-info +
+ + 079                     (str "Ne can tace CDR of `" x "` (" (.getName (.getClass x)) ")") +
+ + 080                     {:phase :host +
+ + 081                      :function 'CDR +
+ + 082                      :args (list x) +
+ + 083                      :type :beowulf})))) +
+ + 084   +
+ + 085   +
+ + 086  (defn uaf +
+ + 087    "Universal access function; `l` is expected to be an arbitrary LISP list, `path` +
+ + 088    a (clojure) list of the characters `a` and `d`. Intended to make declaring +
+ + 089    all those fiddly `#'c[ad]+r'` functions a bit easier" +
+ + 090    [l path] +
+ + 091    (cond +
+ + 092      (= l NIL) NIL +
+ + 093      (empty? path) l +
+ + 094      (not (instance? ConsCell l)) (throw (ex-info (str "Ne liste: " +
+ + 095                                                        l "; " (type l)) +
+ + 096                                                   {:phase :eval +
+ + 097                                                    :function "universal access function" +
+ + 098                                                    :args [l path] +
+ + 099                                                    :type :beowulf})) +
+ + 100      :else (case (last path) +
+ + 101              \a (uaf (.first l) (butlast path)) +
+ + 102              \d (uaf (.getCdr l) (butlast path)) +
+ + 103              (throw (ex-info (str "uaf: unexpected letter in path (only `a` and `d` permitted): " +
+ + 104                                   (last path)) +
+ + 105                              {:phase :eval +
+ + 106                               :function "universal access function" +
+ + 107                               :args [l path] +
+ + 108                               :type :beowulf}))))) +
+ + 109   +
+ + 110  (defmacro CAAR [x] `(uaf ~x '(\a \a))) +
+ + 111  (defmacro CADR [x] `(uaf ~x '(\a \d))) +
+ + 112  (defmacro CDDR [x] `(uaf ~x '(\d \d))) +
+ + 113  (defmacro CDAR [x] `(uaf ~x '(\d \a))) +
+ + 114   +
+ + 115  (defmacro CAAAR [x] `(uaf ~x '(\a \a \a))) +
+ + 116  (defmacro CAADR [x] `(uaf ~x '(\a \a \d))) +
+ + 117  (defmacro CADAR [x] `(uaf ~x '(\a \d \a))) +
+ + 118  (defmacro CADDR [x] `(uaf ~x '(\a \d \d))) +
+ + 119  (defmacro CDDAR [x] `(uaf ~x '(\d \d \a))) +
+ + 120  (defmacro CDDDR [x] `(uaf ~x '(\d \d \d))) +
+ + 121  (defmacro CDAAR [x] `(uaf ~x '(\d \a \a))) +
+ + 122  (defmacro CDADR [x] `(uaf ~x '(\d \a \d))) +
+ + 123   +
+ + 124  (defmacro CAAAAR [x] `(uaf ~x '(\a \a \a \a))) +
+ + 125  (defmacro CAADAR [x] `(uaf ~x '(\a \a \d \a))) +
+ + 126  (defmacro CADAAR [x] `(uaf ~x '(\a \d \a \a))) +
+ + 127  (defmacro CADDAR [x] `(uaf ~x '(\a \d \d \a))) +
+ + 128  (defmacro CDDAAR [x] `(uaf ~x '(\d \d \a \a))) +
+ + 129  (defmacro CDDDAR [x] `(uaf ~x '(\d \d \d \a))) +
+ + 130  (defmacro CDAAAR [x] `(uaf ~x '(\d \a \a \a))) +
+ + 131  (defmacro CDADAR [x] `(uaf ~x '(\d \a \d \a))) +
+ + 132  (defmacro CAAADR [x] `(uaf ~x '(\a \a \a \d))) +
+ + 133  (defmacro CAADDR [x] `(uaf ~x '(\a \a \d \d))) +
+ + 134  (defmacro CADADR [x] `(uaf ~x '(\a \d \a \d))) +
+ + 135  (defmacro CADDDR [x] `(uaf ~x '(\a \d \d \d))) +
+ + 136  (defmacro CDDADR [x] `(uaf ~x '(\d \d \a \d))) +
+ + 137  (defmacro CDDDDR [x] `(uaf ~x '(\d \d \d \d))) +
+ + 138  (defmacro CDAADR [x] `(uaf ~x '(\d \a \a \d))) +
+ + 139  (defmacro CDADDR [x] `(uaf ~x '(\d \a \d \d))) +
+ + 140   +
+ + 141  (defn RPLACA +
+ + 142    "Replace the CAR pointer of this `cell` with this `value`. Dangerous, should +
+ + 143    really not exist, but does in Lisp 1.5 (and was important for some +
+ + 144    performance hacks in early Lisps)" +
+ + 145    [^ConsCell cell value] +
+ + 146    (if +
+ + 147     (instance? ConsCell cell) +
+ + 148      (if +
+ + 149       (or +
+ + 150        (instance? ConsCell value) +
+ + 151        (number? value) +
+ + 152        (symbol? value) +
+ + 153        (= value NIL)) +
+ + 154        (try +
+ + 155          (.rplaca cell value) +
+ + 156          cell +
+ + 157          (catch Throwable any +
+ + 158            (throw (ex-info +
+ + 159                    (str (.getMessage any) " in RPLACA: `") +
+ + 160                    {:cause :upstream-error +
+ + 161                     :phase :host +
+ + 162                     :function :rplaca +
+ + 163                     :args (list cell value) +
+ + 164                     :type :beowulf} +
+ + 165                    any)))) +
+ + 166        (throw (ex-info +
+ + 167                (str "Un-ġefōg þing in RPLACA: `" value "` (" (type value) ")") +
+ + 168                {:cause :bad-value +
+ + 169                 :phase :host +
+ + 170                 :function :rplaca +
+ + 171                 :args (list cell value) +
+ + 172                 :type :beowulf}))) +
+ + 173      (throw (ex-info +
+ + 174              (str "Uncynlic miercels in RPLACA: `" cell "` (" (type cell) ")") +
+ + 175              {:cause :bad-cell +
+ + 176               :phase :host +
+ + 177               :function :rplaca +
+ + 178               :args (list cell value) +
+ + 179               :type :beowulf})))) +
+ + 180   +
+ + 181  (defn RPLACD +
+ + 182    "Replace the CDR pointer of this `cell` with this `value`. Dangerous, should +
+ + 183    really not exist, but does in Lisp 1.5 (and was important for some +
+ + 184    performance hacks in early Lisps)" +
+ + 185    [^ConsCell cell value] +
+ + 186    (if +
+ + 187     (instance? ConsCell cell) +
+ + 188      (if +
+ + 189       (or +
+ + 190        (instance? ConsCell value) +
+ + 191        (number? value) +
+ + 192        (symbol? value) +
+ + 193        (= value NIL)) +
+ + 194        (try +
+ + 195          (.rplacd cell value) +
+ + 196          cell +
+ + 197          (catch Throwable any +
+ + 198            (throw (ex-info +
+ + 199                    (str (.getMessage any) " in RPLACD: `") +
+ + 200                    {:cause :upstream-error +
+ + 201                     :phase :host +
+ + 202                     :function :rplacd +
+ + 203                     :args (list cell value) +
+ + 204                     :type :beowulf} +
+ + 205                    any)))) +
+ + 206        (throw (ex-info +
+ + 207                (str "Un-ġefōg þing in RPLACD: `" value "` (" (type value) ")") +
+ + 208                {:cause :bad-value +
+ + 209                 :phase :host +
+ + 210                 :function :rplacd +
+ + 211                 :args (list cell value) +
+ + 212                 :type :beowulf}))) +
+ + 213      (throw (ex-info +
+ + 214              (str "Uncynlic miercels in RPLACD: `" cell "` (" (type cell) ")") +
+ + 215              {:cause :bad-cell +
+ + 216               :phase :host +
+ + 217               :detail :rplacd +
+ + 218               :args (list cell value) +
+ + 219               :type :beowulf})))) +
+ + 220   +
+ + 221  (defn LIST +
+ + 222    [& args] +
+ + 223    (make-beowulf-list args)) +
+ + 224   +
+ + 225  ;;;; Basic predicates ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +
+ + 226   +
+ + 227  (defmacro NULL +
+ + 228    "Returns `T` if and only if the argument `x` is bound to `NIL`; else `F`." +
+ + 229    [x] +
+ + 230    `(if (= ~x NIL) T F)) +
+ + 231   +
+ + 232  (defmacro NILP +
+ + 233    "Not part of LISP 1.5: `T` if `o` is `NIL`, else `NIL`." +
+ + 234    [x] +
+ + 235    `(if (= ~x NIL) T NIL)) +
+ + 236   +
+ + 237  (defn ATOM +
+ + 238    "Returns `T` if and only if the argument `x` is bound to an atom; else `F`. +
+ + 239    It is not clear to me from the documentation whether `(ATOM 7)` should return +
+ + 240    `T` or `F`. I'm going to assume `T`." +
+ + 241    [x] +
+ + 242    (if (or (symbol? x) (number? x)) T F)) +
+ + 243   +
+ + 244  (defmacro ATOM? +
+ + 245    "The convention of returning `F` from predicates, rather than `NIL`, is going +
+ + 246    to tie me in knots. This is a variant of `ATOM` which returns `NIL` +
+ + 247    on failure." +
+ + 248    [x] +
+ + 249    `(if (or (symbol? ~x) (number? ~x)) T NIL)) +
+ + 250   +
+ + 251  (defn EQ +
+ + 252    "Returns `T` if and only if both `x` and `y` are bound to the same atom, +
+ + 253    else `NIL`." +
+ + 254    [x y] +
+ + 255    (cond (and (instance? ConsCell x) +
+ + 256               (.equals x y)) T +
+ + 257          (and (= (ATOM x) T) (= x y)) T +
+ + 258          :else NIL)) +
+ + 259   +
+ + 260  (defn EQUAL +
+ + 261    "This is a predicate that is true if its two arguments are identical +
+ + 262    S-expressions, and false if they are different. (The elementary predicate +
+ + 263    `EQ` is defined only for atomic arguments.) The definition of `EQUAL` is +
+ + 264    an example of a conditional expression inside a conditional expression. +
+ + 265   +
+ + 266    NOTE: returns `F` on failure, not `NIL`" +
+ + 267    [x y] +
+ + 268    (cond +
+ + 269      (= (ATOM x) T) (if (= x y) T F) +
+ + 270      (= (EQUAL (CAR x) (CAR y)) T) (EQUAL (CDR x) (CDR y)) +
+ + 271      :else F)) +
+ + 272   +
+ + 273  (defn AND +
+ + 274    "`T` if and only if none of my `args` evaluate to either `F` or `NIL`, +
+ + 275     else `F`. +
+ + 276      +
+ + 277     In `beowulf.host` principally because I don't yet feel confident to define +
+ + 278     varargs functions in Lisp." +
+ + 279    [& args] +
+ + 280    ;; (println "AND: " args " type: " (type args) " seq? " (seq? args)) +
+ + 281    ;; (println "  filtered: " (seq (filter #{F NIL} args))) +
+ + 282    (cond (= NIL args) T +
+ + 283          (seq? args) (if (seq (filter #{F NIL} args)) F T) +
+ + 284          :else T)) +
+ + 285   +
+ + 286   +
+ + 287  (defn OR +
+ + 288    "`T` if and only if at least one of my `args` evaluates to something other +
+ + 289    than either `F` or `NIL`, else `F`. +
+ + 290      +
+ + 291     In `beowulf.host` principally because I don't yet feel confident to define +
+ + 292     varargs functions in Lisp." +
+ + 293    [& args] +
+ + 294    ;; (println "OR: " args " type: " (type args) " seq? " (seq? args)) +
+ + 295    ;; (println "  filtered: " (seq (remove #{F NIL} args))) +
+ + 296    (cond (= NIL args) F +
+ + 297          (seq? args) (if (seq (remove #{F NIL} args)) T F) +
+ + 298          :else F)) +
+ + 299   +
+ + 300   +
+ + 301  ;;;; Operations on lists ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +
+ + 302  ;; +
+ + 303  ;; TODO: These are candidates for moving to Lisp urgently! +
+ + 304   +
+ + 305  (defn ASSOC +
+ + 306    "If a is an association list such as the one formed by PAIRLIS in the above +
+ + 307    example, then assoc will produce the first pair whose first term is x. Thus +
+ + 308    it is a table searching function. +
+ + 309   +
+ + 310    All args are assumed to be `beowulf.cons-cell/ConsCell` objects. +
+ + 311    See page 12 of the Lisp 1.5 Programmers Manual. +
+ + 312      +
+ + 313     **NOTE THAT** this function is overridden by an implementation in Lisp, +
+ + 314     but is currently still present for bootstrapping." +
+ + 315    [x a] +
+ + 316    (cond +
+ + 317      (= NIL a) NIL ;; this clause is not present in the original but is added for +
+ + 318      ;; robustness. +
+ + 319      (= (EQUAL (CAAR a) x) T) (CAR a) +
+ + 320      :else +
+ + 321      (ASSOC x (CDR a)))) +
+ + 322   +
+ + 323  (defn PAIRLIS +
+ + 324    "This function gives the list of pairs of corresponding elements of the +
+ + 325    lists `x` and `y`, and APPENDs this to the list `a`. The resultant list +
+ + 326    of pairs, which is like a table with two columns, is called an +
+ + 327    association list. +
+ + 328   +
+ + 329    Eessentially, it builds the environment on the stack, implementing shallow +
+ + 330    binding. +
+ + 331   +
+ + 332    All args are assumed to be `beowulf.cons-cell/ConsCell` objects. +
+ + 333    See page 12 of the Lisp 1.5 Programmers Manual. +
+ + 334      +
+ + 335     **NOTE THAT** this function is overridden by an implementation in Lisp, +
+ + 336     but is currently still present for bootstrapping." +
+ + 337    [x y a] +
+ + 338    (cond +
+ + 339      ;; the original tests only x; testing y as well will be a little more +
+ + 340      ;; robust if `x` and `y` are not the same length. +
+ + 341      (or (= NIL x) (= NIL y)) a +
+ + 342      :else (make-cons-cell +
+ + 343             (make-cons-cell (CAR x) (CAR y)) +
+ + 344             (PAIRLIS (CDR x) (CDR y) a)))) +
+ + 345   +
+ + 346  ;;;; Arithmetic ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +
+ + 347  ;; +
+ + 348  ;; TODO: When in strict mode, should we limit arithmetic precision to that +
+ + 349  ;; supported by Lisp 1.5? +
+ + 350   +
+ + 351  (defn PLUS +
+ + 352    [& args] +
+ + 353    (let [s (apply + args)] +
+ + 354      (if (integer? s) s (float s)))) +
+ + 355   +
+ + 356  (defn TIMES +
+ + 357    [& args] +
+ + 358    (let [p (apply * args)] +
+ + 359      (if (integer? p) p (float p)))) +
+ + 360   +
+ + 361  (defn DIFFERENCE +
+ + 362    [x y] +
+ + 363    (let [d (- x y)] +
+ + 364      (if (integer? d) d (float d)))) +
+ + 365   +
+ + 366  (defn QUOTIENT +
+ + 367    "I'm not certain from the documentation whether Lisp 1.5 `QUOTIENT` returned +
+ + 368    the integer part of the quotient, or a realnum representing the whole +
+ + 369    quotient. I am for now implementing the latter." +
+ + 370    [x y] +
+ + 371    (let [q (/ x y)] +
+ + 372      (if (integer? q) q (float q)))) +
+ + 373   +
+ + 374  (defn REMAINDER +
+ + 375    [x y] +
+ + 376    (rem x y)) +
+ + 377   +
+ + 378  (defn ADD1 +
+ + 379    [x] +
+ + 380    (inc x)) +
+ + 381   +
+ + 382  (defn SUB1 +
+ + 383    [x] +
+ + 384    (dec x)) +
+ + 385   +
+ + 386  (defn FIXP +
+ + 387    [x] +
+ + 388    (if (integer? x) T F)) +
+ + 389   +
+ + 390  (defn NUMBERP +
+ + 391    [x] +
+ + 392    (if (number? x) T F)) +
+ + 393   +
+ + 394  (defn LESSP +
+ + 395    [x y] +
+ + 396    (if (< x y) T F)) +
+ + 397   +
+ + 398  (defn GREATERP +
+ + 399    [x y] +
+ + 400    (if (> x y) T F)) +
+ + 401   +
+ + 402  ;;;; Miscellaneous ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +
+ + 403   +
+ + 404  (defn GENSYM +
+ + 405    "Generate a unique symbol." +
+ + 406    [] +
+ + 407    (symbol (upper-case (str (gensym "SYM"))))) +
+ + 408   +
+ + 409  (defn ERROR +
+ + 410    "Throw an error" +
+ + 411    [& args] +
+ + 412    (throw (ex-info "LISP STÆFLEAHTER" {:args args +
+ + 413                                        :phase :eval +
+ + 414                                        :function 'ERROR +
+ + 415                                        :type :lisp +
+ + 416                                        :code (or (first args) 'A1)}))) +
+ + 417   +
+ + 418  ;;;; Assignment and the object list ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +
+ + 419   +
+ + 420  (defn OBLIST +
+ + 421    "Return a list of the symbols currently bound on the object list. +
+ + 422      +
+ + 423     **NOTE THAT** in the Lisp 1.5 manual, footnote at the bottom of page 69, it implies  +
+ + 424     that an argument can be passed but I'm not sure of the semantics of +
+ + 425     this." +
+ + 426    [] +
+ + 427    (if (instance? ConsCell @oblist) +
+ + 428      (make-beowulf-list (map CAR @oblist)) +
+ + 429      NIL)) +
+ + 430   +
+ + 431  (def magic-marker +
+ + 432    "The unexplained magic number which marks the start of a property list." +
+ + 433    (Integer/parseInt "77777" 8)) +
+ + 434   +
+ + 435  (defn hit-or-miss-assoc +
+ + 436    "Find the position of the binding of this `target` in a Lisp 1.5  +
+ + 437     property list `plist`. +
+ + 438      +
+ + 439     Lisp 1.5 property lists are not assoc lists, but lists of the form +
+ + 440     `(name value name value name value...)`. It's therefore necessary to +
+ + 441     recurse down the list two entries at a time to avoid confusing names +
+ + 442     with values." +
+ + 443    [target plist] +
+ + 444    (if (and (instance? ConsCell plist) (even? (count plist))) +
+ + 445      (cond (= plist NIL) NIL +
+ + 446            (= (first plist) target) plist +
+ + 447            :else (hit-or-miss-assoc target (CDDR plist))) +
+ + 448      NIL)) +
+ + 449   +
+ + 450  (defn ATTRIB +
+ + 451    "Destructive append. From page 59 of the manual: +
+ + 452      +
+ + 453     The function `attrib` concatenates its two arguments by changing the last  +
+ + 454     element of its first argument to point to the second argument. Thus it +
+ + 455     is commonly used to tack something onto the end of a property list.  +
+ + 456     The value of `attrib` is the second argument. +
+ + 457   +
+ + 458     For example +
+ + 459     ``` +
+ + 460     attrib[FF; (EXPR (LAMBDA (X) (COND ((ATOM X) X) (T (FF (CAR x))))))] +
+ + 461     ``` +
+ + 462     would put EXPR followed by the LAMBDA expression for FF onto the end of  +
+ + 463     the property list for FF." +
+ + 464    [x e] +
+ + 465    (loop [l x] +
+ + 466      (cond +
+ + 467        (instance? ConsCell (CDR l)) (recur (CDR l)) +
+ + 468        :else (when (RPLACD l e) e)))) +
+ + 469   +
+ + 470  (defn PUT +
+ + 471    "Put this `value` as the value of the property indicated by this `indicator`  +
+ + 472     of this `symbol`. Return `value` on success. +
+ + 473      +
+ + 474     NOTE THAT there is no `PUT` defined in the manual, but it would have been  +
+ + 475     easy to have defined it so I don't think this fully counts as an extension." +
+ + 476    [symbol indicator value] +
+ + 477    (let [binding (ASSOC symbol @oblist)] +
+ + 478      (if (instance? ConsCell binding) +
+ + 479        (let [prop (hit-or-miss-assoc indicator (CDDR binding))] +
+ + 480          (if (instance? ConsCell prop) +
+ + 481            (RPLACA (CDR prop) value) +
+ + 482            ;; The implication is ATTRIB was used here, but I have not made that +
+ + 483            ;; work and this does work, so if it ain't broke don't fix it. +
+ + 484            (RPLACD binding +
+ + 485                    (make-cons-cell +
+ + 486                     magic-marker +
+ + 487                     (make-cons-cell +
+ + 488                      indicator +
+ + 489                      (make-cons-cell value (CDDR binding))))))) +
+ + 490        (swap! +
+ + 491         oblist +
+ + 492         (fn [ob s p v] +
+ + 493           (make-cons-cell +
+ + 494            (make-beowulf-list (list s magic-marker p v)) +
+ + 495            ob)) +
+ + 496         symbol indicator value))) +
+ + 497    value) +
+ + 498   +
+ + 499  (defn GET +
+ + 500    "From the manual: +
+ + 501      +
+ + 502     '`get` is somewhat like `prop`; however its value is car of the rest of +
+ + 503     the list if the `indicator` is found, and NIL otherwise.' +
+ + 504      +
+ + 505     It's clear that `GET` is expected to be defined in terms of `PROP`, but +
+ + 506     we can't implement `PROP` here because we lack `EVAL`; and we can't have +
+ + 507     `EVAL` here because both it and `APPLY` depends on `GET`. +
+ + 508      +
+ + 509     OK, It's worse than that: the statement of the definition of `GET` (and  +
+ + 510     of) `PROP` on page 59 says that the first argument to each must be a list; +
+ + 511     But the in the definition of `ASSOC` on page 70, when `GET` is called its +
+ + 512     first argument is always an atom. Since it's `ASSOC` and `EVAL` which I  +
+ + 513     need to make work, I'm going to assume that page 59 is wrong." +
+ + 514    [symbol indicator] +
+ + 515    (let [binding (ASSOC symbol @oblist) +
+ + 516          val (cond +
+ + 517                (= binding NIL) NIL +
+ + 518                (= magic-marker +
+ + 519                   (CADR binding)) (let [p (hit-or-miss-assoc indicator binding)] +
+ + 520                                     (if-not (= NIL p) +
+ + 521                                       (CADR p) +
+ + 522                                       NIL)) +
+ + 523                :else (throw +
+ + 524                       (ex-info "Misformatted property list (missing magic marker)" +
+ + 525                                {:phase :host +
+ + 526                                 :function :get +
+ + 527                                 :args (list symbol indicator) +
+ + 528                                 :type :beowulf})))] +
+ + 529      ;; (println "<< GET returning: " val) +
+ + 530      val)) +
+ + 531   +
+ + 532  (defn DEFLIST +
+ + 533    "For each pair in this association list `a-list`, set the property with this +
+ + 534     `indicator` of the symbol which is the first element of the pair to the  +
+ + 535     value which is the second element of the pair. See page 58 of the manual." +
+ + 536    [a-list indicator] +
+ + 537    (doall +
+ + 538     (map +
+ + 539      #(when (PUT (CAR %) indicator (CDR %)) (CAR %)) +
+ + 540      a-list))) +
+ + 541   +
+ + 542  (defn DEFINE +
+ + 543    "Bootstrap-only version of `DEFINE` which, post boostrap, can be overwritten  +
+ + 544    in LISP.  +
+ + 545   +
+ + 546    The single argument to `DEFINE` should be an association list of symbols to +
+ + 547     lambda functions. See page 58 of the manual." +
+ + 548    [a-list] +
+ + 549    (DEFLIST a-list 'EXPR)) +
+ + 550   +
+ + 551  (defn SET +
+ + 552    "Implementation of SET in Clojure. Add to the `oblist` a binding of the +
+ + 553     value of `var` to the value of `val`. NOTE WELL: this is not SETQ!" +
+ + 554    [symbol val] +
+ + 555    (PUT symbol 'APVAL val)) +
+ + 556   +
+ + 557  ;;;; TRACE and friends ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +
+ + 558   +
+ + 559  (def traced-symbols +
+ + 560    "Symbols currently being traced." +
+ + 561    (atom #{})) +
+ + 562   +
+ + 563  (defn traced? +
+ + 564    "Return `true` iff `s` is a symbol currently being traced, else `nil`." +
+ + 565    [s] +
+ + 566    (try (contains? @traced-symbols s) +
+ + 567         (catch Throwable _ nil))) +
+ + 568   +
+ + 569  (defn TRACE +
+ + 570    "Add this `s` to the set of symbols currently being traced. If `s` +
+ + 571     is not a symbol or sequence of symbols, does nothing." +
+ + 572    [s] +
+ + 573    (swap! traced-symbols +
+ + 574           #(cond +
+ + 575              (symbol? s) (conj % s) +
+ + 576              (and (seq? s) (every? symbol? s)) (union % (set s)) +
+ + 577              :else %))) +
+ + 578   +
+ + 579  (defn UNTRACE +
+ + 580    "Remove this `s` from the set of symbols currently being traced. If `s` +
+ + 581     is not a symbol or sequence of symbols, does nothing." +
+ + 582    [s] +
+ + 583    (cond +
+ + 584      (symbol? s) (swap! traced-symbols #(set (remove (fn [x] (= s x)) %))) +
+ + 585      (and (seq? s) (every? symbol? s)) (map UNTRACE s)) +
+ + 586    @traced-symbols) +
+ + 587   +
+ + 588  ;;;; Extensions ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +
+ + 589   +
+ + 590  (defn DOC +
+ + 591    "Open the page for this `symbol` in the Lisp 1.5 manual, if known, in the  +
+ + 592      default web browser. +
+ + 593      +
+ + 594     **NOTE THAT** this is an extension function, not available in strct mode." +
+ + 595    [symbol] +
+ + 596    (when (lax? 'DOC) +
+ + 597      (open-doc symbol))) +
+ + 598   +
+ + 599  (defn CONSP +
+ + 600    "Return `T` if object `o` is a cons cell, else `F`. +
+ + 601      +
+ + 602     **NOTE THAT** this is an extension function, not available in strct mode.  +
+ + 603     I believe that Lisp 1.5 did not have any mechanism for testing whether an +
+ + 604     argument was, or was not, a cons cell." +
+ + 605    [o] +
+ + 606    (when (lax? 'CONSP) +
+ + 607      (if (instance? ConsCell o) 'T 'F)))
diff --git a/docs/cloverage/beowulf/interop.clj.html b/docs/cloverage/beowulf/interop.clj.html new file mode 100644 index 0000000..0dd6c5c --- /dev/null +++ b/docs/cloverage/beowulf/interop.clj.html @@ -0,0 +1,395 @@ + + + + beowulf/interop.clj + + + + 001  (ns beowulf.interop +
+ + 002    (:require [beowulf.cons-cell :refer [make-beowulf-list]] +
+ + 003              [beowulf.host :refer [CAR CDR]] +
+ + 004              [beowulf.oblist :refer [*options* NIL]] +
+ + 005              [clojure.string :as s :refer [last-index-of lower-case split +
+ + 006                                            upper-case]])) +
+ + 007   +
+ + 008  ;;;; INTEROP feature ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +
+ + 009   +
+ + 010  (defn listify-qualified-name +
+ + 011    "We need to be able to print something we can link to the particular Clojure +
+ + 012     function `subr` in a form in which Lisp 1.5 is able to read it back in and +
+ + 013     relink it. +
+ + 014      +
+ + 015     This assumes `subr` is either  +
+ + 016     1. a string in the format `#'beowulf.io/SYSIN` or `beowulf.io/SYSIN`; or +
+ + 017     2. something which, when coerced to a string with `str`, will have such +
+ + 018        a format." +
+ + 019    [subr] +
+ + 020    (make-beowulf-list +
+ + 021     (map +
+ + 022      #(symbol (upper-case %)) +
+ + 023      (remove empty? (split (str subr) #"[#'./]"))))) +
+ + 024   +
+ + 025   +
+ + 026  (defn interpret-qualified-name +
+ + 027    "For interoperation with Clojure, it will often be necessary to pass +
+ + 028    qualified names that are not representable in Lisp 1.5. This function +
+ + 029    takes a sequence in the form `(PART PART PART... NAME)` and returns +
+ + 030    a symbol in the form `part.part.part/NAME`. This symbol will then be +
+ + 031    tried in both that form and lower-cased. Names with hyphens or +
+ + 032    underscores cannot be represented with this scheme." +
+ + 033    ([l] +
+ + 034     (symbol +
+ + 035      (let [n (s/join "."  +
+ + 036                      (concat (map #(lower-case (str %)) (butlast l))  +
+ + 037                              (list (last l)))) +
+ + 038            s (last-index-of n ".")] +
+ + 039        (if s +
+ + 040          (str (subs n 0 s) "/" (subs n (inc s))) +
+ + 041          n))))) +
+ + 042   +
+ + 043  (defn to-beowulf +
+ + 044    "Return a beowulf-native representation of the Clojure object `o`. +
+ + 045    Numbers and symbols are unaffected. Collections have to be converted; +
+ + 046    strings must be converted to symbols." +
+ + 047    [o] +
+ + 048    (cond +
+ + 049      (coll? o) (make-beowulf-list o) +
+ + 050      (string? o) (symbol (s/upper-case o)) +
+ + 051      :else o)) +
+ + 052   +
+ + 053  (defn to-clojure +
+ + 054    "If l is a `beowulf.cons_cell.ConsCell`, return a Clojure list having the  +
+ + 055    same members in the same order." +
+ + 056    [l] +
+ + 057    (cond +
+ + 058      (not (instance? beowulf.cons_cell.ConsCell l)) +
+ + 059      l +
+ + 060      (= (CDR l) NIL) +
+ + 061      (list (to-clojure (CAR l))) +
+ + 062      :else +
+ + 063      (conj (to-clojure (CDR l)) (to-clojure (CAR l))))) +
+ + 064   +
+ + 065  (defn INTEROP +
+ + 066    "Clojure (or other host environment) interoperation API. `fn-symbol` is expected +
+ + 067    to be either +
+ + 068   +
+ + 069    1. a symbol bound in the host environment to a function; or +
+ + 070    2. a sequence (list) of symbols forming a qualified path name bound to a +
+ + 071       function. +
+ + 072   +
+ + 073    Lower case characters cannot normally be represented in Lisp 1.5, so both the +
+ + 074    upper case and lower case variants of `fn-symbol` will be tried. If the +
+ + 075    function you're looking for has a mixed case name, that is not currently +
+ + 076    accessible. +
+ + 077   +
+ + 078    `args` is expected to be a Lisp 1.5 list of arguments to be passed to that +
+ + 079    function. Return value must be something acceptable to Lisp 1.5, so either +
+ + 080    a symbol, a number, or a Lisp 1.5 list. +
+ + 081   +
+ + 082    If `fn-symbol` is not found (even when cast to lower case), or is not a function, +
+ + 083    or the value returned cannot be represented in Lisp 1.5, an exception is thrown +
+ + 084    with `:cause` bound to `:interop` and `:detail` set to a value representing the +
+ + 085    actual problem." +
+ + 086    [fn-symbol args] +
+ + 087    (if-not (:strict *options*) +
+ + 088      (let +
+ + 089       [q-name (if +
+ + 090                (seq? fn-symbol) +
+ + 091                 (interpret-qualified-name fn-symbol) +
+ + 092                 fn-symbol) +
+ + 093        l-name (symbol (s/lower-case q-name)) +
+ + 094        f      (cond +
+ + 095                 (try +
+ + 096                   (fn? (eval l-name)) +
+ + 097                   (catch java.lang.ClassNotFoundException _ nil)) l-name +
+ + 098                 (try +
+ + 099                   (fn? (eval q-name)) +
+ + 100                   (catch java.lang.ClassNotFoundException _ nil)) q-name +
+ + 101                 :else (throw +
+ + 102                        (ex-info +
+ + 103                         (str "INTEROP: ungecnáwen þegnung `" fn-symbol "`") +
+ + 104                         {:cause      :interop +
+ + 105                          :detail     :not-found +
+ + 106                          :name       fn-symbol +
+ + 107                          :also-tried l-name}))) +
+ + 108        args'  (to-clojure args)] +
+ + 109  ;;      (print (str "INTEROP: eahtiende `" (cons f args') "`")) +
+ + 110        (flush) +
+ + 111        (let [result (eval (conj args' f))] ;; this has the potential to blow up the world +
+ + 112  ;;        (println (str "; ágiefende `" result "`")) +
+ + 113          (cond +
+ + 114            (instance? beowulf.cons_cell.ConsCell result) result +
+ + 115            (coll? result) (make-beowulf-list result) +
+ + 116            (symbol? result) result +
+ + 117            (string? result) (symbol result) +
+ + 118            (number? result) result +
+ + 119            :else (throw +
+ + 120                   (ex-info +
+ + 121                    (str "INTEROP: Ne can eahtiende `" result "` to Lisp 1.5.") +
+ + 122                    {:cause  :interop +
+ + 123                     :detail :not-representable +
+ + 124                     :result result}))))) +
+ + 125      (throw +
+ + 126       (ex-info +
+ + 127        (str "INTEROP ne āfand innan Lisp 1.5.") +
+ + 128        {:cause  :interop +
+ + 129         :detail :strict})))) +
+ + diff --git a/docs/cloverage/beowulf/io.clj.html b/docs/cloverage/beowulf/io.clj.html new file mode 100644 index 0000000..aaf97e7 --- /dev/null +++ b/docs/cloverage/beowulf/io.clj.html @@ -0,0 +1,530 @@ + + + + beowulf/io.clj + + + + 001  (ns beowulf.io +
+ + 002    "Non-standard extensions to Lisp 1.5 to read and write to the filesystem. +
+ + 003      +
+ + 004     Lisp 1.5 had only `READ`, which read one S-Expression at a time, and  +
+ + 005     various forms of `PRIN*` functions, which printed to the line printer.  +
+ + 006     There was also `PUNCH`, which wrote to a card punch. It does not seem  +
+ + 007     that there was any concept of an interactive terminal. +
+ + 008      +
+ + 009     See Appendix E, `OVERLORD - THE MONITOR`, and Appendix F, `LISP INPUT +
+ + 010     AND OUTPUT`. +
+ + 011      +
+ + 012     For our purposes, to save the current state of the Lisp system it should +
+ + 013     be sufficient to print the current contents of the oblist to file; and to +
+ + 014     restore a previous state from file, to overwrite the contents of the  +
+ + 015     oblist with data from that file. +
+ + 016      +
+ + 017     Hence functions SYSOUT and SYSIN, which do just that." +
+ + 018    (:require [beowulf.cons-cell :refer [make-beowulf-list make-cons-cell +
+ + 019                                         pretty-print]] +
+ + 020              [beowulf.host :refer [CADR CAR CDDR CDR]] +
+ + 021              [beowulf.interop :refer [interpret-qualified-name +
+ + 022                                       listify-qualified-name]] +
+ + 023              [beowulf.oblist :refer [*options* NIL oblist]] +
+ + 024              [beowulf.read :refer [READ]] +
+ + 025              [clojure.java.io :refer [file resource]] +
+ + 026              [clojure.string :refer [ends-with?]] +
+ + 027              [java-time.api :refer [local-date local-date-time]])) +
+ + 028   +
+ + 029  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +
+ + 030  ;;; +
+ + 031  ;;; Copyright (C) 2022-2023 Simon Brooke +
+ + 032  ;;; +
+ + 033  ;;; This program is free software; you can redistribute it and/or +
+ + 034  ;;; modify it under the terms of the GNU General Public License +
+ + 035  ;;; as published by the Free Software Foundation; either version 2 +
+ + 036  ;;; of the License, or (at your option) any later version. +
+ + 037  ;;;  +
+ + 038  ;;; This program is distributed in the hope that it will be useful, +
+ + 039  ;;; but WITHOUT ANY WARRANTY; without even the implied warranty of +
+ + 040  ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the +
+ + 041  ;;; GNU General Public License for more details. +
+ + 042  ;;;  +
+ + 043  ;;; You should have received a copy of the GNU General Public License +
+ + 044  ;;; along with this program; if not, write to the Free Software +
+ + 045  ;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA. +
+ + 046  ;;; +
+ + 047  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +
+ + 048   +
+ + 049  (def ^:constant default-sysout "lisp1.5.lsp") +
+ + 050   +
+ + 051  (defn- full-path +
+ + 052    [fp] +
+ + 053    (str +
+ + 054     (if (:filepath *options*) +
+ + 055       (str (:filepath *options*) (java.io.File/separator)) +
+ + 056       "") +
+ + 057     (if (and (string? fp) +
+ + 058              (> (count fp) 0) +
+ + 059              (not= fp "NIL")) +
+ + 060       fp +
+ + 061       (str "Sysout-" (local-date))) +
+ + 062     (if (ends-with? fp ".lsp") +
+ + 063       "" +
+ + 064       ".lsp"))) +
+ + 065   +
+ + 066  ;; (find-var (symbol "beowulf.io/SYSIN")) +
+ + 067  ;; (@(resolve (symbol "beowulf.host/TIMES")) 2 2) +
+ + 068   +
+ + 069  (defn safely-wrap-subr +
+ + 070    [entry] +
+ + 071    (cond (= entry NIL) NIL +
+ + 072          (= (CAR entry) 'SUBR) (make-cons-cell +
+ + 073                                 (CAR entry) +
+ + 074                                 (make-cons-cell +
+ + 075                                  (listify-qualified-name (CADR entry)) +
+ + 076                                  (CDDR entry))) +
+ + 077          :else (make-cons-cell +
+ + 078                 (CAR entry) (safely-wrap-subr (CDR entry))))) +
+ + 079   +
+ + 080  (defn safely-wrap-subrs +
+ + 081    [objects] +
+ + 082    (make-beowulf-list (map safely-wrap-subr objects))) +
+ + 083   +
+ + 084  (defn SYSOUT +
+ + 085    "Dump the current content of the object list to file. If no `filepath` is +
+ + 086     specified, a file name will be constructed of the symbol `Sysout` and  +
+ + 087     the current date. File paths will be considered relative to the filepath +
+ + 088     set when starting Lisp. +
+ + 089      +
+ + 090     **NOTE THAT** this is an extension function, not available in strct mode." +
+ + 091    ([] +
+ + 092     (SYSOUT nil)) +
+ + 093    ([filepath] +
+ + 094     (let [destination (full-path (str filepath))] +
+ + 095      (spit destination +
+ + 096           (with-out-str +
+ + 097             (println (apply str (repeat 79 ";"))) +
+ + 098             (println (format ";; Beowulf %s Sysout file generated at %s" +
+ + 099                              (or (System/getProperty "beowulf.version") "") +
+ + 100                              (local-date-time))) +
+ + 101             (when (System/getenv "USER") +
+ + 102               (println (format ";; generated by %s" (System/getenv "USER")))) +
+ + 103             (println (apply str (repeat 79 ";"))) +
+ + 104             (println) +
+ + 105             (let [output (safely-wrap-subrs @oblist)] +
+ + 106               (pretty-print output) +
+ + 107               ))) +
+ + 108       (println "Saved sysout to " destination) +
+ + 109       NIL))) +
+ + 110   +
+ + 111  (defn resolve-subr +
+ + 112    "If this oblist `entry` references a subroutine, attempt to fix up that +
+ + 113     reference." +
+ + 114    ([entry] +
+ + 115     (or (resolve-subr entry 'SUBR) +
+ + 116         (resolve-subr entry 'FSUBR))) +
+ + 117    ([entry prop] +
+ + 118     (cond (= entry NIL) NIL +
+ + 119          (= (CAR entry) prop) (try +
+ + 120                                  (make-cons-cell +
+ + 121                                   (CAR entry) +
+ + 122                                   (make-cons-cell +
+ + 123                                    (interpret-qualified-name +
+ + 124                                           (CADR entry)) +
+ + 125                                    (CDDR entry))) +
+ + 126                                  (catch Exception _ +
+ + 127                                    (print "Warnung: ne can āfinde " +
+ + 128                                           (CADR entry)) +
+ + 129                                    (CDDR entry))) +
+ + 130          :else (make-cons-cell +
+ + 131                 (CAR entry) (resolve-subr (CDR entry)))))) +
+ + 132   +
+ + 133   +
+ + 134  (defn- resolve-subroutines +
+ + 135    "Attempt to fix up the references to subroutines (Clojure functions) among +
+ + 136     these `objects`, being new content for the object list." +
+ + 137    [objects] +
+ + 138    (make-beowulf-list +
+ + 139     (map +
+ + 140      resolve-subr +
+ + 141      objects))) +
+ + 142   +
+ + 143  (defn SYSIN +
+ + 144    "Read the contents of the file at this `filename` into the object list.  +
+ + 145      +
+ + 146     If the file is not a valid Beowulf sysout file, this will probably  +
+ + 147     corrupt the system, you have been warned. File paths will be considered  +
+ + 148     relative to the filepath set when starting Lisp. +
+ + 149   +
+ + 150     It is intended that sysout files can be read both from resources within +
+ + 151     the jar file, and from the file system. If a named file exists in both the +
+ + 152     file system and the resources, the file system will be preferred. +
+ + 153      +
+ + 154     **NOTE THAT** if the provided `filename` does not end with `.lsp` (which, +
+ + 155     if you're writing it from the Lisp REPL, it won't), the extension `.lsp` +
+ + 156     will be appended. +
+ + 157      +
+ + 158     **NOTE THAT** this is an extension function, not available in strct mode." +
+ + 159    ([] +
+ + 160     (SYSIN (or (:read *options*) (str "resources/" default-sysout)))) +
+ + 161    ([filename] +
+ + 162     (let [fp (file (full-path (str filename))) +
+ + 163           file (when (and (.exists fp) (.canRead fp)) fp) +
+ + 164           res (try (resource filename) +
+ + 165                    (catch Throwable _ nil)) +
+ + 166           content (try (READ (slurp (or file res))) +
+ + 167                        (catch Throwable _ +
+ + 168                          (throw (ex-info "Ne can ārǣde" +
+ + 169                                          {:context "SYSIN" +
+ + 170                                           :filename filename +
+ + 171                                           :filepath fp}))))] +
+ + 172       (swap! oblist +
+ + 173              #(when (or % (seq content)) +
+ + 174                 (resolve-subroutines content)))))) +
+ + diff --git a/docs/cloverage/beowulf/manual.clj.html b/docs/cloverage/beowulf/manual.clj.html new file mode 100644 index 0000000..b80738c --- /dev/null +++ b/docs/cloverage/beowulf/manual.clj.html @@ -0,0 +1,2315 @@ + + + + beowulf/manual.clj + + + + 001  (ns beowulf.manual +
+ + 002    "Experimental code for accessing the manual online." +
+ + 003    (:require [clojure.string :refer [ends-with? join trim]])) +
+ + 004   +
+ + 005  (def ^:dynamic *manual-url* +
+ + 006    "https://www.softwarepreservation.org/projects/LISP/book/LISP%201.5%20Programmers%20Manual.pdf") +
+ + 007   +
+ + 008  (def ^:constant index +
+ + 009    "This is data extracted from the index pages of `Lisp 1.5 Programmer's Manual`. +
+ + 010     It's here in the hope that we can automatically link to an online PDF link +
+ + 011     to the manual when the user invokes a function probably called `DOC` or `HELP`." +
+ + 012    {:RECIP +
+ + 013     {:fn-name "RECIP", +
+ + 014      :call-type "SUBR", +
+ + 015      :implementation "", +
+ + 016      :page-nos ["26" "64"]}, +
+ + 017     :QUOTE +
+ + 018     {:fn-name "QUOTE", +
+ + 019      :call-type "FSUBR", +
+ + 020      :implementation "", +
+ + 021      :page-nos ["10" "22" "71"]}, +
+ + 022     :RECLAIM +
+ + 023     {:fn-name "RECLAIM", +
+ + 024      :call-type "SUBR", +
+ + 025      :implementation "PSEUDO-FUNCTION ", +
+ + 026      :page-nos ["67"]}, +
+ + 027     :NUMOB +
+ + 028     {:fn-name "NUMOB", +
+ + 029      :call-type "SUBR", +
+ + 030      :implementation "PSEUDO-FUNCTION ", +
+ + 031      :page-nos ["86"]}, +
+ + 032     :EVLIS +
+ + 033     {:fn-name "EVLIS", +
+ + 034      :call-type "SUBR", +
+ + 035      :implementation "", +
+ + 036      :page-nos ["71"]}, +
+ + 037     :DASH +
+ + 038     {:fn-name "DASH", +
+ + 039      :call-type "SUBR", +
+ + 040      :implementation "PREDICATE APVAL", +
+ + 041      :page-nos ["85" "87 "]}, +
+ + 042     :EQUAL +
+ + 043     {:fn-name "EQUAL", +
+ + 044      :call-type "SUBR", +
+ + 045      :implementation "PREDICATE", +
+ + 046      :page-nos ["11" "26" "57"]}, +
+ + 047     :PRIN1 +
+ + 048     {:fn-name "PRIN1", +
+ + 049      :call-type "SUBR", +
+ + 050      :implementation "PSEUDO-FUNCTION ", +
+ + 051      :page-nos ["65" "84"]}, +
+ + 052     :REMFLAG +
+ + 053     {:fn-name "REMFLAG", +
+ + 054      :call-type "SUBR", +
+ + 055      :implementation "PSEUDO-FUNCTION ", +
+ + 056      :page-nos ["41" "60"]}, +
+ + 057     :DEFINE +
+ + 058     {:fn-name "DEFINE", +
+ + 059      :call-type "EXPR", +
+ + 060      :implementation "PSEUDO-FUNCTION", +
+ + 061      :page-nos ["15" "18" "58"]}, +
+ + 062     :PUNCHLAP +
+ + 063     {:fn-name "PUNCHLAP", +
+ + 064      :call-type "EXPR", +
+ + 065      :implementation "PSEUDO-FUNCTION LIBRARY", +
+ + 066      :page-nos ["68" "76"]}, +
+ + 067     :STARTREAD +
+ + 068     {:fn-name "STARTREAD", +
+ + 069      :call-type "SUBR", +
+ + 070      :implementation "PSEUDO-FUNCTION", +
+ + 071      :page-nos ["87"]}, +
+ + 072     :PERIOD +
+ + 073     {:fn-name "PERIOD", +
+ + 074      :call-type "APVAL", +
+ + 075      :implementation "", +
+ + 076      :page-nos ["69" "85"]}, +
+ + 077     :CP1 +
+ + 078     {:fn-name "CP1", +
+ + 079      :call-type "SUBR", +
+ + 080      :implementation "", +
+ + 081      :page-nos ["66"]}, +
+ + 082     :NCONC +
+ + 083     {:fn-name "NCONC", +
+ + 084      :call-type "SUBR", +
+ + 085      :implementation "PSEUDO-FUNCTION ", +
+ + 086      :page-nos ["62"]}, +
+ + 087     :EQ +
+ + 088     {:fn-name "EQ", +
+ + 089      :call-type "SUBR", +
+ + 090      :implementation "PREDICATE", +
+ + 091      :page-nos ["3" "23" "57"]}, +
+ + 092     :RPLACD +
+ + 093     {:fn-name "RPLACD", +
+ + 094      :call-type "SUBR", +
+ + 095      :implementation "PSEUDO-FUNCTION", +
+ + 096      :page-nos ["41" "58"]}, +
+ + 097     :PROG2 +
+ + 098     {:fn-name "PROG2", +
+ + 099      :call-type "SUBR", +
+ + 100      :implementation "", +
+ + 101      :page-nos ["42" "66"]}, +
+ + 102     :UNCOUNT +
+ + 103     {:fn-name "UNCOUNT", +
+ + 104      :call-type "SUBR", +
+ + 105      :implementation "PSEUDO-FUNCTION", +
+ + 106      :page-nos ["34" "66"]}, +
+ + 107     :ERROR1 +
+ + 108     {:fn-name "ERROR1", +
+ + 109      :call-type "SUBR", +
+ + 110      :implementation "PSEUDO-FUNCTION", +
+ + 111      :page-nos ["88"]}, +
+ + 112     :EXPT +
+ + 113     {:fn-name "EXPT", +
+ + 114      :call-type "SUBR", +
+ + 115      :implementation "", +
+ + 116      :page-nos ["26" "64"]}, +
+ + 117     :NOT +
+ + 118     {:fn-name "NOT", +
+ + 119      :call-type "SUBR", +
+ + 120      :implementation "PREDICATE", +
+ + 121      :page-nos ["21" "23" "58"]}, +
+ + 122     :SLASH +
+ + 123     {:fn-name "SLASH", +
+ + 124      :call-type "APVAL", +
+ + 125      :implementation "", +
+ + 126      :page-nos ["69" "85"]}, +
+ + 127     :RPLACA +
+ + 128     {:fn-name "RPLACA", +
+ + 129      :call-type "SUBR", +
+ + 130      :implementation "PSEUDO-FUNCTION", +
+ + 131      :page-nos ["41" "58"]}, +
+ + 132     :QUOTIENT +
+ + 133     {:fn-name "QUOTIENT", +
+ + 134      :call-type "SUBR", +
+ + 135      :implementation "", +
+ + 136      :page-nos ["26" "64"]}, +
+ + 137     :UNPACK +
+ + 138     {:fn-name "UNPACK", +
+ + 139      :call-type "SUBR", +
+ + 140      :implementation "PSEUDO-FUNCTION", +
+ + 141      :page-nos ["87"]}, +
+ + 142     :CONC +
+ + 143     {:fn-name "CONC", +
+ + 144      :call-type "FEXPR", +
+ + 145      :implementation "", +
+ + 146      :page-nos ["61"]}, +
+ + 147     :CAR +
+ + 148     {:fn-name "CAR", +
+ + 149      :call-type "SUBR", +
+ + 150      :implementation "", +
+ + 151      :page-nos ["2" "56"]}, +
+ + 152     :GENSYM +
+ + 153     {:fn-name "GENSYM", +
+ + 154      :call-type "SUBR", +
+ + 155      :implementation "", +
+ + 156      :page-nos ["66"]}, +
+ + 157     :PROP +
+ + 158     {:fn-name "PROP", +
+ + 159      :call-type "SUBR", +
+ + 160      :implementation "FUNCTIONAL ", +
+ + 161      :page-nos [" 59"]}, +
+ + 162     :MEMBER +
+ + 163     {:fn-name "MEMBER", +
+ + 164      :call-type "SUBR", +
+ + 165      :implementation "PREDICATE ", +
+ + 166      :page-nos ["11" "62"]}, +
+ + 167     :UNTRACESET +
+ + 168     {:fn-name "UNTRACESET", +
+ + 169      :call-type "EXPR", +
+ + 170      :implementation "PSEUDO-FUNCTION", +
+ + 171      :page-nos ["68"]}, +
+ + 172     :UNTRACE +
+ + 173     {:fn-name "UNTRACE", +
+ + 174      :call-type "EXPR", +
+ + 175      :implementation "PSEUDO-FUNCTION", +
+ + 176      :page-nos ["32" "66"]}, +
+ + 177     :MINUSP +
+ + 178     {:fn-name "MINUSP", +
+ + 179      :call-type "SUBR", +
+ + 180      :implementation "PREDICATE ", +
+ + 181      :page-nos ["26" "64"]}, +
+ + 182     :F +
+ + 183     {:fn-name "F", +
+ + 184      :call-type "APVAL", +
+ + 185      :implementation "", +
+ + 186      :page-nos ["22" "69"]}, +
+ + 187     :SPECIAL +
+ + 188     {:fn-name "SPECIAL", +
+ + 189      :call-type "SUBR", +
+ + 190      :implementation "PSEUDO-FUNCTION", +
+ + 191      :page-nos ["64" "78"]}, +
+ + 192     :LPAR +
+ + 193     {:fn-name "LPAR", +
+ + 194      :call-type "APVAL", +
+ + 195      :implementation "", +
+ + 196      :page-nos ["69" "85"]}, +
+ + 197     :GO +
+ + 198     {:fn-name "GO", +
+ + 199      :call-type "FSUBR", +
+ + 200      :implementation "PSEUDO-FUNCTION", +
+ + 201      :page-nos ["30" "72"]}, +
+ + 202     :MKNAM +
+ + 203     {:fn-name "MKNAM", +
+ + 204      :call-type "SUBR", +
+ + 205      :implementation "", +
+ + 206      :page-nos ["86"]}, +
+ + 207     :COMMON +
+ + 208     {:fn-name "COMMON", +
+ + 209      :call-type "SUBR", +
+ + 210      :implementation "PSEUDO-FUNCTION", +
+ + 211      :page-nos ["64" "78"]}, +
+ + 212     :NUMBERP +
+ + 213     {:fn-name "NUMBERP", +
+ + 214      :call-type "SUBR", +
+ + 215      :implementation "PREDICATE ", +
+ + 216      :page-nos ["26" "64"]}, +
+ + 217     :CONS +
+ + 218     {:fn-name "CONS", +
+ + 219      :call-type "SUBR", +
+ + 220      :implementation "", +
+ + 221      :page-nos ["2" "56"]}, +
+ + 222     :PLUS +
+ + 223     {:fn-name "PLUS", +
+ + 224      :call-type "FSUBR", +
+ + 225      :implementation "", +
+ + 226      :page-nos ["25" "63"]}, +
+ + 227     :SET +
+ + 228     {:fn-name "SET", +
+ + 229      :call-type "SUBR", +
+ + 230      :implementation "PSEUDO-FUNCTION", +
+ + 231      :page-nos ["30" "71"]}, +
+ + 232     :DOLLAR +
+ + 233     {:fn-name "DOLLAR", +
+ + 234      :call-type "APVAL", +
+ + 235      :implementation "", +
+ + 236      :page-nos ["69" "85"]}, +
+ + 237     :SASSOC +
+ + 238     {:fn-name "SASSOC", +
+ + 239      :call-type "SUBR", +
+ + 240      :implementation "FUNCTIONAL", +
+ + 241      :page-nos ["60"]}, +
+ + 242     :SELECT +
+ + 243     {:fn-name "SELECT", +
+ + 244      :call-type "FEXPR", +
+ + 245      :implementation "", +
+ + 246      :page-nos ["66"]}, +
+ + 247     :OPDEFINE +
+ + 248     {:fn-name "OPDEFINE", +
+ + 249      :call-type "EXPR", +
+ + 250      :implementation "PSEUDO-FUNCTION ", +
+ + 251      :page-nos ["65" "75"]}, +
+ + 252     :PAUSE +
+ + 253     {:fn-name "PAUSE", +
+ + 254      :call-type "SUBR", +
+ + 255      :implementation "PSEUDO-FUNCTION", +
+ + 256      :page-nos ["67"]}, +
+ + 257     :AND +
+ + 258     {:fn-name "AND", +
+ + 259      :call-type "FSUBR", +
+ + 260      :implementation "PREDICATE", +
+ + 261      :page-nos ["21" "58"]}, +
+ + 262     :COMMA +
+ + 263     {:fn-name "COMMA", +
+ + 264      :call-type "APVAL", +
+ + 265      :implementation "", +
+ + 266      :page-nos ["69" "85"]}, +
+ + 267     :EFFACE +
+ + 268     {:fn-name "EFFACE", +
+ + 269      :call-type "SUBR", +
+ + 270      :implementation "PSEUDO-FUNCTION", +
+ + 271      :page-nos ["63"]}, +
+ + 272     :CSETQ +
+ + 273     {:fn-name "CSETQ", +
+ + 274      :call-type "FEXPR", +
+ + 275      :implementation "PSEUDO-FUNCTION", +
+ + 276      :page-nos ["59"]}, +
+ + 277     :OPCHAR +
+ + 278     {:fn-name "OPCHAR", +
+ + 279      :call-type "SUBR", +
+ + 280      :implementation "PREDICATE ", +
+ + 281      :page-nos [" 87"]}, +
+ + 282     :PRINTPROP +
+ + 283     {:fn-name "PRINTPROP", +
+ + 284      :call-type "EXPR", +
+ + 285      :implementation "PSEUDO-FUNCTION LIBRARY ", +
+ + 286      :page-nos ["68"]}, +
+ + 287     :PLB +
+ + 288     {:fn-name "PLB", +
+ + 289      :call-type "SUBR", +
+ + 290      :implementation "PSEUDO- FUNCTION", +
+ + 291      :page-nos ["67"]}, +
+ + 292     :DIGIT +
+ + 293     {:fn-name "DIGIT", +
+ + 294      :call-type "SUBR", +
+ + 295      :implementation "PREDICATE ", +
+ + 296      :page-nos ["87"]}, +
+ + 297     :PUNCHDEF +
+ + 298     {:fn-name "PUNCHDEF", +
+ + 299      :call-type "EXPR", +
+ + 300      :implementation "PSEUDO-FUNCTION LIBRARY", +
+ + 301      :page-nos ["68"]}, +
+ + 302     :ARRAY +
+ + 303     {:fn-name "ARRAY", +
+ + 304      :call-type "SUBR", +
+ + 305      :implementation "PSEUDO-FUNCTION", +
+ + 306      :page-nos ["27" "64"]}, +
+ + 307     :MAX +
+ + 308     {:fn-name "MAX", +
+ + 309      :call-type "FSUBR", +
+ + 310      :implementation "", +
+ + 311      :page-nos ["26" "64"]}, +
+ + 312     :INTERN +
+ + 313     {:fn-name "INTERN", +
+ + 314      :call-type "SUBR", +
+ + 315      :implementation "PSEUDO-FUNCTION", +
+ + 316      :page-nos ["67" "87"]}, +
+ + 317     :NIL +
+ + 318     {:fn-name "NIL", +
+ + 319      :call-type "APVAL", +
+ + 320      :implementation "", +
+ + 321      :page-nos ["22" "69"]}, +
+ + 322     :TIMES +
+ + 323     {:fn-name "TIMES", +
+ + 324      :call-type "FSUBR", +
+ + 325      :implementation "", +
+ + 326      :page-nos ["26" "64"]}, +
+ + 327     :ERROR +
+ + 328     {:fn-name "ERROR", +
+ + 329      :call-type "SUBR", +
+ + 330      :implementation "PSEUDO-FUNCTION", +
+ + 331      :page-nos ["32" "66"]}, +
+ + 332     :PUNCH +
+ + 333     {:fn-name "PUNCH", +
+ + 334      :call-type "SUBR", +
+ + 335      :implementation "PSEUDO-FUNCTION", +
+ + 336      :page-nos ["65" "84"]}, +
+ + 337     :REMPROP +
+ + 338     {:fn-name "REMPROP", +
+ + 339      :call-type "SUBR", +
+ + 340      :implementation "PSEUDO-FUNCTION", +
+ + 341      :page-nos ["41" "59"]}, +
+ + 342     :DIVIDE +
+ + 343     {:fn-name "DIVIDE", +
+ + 344      :call-type "SUBR", +
+ + 345      :implementation "", +
+ + 346      :page-nos ["26" "64"]}, +
+ + 347     :OR +
+ + 348     {:fn-name "OR", +
+ + 349      :call-type "FSUBR", +
+ + 350      :implementation "PREDICATE ", +
+ + 351      :page-nos ["21" "58"]}, +
+ + 352     :SUBLIS +
+ + 353     {:fn-name "SUBLIS", +
+ + 354      :call-type "SUBR", +
+ + 355      :implementation "", +
+ + 356      :page-nos ["12" "61"]}, +
+ + 357     :LAP +
+ + 358     {:fn-name "LAP", +
+ + 359      :call-type "SUBR", +
+ + 360      :implementation "PSEUDO-FUNCTION ", +
+ + 361      :page-nos ["65" "73"]}, +
+ + 362     :PROG +
+ + 363     {:fn-name "PROG", +
+ + 364      :call-type "FSUBR", +
+ + 365      :implementation "", +
+ + 366      :page-nos ["29" "71"]}, +
+ + 367     :T +
+ + 368     {:fn-name "T", +
+ + 369      :call-type "APVAL", +
+ + 370      :implementation "", +
+ + 371      :page-nos ["22" "69"]}, +
+ + 372     :GREATERP +
+ + 373     {:fn-name "GREATERP", +
+ + 374      :call-type "SUBR", +
+ + 375      :implementation "PREDICATE", +
+ + 376      :page-nos ["26" "64"]}, +
+ + 377     :CSET +
+ + 378     {:fn-name "CSET", +
+ + 379      :call-type "EXPR", +
+ + 380      :implementation "PSEUDO-FUNCTION", +
+ + 381      :page-nos ["17" "59"]}, +
+ + 382     :FUNCTION +
+ + 383     {:fn-name "FUNCTION", +
+ + 384      :call-type "FSUBR", +
+ + 385      :implementation "", +
+ + 386      :page-nos ["21" "71"]}, +
+ + 387     :LENGTH +
+ + 388     {:fn-name "LENGTH", +
+ + 389      :call-type "SUBR", +
+ + 390      :implementation "", +
+ + 391      :page-nos ["62"]}, +
+ + 392     :MINUS +
+ + 393     {:fn-name "MINUS", +
+ + 394      :call-type "SUBR", +
+ + 395      :implementation "", +
+ + 396      :page-nos ["26" "63"]}, +
+ + 397     :COND +
+ + 398     {:fn-name "COND", +
+ + 399      :call-type "FSUBR", +
+ + 400      :implementation "", +
+ + 401      :page-nos ["18"]}, +
+ + 402     :APPEND +
+ + 403     {:fn-name "APPEND", +
+ + 404      :call-type "SUBR", +
+ + 405      :implementation "", +
+ + 406      :page-nos ["11" "61"]}, +
+ + 407     :CDR +
+ + 408     {:fn-name "CDR", +
+ + 409      :call-type "SUBR", +
+ + 410      :implementation "", +
+ + 411      :page-nos ["3" "56"]}, +
+ + 412     :OBLIST +
+ + 413     {:fn-name "OBLIST", +
+ + 414      :call-type "APVAL", +
+ + 415      :implementation "", +
+ + 416      :page-nos ["69"]}, +
+ + 417     :READ +
+ + 418     {:fn-name "READ", +
+ + 419      :call-type "SUBR", +
+ + 420      :implementation "PSEUDO-FUNCTION ", +
+ + 421      :page-nos ["5" "84"]}, +
+ + 422     :ERRORSET +
+ + 423     {:fn-name "ERRORSET", +
+ + 424      :call-type "SUBR", +
+ + 425      :implementation "PSEUDO-FUNCTION", +
+ + 426      :page-nos ["35" "66"]}, +
+ + 427     :UNCOMMON +
+ + 428     {:fn-name "UNCOMMON", +
+ + 429      :call-type "SUBR", +
+ + 430      :implementation "PSEUDO-FUNCTION ", +
+ + 431      :page-nos ["64" "78"]}, +
+ + 432     :EVAL +
+ + 433     {:fn-name "EVAL", +
+ + 434      :call-type "SUBR", +
+ + 435      :implementation "", +
+ + 436      :page-nos ["71"]}, +
+ + 437     :MIN +
+ + 438     {:fn-name "MIN", +
+ + 439      :call-type "FSUBR", +
+ + 440      :implementation "", +
+ + 441      :page-nos ["26" "64"]}, +
+ + 442     :PAIR +
+ + 443     {:fn-name "PAIR", +
+ + 444      :call-type "SUBR", +
+ + 445      :implementation "", +
+ + 446      :page-nos ["60"]}, +
+ + 447     :BLANK +
+ + 448     {:fn-name "BLANK", +
+ + 449      :call-type "APVAL", +
+ + 450      :implementation "", +
+ + 451      :page-nos ["69" "85"]}, +
+ + 452     :SETQ +
+ + 453     {:fn-name "SETQ", +
+ + 454      :call-type "FSUBR", +
+ + 455      :implementation "PSEUDO-FUNCTION", +
+ + 456      :page-nos ["30" "71"]}, +
+ + 457     :GET +
+ + 458     {:fn-name "GET", +
+ + 459      :call-type "SUBR", +
+ + 460      :implementation "", +
+ + 461      :page-nos ["41" "59"]}, +
+ + 462     :PRINT +
+ + 463     {:fn-name "PRINT", +
+ + 464      :call-type "SUBR", +
+ + 465      :implementation "PSEUDO-FUNCTION ", +
+ + 466      :page-nos ["65" "84"]}, +
+ + 467     :ENDREAD +
+ + 468     {:fn-name "ENDREAD", +
+ + 469      :call-type "SUBR", +
+ + 470      :implementation "PSEUDO-FUNCTION", +
+ + 471      :page-nos ["8 8"]}, +
+ + 472     :RETURN +
+ + 473     {:fn-name "RETURN", +
+ + 474      :call-type "SUBR", +
+ + 475      :implementation "PSEUDO-FUNCTION", +
+ + 476      :page-nos ["30" "72"]}, +
+ + 477     :LITER +
+ + 478     {:fn-name "LITER", +
+ + 479      :call-type "SUBR", +
+ + 480      :implementation "PREDICATE ", +
+ + 481      :page-nos ["87"]}, +
+ + 482     :EOF +
+ + 483     {:fn-name "EOF", +
+ + 484      :call-type "APVAL", +
+ + 485      :implementation "", +
+ + 486      :page-nos ["69" "88"]}, +
+ + 487     :TRACE +
+ + 488     {:fn-name "TRACE", +
+ + 489      :call-type "EXPR", +
+ + 490      :implementation "PSEUDO-FUNCTION", +
+ + 491      :page-nos ["32" "66" "79"]}, +
+ + 492     :TRACESET +
+ + 493     {:fn-name "TRACESET", +
+ + 494      :call-type "EXPR", +
+ + 495      :implementation "PSEUDO-FUNCTION LIBRARY", +
+ + 496      :page-nos ["68"]}, +
+ + 497     :PACK +
+ + 498     {:fn-name "PACK", +
+ + 499      :call-type "SUBR", +
+ + 500      :implementation "PSEUDO-FUNCTION ", +
+ + 501      :page-nos ["86"]}, +
+ + 502     :NULL +
+ + 503     {:fn-name "NULL", +
+ + 504      :call-type "SUBR", +
+ + 505      :implementation "PREDICATE ", +
+ + 506      :page-nos ["11" "57"]}, +
+ + 507     :CLEARBUFF +
+ + 508     {:fn-name "CLEARBUFF", +
+ + 509      :call-type "SUBR", +
+ + 510      :implementation "PSEUDO-FUNCTION", +
+ + 511      :page-nos ["86"]}, +
+ + 512     :LESSP +
+ + 513     {:fn-name "LESSP", +
+ + 514      :call-type "SUBR", +
+ + 515      :implementation "PREDICATE ", +
+ + 516      :page-nos ["26" "64"]}, +
+ + 517     :TERPRI +
+ + 518     {:fn-name "TERPRI", +
+ + 519      :call-type "SUBR", +
+ + 520      :implementation "PSEUDO-FUNCTION", +
+ + 521      :page-nos ["65" "84"]}, +
+ + 522     :ONEP +
+ + 523     {:fn-name "ONEP", +
+ + 524      :call-type "SUBR", +
+ + 525      :implementation "PREDICATE ", +
+ + 526      :page-nos [" 26" "64"]}, +
+ + 527     :EXCISE +
+ + 528     {:fn-name "EXCISE", +
+ + 529      :call-type "SUBR", +
+ + 530      :implementation "PSEUDO-FUNCTION", +
+ + 531      :page-nos ["67" "77"]}, +
+ + 532     :REMOB +
+ + 533     {:fn-name "REMOB", +
+ + 534      :call-type "SUBR", +
+ + 535      :implementation "PSEUDO-FUNCTION ", +
+ + 536      :page-nos ["67"]}, +
+ + 537     :MAP +
+ + 538     {:fn-name "MAP", +
+ + 539      :call-type "SUBR", +
+ + 540      :implementation "FUNCTIONAL ", +
+ + 541      :page-nos ["63"]}, +
+ + 542     :COMPILE +
+ + 543     {:fn-name "COMPILE", +
+ + 544      :call-type "SUBR", +
+ + 545      :implementation "PSEUDO-FUNCTION", +
+ + 546      :page-nos ["64" "76"]}, +
+ + 547     :ADD1 +
+ + 548     {:fn-name "ADD1", +
+ + 549      :call-type "SUBR", +
+ + 550      :implementation "", +
+ + 551      :page-nos ["26" "64"]}, +
+ + 552     :ADVANCE +
+ + 553     {:fn-name "ADVANCE", +
+ + 554      :call-type "SUBR", +
+ + 555      :implementation "PSEUDO-FUNCTION", +
+ + 556      :page-nos ["88"]}, +
+ + 557     :SEARCH +
+ + 558     {:fn-name "SEARCH", +
+ + 559      :call-type "SUBR", +
+ + 560      :implementation "FUNCTIONAL", +
+ + 561      :page-nos ["63"]}, +
+ + 562     :APPLY +
+ + 563     {:fn-name "APPLY", +
+ + 564      :call-type "SUBR", +
+ + 565      :implementation "", +
+ + 566      :page-nos ["70"]}, +
+ + 567     :READLAP +
+ + 568     {:fn-name "READLAP", +
+ + 569      :call-type "SUBR", +
+ + 570      :implementation "PSEUDO-FUNCTION ", +
+ + 571      :page-nos ["65" "76"]}, +
+ + 572     :UNSPECIAL +
+ + 573     {:fn-name "UNSPECIAL", +
+ + 574      :call-type "SUBR", +
+ + 575      :implementation "", +
+ + 576      :page-nos ["64" "78"]}, +
+ + 577     :SUBST +
+ + 578     {:fn-name "SUBST", +
+ + 579      :call-type "SUBR", +
+ + 580      :implementation "", +
+ + 581      :page-nos ["11" "61"]}, +
+ + 582     :COPY +
+ + 583     {:fn-name "COPY", +
+ + 584      :call-type "SUBR", +
+ + 585      :implementation "", +
+ + 586      :page-nos ["62"]}, +
+ + 587     :LOGOR +
+ + 588     {:fn-name "LOGOR", +
+ + 589      :call-type "FSUBR", +
+ + 590      :implementation "", +
+ + 591      :page-nos ["26" "64"]}, +
+ + 592     :LABEL +
+ + 593     {:fn-name "LABEL", +
+ + 594      :call-type "FSUBR", +
+ + 595      :implementation "", +
+ + 596      :page-nos ["8" "18" "70"]}, +
+ + 597     :FIXP +
+ + 598     {:fn-name "FIXP", +
+ + 599      :call-type "SUBR", +
+ + 600      :implementation "PREDICATE", +
+ + 601      :page-nos ["26" "64"]}, +
+ + 602     :SUB1 +
+ + 603     {:fn-name "SUB1", +
+ + 604      :call-type "SUBR", +
+ + 605      :implementation "", +
+ + 606      :page-nos ["26" "64"]}, +
+ + 607     :ATTRIB +
+ + 608     {:fn-name "ATTRIB", +
+ + 609      :call-type "SUBR", +
+ + 610      :implementation "PSEUDO-FUNCTION", +
+ + 611      :page-nos ["59"]}, +
+ + 612     :DIFFERENCE +
+ + 613     {:fn-name "DIFFERENCE", +
+ + 614      :call-type "SUBR", +
+ + 615      :implementation "", +
+ + 616      :page-nos ["26" "64"]}, +
+ + 617     :REMAINDER +
+ + 618     {:fn-name "REMAINDER", +
+ + 619      :call-type "SUBR", +
+ + 620      :implementation "", +
+ + 621      :page-nos ["26" "64"]}, +
+ + 622     :REVERSE +
+ + 623     {:fn-name "REVERSE", +
+ + 624      :call-type "SUBR", +
+ + 625      :implementation "", +
+ + 626      :page-nos ["6 2"]}, +
+ + 627     :EOR +
+ + 628     {:fn-name "EOR", +
+ + 629      :call-type "APVAL", +
+ + 630      :implementation "", +
+ + 631      :page-nos ["69" "88"]}, +
+ + 632     :PLUSS +
+ + 633     {:fn-name "PLUSS", +
+ + 634      :call-type "APVAL", +
+ + 635      :implementation "", +
+ + 636      :page-nos ["69" "85"]}, +
+ + 637     :TEMPUS-FUGIT +
+ + 638     {:fn-name "TEMPUS-FUGIT", +
+ + 639      :call-type "SUBR", +
+ + 640      :implementation "PSEUDO-FUNCTION", +
+ + 641      :page-nos ["67"]}, +
+ + 642     :LOAD +
+ + 643     {:fn-name "LOAD", +
+ + 644      :call-type "SUBR", +
+ + 645      :implementation "PSEUDO-FUNCTION", +
+ + 646      :page-nos ["67"]}, +
+ + 647     :CHARCOUNT +
+ + 648     {:fn-name "CHARCOUNT", +
+ + 649      :call-type "APVAL", +
+ + 650      :implementation "", +
+ + 651      :page-nos ["69" "87"]}, +
+ + 652     :RPAR +
+ + 653     {:fn-name "RPAR", +
+ + 654      :call-type "APVAL", +
+ + 655      :implementation "", +
+ + 656      :page-nos ["69" "85"]}, +
+ + 657     :COUNT +
+ + 658     {:fn-name "COUNT", +
+ + 659      :call-type "SUBR", +
+ + 660      :implementation "PSEUDO-FUNCTION", +
+ + 661      :page-nos ["34" "66"]}, +
+ + 662     :SPEAK +
+ + 663     {:fn-name "SPEAK", +
+ + 664      :call-type "SUBR", +
+ + 665      :implementation "PSEUDO-FUNCTION", +
+ + 666      :page-nos ["34" "66 "]}, +
+ + 667     :LOGXOR +
+ + 668     {:fn-name "LOGXOR", +
+ + 669      :call-type "FSUBR", +
+ + 670      :implementation "", +
+ + 671      :page-nos ["27" "64"]}, +
+ + 672     :FLOATP +
+ + 673     {:fn-name "FLOATP", +
+ + 674      :call-type "SUBR", +
+ + 675      :implementation "PREDICATE", +
+ + 676      :page-nos ["26" "64"]}, +
+ + 677     :ATOM +
+ + 678     {:fn-name "ATOM", +
+ + 679      :call-type "SUBR", +
+ + 680      :implementation "PREDICATE", +
+ + 681      :page-nos ["3" "57"]}, +
+ + 682     :EQSIGN +
+ + 683     {:fn-name "EQSIGN", +
+ + 684      :call-type "APVAL", +
+ + 685      :implementation "", +
+ + 686      :page-nos ["69" "85"]}, +
+ + 687     :LIST +
+ + 688     {:fn-name "LIST", +
+ + 689      :call-type "FSUBR", +
+ + 690      :implementation "", +
+ + 691      :page-nos ["57"]}, +
+ + 692     :MAPLIST +
+ + 693     {:fn-name "MAPLIST", +
+ + 694      :call-type "SUBR", +
+ + 695      :implementation "FUNCTIONAL ", +
+ + 696      :page-nos ["20" "21" "63"]}, +
+ + 697     :LOGAND +
+ + 698     {:fn-name "LOGAND", +
+ + 699      :call-type "FSUBR", +
+ + 700      :implementation "", +
+ + 701      :page-nos ["27" "64"]}, +
+ + 702     :FLAG +
+ + 703     {:fn-name "FLAG", +
+ + 704      :call-type "EXPR", +
+ + 705      :implementation "PSEUDO-FUNCTION", +
+ + 706      :page-nos ["41" "60"]}, +
+ + 707     :MAPCON +
+ + 708     {:fn-name "MAPCON", +
+ + 709      :call-type "SUBR", +
+ + 710      :implementation "FUNCTIONAL PSEUDO- FUNCTION", +
+ + 711      :page-nos ["63"]}, +
+ + 712     :STAR +
+ + 713     {:fn-name "STAR", +
+ + 714      :call-type "APVAL", +
+ + 715      :implementation "", +
+ + 716      :page-nos ["69" "85"]}, +
+ + 717     :CURCHAR +
+ + 718     {:fn-name "CURCHAR", +
+ + 719      :call-type "APVAL", +
+ + 720      :implementation "", +
+ + 721      :page-nos ["69" "87"]}, +
+ + 722     :DUMP +
+ + 723     {:fn-name "DUMP", +
+ + 724      :call-type "SUBR", +
+ + 725      :implementation "PSEUDO-FUNCTION", +
+ + 726      :page-nos ["67"]}, +
+ + 727     :DEFLIST +
+ + 728     {:fn-name "DEFLIST", +
+ + 729      :call-type "EXPR", +
+ + 730      :implementation "PSEUDO-FUNCTION", +
+ + 731      :page-nos ["41" "58"]}, +
+ + 732     :LEFTSHIFT +
+ + 733     {:fn-name "LEFTSHIFT", +
+ + 734      :call-type "SUBR", +
+ + 735      :implementation "", +
+ + 736      :page-nos ["27" "64"]}, +
+ + 737     :ZEROP +
+ + 738     {:fn-name "ZEROP", +
+ + 739      :call-type "SUBR", +
+ + 740      :implementation "PREDICATE", +
+ + 741      :page-nos ["26" "64"]}}) +
+ + 742   +
+ + 743  (defn page-url +
+ + 744    "Format the URL for the page in the manual with this `page-no`." +
+ + 745    [page-no] +
+ + 746    (let [n (read-string page-no) +
+ + 747          n' (when (and (number? n) +
+ + 748                        (ends-with? *manual-url* ".pdf")) +
+ + 749               ;; annoyingly, the manual has eight pages of front-matter +
+ + 750               ;; before numbering starts. +
+ + 751               (+ n 8))] +
+ + 752      (format +
+ + 753       (if (ends-with? *manual-url* ".pdf") "%s#page=%s" "%s#page%s") +
+ + 754       *manual-url* +
+ + 755       (or n' (trim (str page-no)))))) +
+ + 756   +
+ + 757  (defn format-page-references +
+ + 758    "Format page references from the manual index for the function whose name +
+ + 759     is `fn-symbol`." +
+ + 760    [fn-symbol] +
+ + 761    (let [k (if (keyword? fn-symbol) fn-symbol (keyword fn-symbol))] +
+ + 762      (join ", " +
+ + 763            (doall +
+ + 764             (map +
+ + 765              (fn [n] +
+ + 766                (let [p (trim n)] +
+ + 767                  (format "<a href='%s'>%s</a>" +
+ + 768                          (page-url p) p))) +
+ + 769              (:page-nos (index k))))))) +
+ + diff --git a/docs/cloverage/beowulf/oblist.clj.html b/docs/cloverage/beowulf/oblist.clj.html new file mode 100644 index 0000000..4ca6768 --- /dev/null +++ b/docs/cloverage/beowulf/oblist.clj.html @@ -0,0 +1,143 @@ + + + + beowulf/oblist.clj + + + + 001  (ns beowulf.oblist +
+ + 002    "A namespace mainly devoted to the object list and other top level +
+ + 003     global variables. +
+ + 004      +
+ + 005     Yes, this makes little sense, but if you put them anywhere else you end +
+ + 006     up in cyclic dependency hell." +
+ + 007    ) +
+ + 008   +
+ + 009  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +
+ + 010  ;;; +
+ + 011  ;;; Copyright (C) 2022-2023 Simon Brooke +
+ + 012  ;;; +
+ + 013  ;;; This program is free software; you can redistribute it and/or +
+ + 014  ;;; modify it under the terms of the GNU General Public License +
+ + 015  ;;; as published by the Free Software Foundation; either version 2 +
+ + 016  ;;; of the License, or (at your option) any later version. +
+ + 017  ;;;  +
+ + 018  ;;; This program is distributed in the hope that it will be useful, +
+ + 019  ;;; but WITHOUT ANY WARRANTY; without even the implied warranty of +
+ + 020  ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the +
+ + 021  ;;; GNU General Public License for more details. +
+ + 022  ;;;  +
+ + 023  ;;; You should have received a copy of the GNU General Public License +
+ + 024  ;;; along with this program; if not, write to the Free Software +
+ + 025  ;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA. +
+ + 026  ;;; +
+ + 027  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +
+ + 028   +
+ + 029  (def NIL +
+ + 030    "The canonical empty list symbol. +
+ + 031      +
+ + 032     TODO: this doesn't really work, because (from Clojure) `(empty? NIL)` throws +
+ + 033     an exception. It might be better to subclass beowulf.cons_cell.ConsCell to create +
+ + 034     a new singleton class Nil which overrides the `empty` method of  +
+ + 035     IPersistentCollection?" +
+ + 036    'NIL) +
+ + 037   +
+ + 038  (def oblist +
+ + 039    "The default environment." +
+ + 040    (atom NIL)) +
+ + 041   +
+ + 042  (def ^:dynamic *options* +
+ + 043    "Command line options from invocation." +
+ + 044    {:testing true}) +
+ + 045   +
+ + diff --git a/docs/cloverage/beowulf/read.clj.html b/docs/cloverage/beowulf/read.clj.html index f999f3a..74998a3 100644 --- a/docs/cloverage/beowulf/read.clj.html +++ b/docs/cloverage/beowulf/read.clj.html @@ -35,7 +35,7 @@ 010        reader ever did;
- 011    2. It treats everything between a semi-colon and an end of line as a comment, + 011    2. It treats everything between a double semi-colon and an end of line as a comment,
012        as most modern Lisps do; but I do not believe Lisp 1.5 had this feature. @@ -50,904 +50,319 @@ 015    switch."
- 016    (:require [beowulf.bootstrap :refer [*options*]] + 016    (:require [beowulf.oblist :refer [*options*]]
- 017              [clojure.math.numeric-tower :refer [expt]] + 017              [beowulf.reader.char-reader :refer [read-chars]]
- 018              [clojure.string :refer [starts-with? upper-case]] + 018              [beowulf.reader.generate :refer [generate]]
- 019              [instaparse.core :as i] + 019              [beowulf.reader.parser :refer [parse]]
- 020              [beowulf.cons-cell :refer [make-beowulf-list make-cons-cell NIL]])) + 020              [beowulf.reader.simplify :refer [simplify]] +
+ + 021              [clojure.string :refer [join split starts-with? trim]]) +
+ + 022    (:import [instaparse.gll Failure] +
+ + 023             [java.io InputStream]))
- 021   + 024  
- 022  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + 025  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
- 023  ;;; + 026  ;;;
- 024  ;;; This file provides the reader required for boostrapping. It's not a bad + 027  ;;; This file provides the reader required for boostrapping. It's not a bad
- 025  ;;; reader - it provides feedback on errors found in the input - but it isn't + 028  ;;; reader - it provides feedback on errors found in the input - but it isn't
- 026  ;;; the real Lisp reader. + 029  ;;; the real Lisp reader.
- 027  ;;; + 030  ;;;
- 028  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + 031  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +
+ + 032  ;;; +
+ + 033  ;;; Copyright (C) 2022-2023 Simon Brooke +
+ + 034  ;;; +
+ + 035  ;;; This program is free software; you can redistribute it and/or +
+ + 036  ;;; modify it under the terms of the GNU General Public License +
+ + 037  ;;; as published by the Free Software Foundation; either version 2 +
+ + 038  ;;; of the License, or (at your option) any later version. +
+ + 039  ;;;  +
+ + 040  ;;; This program is distributed in the hope that it will be useful, +
+ + 041  ;;; but WITHOUT ANY WARRANTY; without even the implied warranty of +
+ + 042  ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the +
+ + 043  ;;; GNU General Public License for more details. +
+ + 044  ;;;  +
+ + 045  ;;; You should have received a copy of the GNU General Public License +
+ + 046  ;;; along with this program; if not, write to the Free Software +
+ + 047  ;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA. +
+ + 048  ;;; +
+ + 049  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
- 029   -
- - 030  (declare generate) -
- - 031   + 050  
- 032  (def parse + 051  (defn strip-line-comments
- 033    "Parse a string presented as argument into a parse tree which can then + 052    "Strip blank lines and comment lines from this string `s`, expected to
- 034    be operated upon further." -
- - 035    (i/parser -
- - 036      (str + 053     be Lisp source."
- 037        ;; top level: we accept mexprs as well as sexprs. -
- - 038        "expr := mexpr | sexpr;" -
- - 039   -
- - 040        ;; mexprs. I'm pretty clear that Lisp 1.5 could never read these, -
- - 041        ;; but it's a convenience. -
- - 042        "mexpr := λexpr | fncall | defn | cond | mvar | mexpr comment; -
- - 043        λexpr := λ lsqb bindings semi-colon body rsqb; -
- - 044        λ := 'λ'; -
- - 045        bindings := lsqb args rsqb; -
- - 046        body := (expr semi-colon opt-space)* expr; -
- - 047        fncall := fn-name lsqb args rsqb; -
- - 048        lsqb := '['; -
- - 049        rsqb := ']'; -
- - 050        defn := mexpr opt-space '=' opt-space mexpr; -
- - 051        cond := lsqb (cond-clause semi-colon opt-space)* cond-clause rsqb; -
- - 052        cond-clause := expr opt-space arrow opt-space expr; -
- - 053        arrow := '->'; -
- - 054        args := (expr semi-colon opt-space)* expr; -
- - 055        fn-name := mvar; -
- - 056        mvar := #'[a-z]+'; -
- - 057        semi-colon := ';';" -
- - 058   -
- - 059        ;; comments. I'm pretty confident Lisp 1.5 did NOT have these. -
- - 060        "comment := opt-space <';;'> #'[^\\n\\r]*';" -
- - 061   -
- - 062        ;; sexprs. Note it's not clear to me whether Lisp 1.5 had the quote macro, -
- - 063        ;; but I've included it on the basis that it can do little harm. -
- - 064        "sexpr := quoted-expr | atom | number | dotted-pair | list | sexpr comment; -
- - 065        list := lpar sexpr rpar | lpar (sexpr sep)* rpar | lpar (sexpr sep)* dot-terminal; -
- - 066        dotted-pair := lpar dot-terminal ; -
- - 067        dot := '.'; -
- - 068        lpar := '('; -
- - 069        rpar := ')'; -
- - 070        quoted-expr := quote sexpr; -
- - 071        quote := '\\''; -
- - 072        dot-terminal := sexpr space dot space sexpr rpar; -
- - 073        space := #'\\p{javaWhitespace}+'; -
- - 074        opt-space := #'\\p{javaWhitespace}*'; -
- - 075        sep := ',' | opt-space; -
- - 076        atom := #'[A-Z][A-Z0-9]*';" -
- - 077   -
- - 078        ;; Lisp 1.5 supported octal as well as decimal and scientific notation -
- - 079        "number := integer | decimal | scientific | octal; -
- - 080        integer := #'-?[1-9][0-9]*'; -
- - 081        decimal := #'-?[1-9][0-9]*\\.?[0-9]*' | #'0.[0-9]*'; -
- - 082        scientific := coefficient e exponent; -
- - 083        coefficient := decimal; -
- - 084        exponent := integer; -
- - 085        e := 'E'; -
- - 086        octal := #'[+-]?[0-7]+{1,12}' q scale-factor; -
- - 087        q := 'Q'; -
- - 088        scale-factor := #'[0-9]*'"))) -
- - 089   -
- - 090  (defn simplify -
- - 091    "Simplify this parse tree `p`. If `p` is an instaparse failure object, throw -
- - 092    an `ex-info`, with `p` as the value of its `:failure` key." -
- - 093    ([p] -
- - 094     (if -
- - 095       (instance? instaparse.gll.Failure p) -
- - 096       (throw (ex-info "Ic ne behæfd" {:cause :parse-failure :failure p})) -
- - 097       (simplify p :sexpr))) -
- - 098    ([p context] -
- - 099    (if + 054    [^String s]
- 100      (coll? p) -
- - 101      (apply -
- - 102        vector + 055    (join "\n"
- 103        (remove -
- - 104          #(if (coll? %) (empty? %)) -
- - 105          (case (first p) -
- - 106            (:arg :expr :coefficient :fn-name :number :sexpr) (simplify (second p) context) -
- - 107            (:λexpr -
- - 108              :args :bindings :body :cond :cond-clause :dot-terminal -
- - 109              :fncall :octal :quoted-expr :scientific) (map #(simplify % context) p) -
- - 110            (:arrow :dot :e :lpar :lsqb :opt-space :q :quote :rpar :rsqb -
- - 111              :semi-colon :sep :space) nil -
- - 112            :atom (if -
- - 113                    (= context :mexpr) -
- - 114                    [:quoted-expr p] -
- - 115                    p) -
- - 116            :comment (if -
- - 117                       (:strict *options*) -
- - 118                       (throw -
- - 119                         (ex-info "Cannot parse comments in strict mode" -
- - 120                                  {:cause :strict}))) -
- - 121            :dotted-pair (if -
- - 122                           (= context :mexpr) -
- - 123                           [:fncall -
- - 124                            [:mvar "cons"] -
- - 125                            [:args -
- - 126                             (simplify (nth p 1) context) -
- - 127                             (simplify (nth p 2) context)]] -
- - 128                           (map simplify p)) -
- - 129            :mexpr (if -
- - 130                     (:strict *options*) -
- - 131                     (throw -
- - 132                       (ex-info "Cannot parse meta expressions in strict mode" -
- - 133                                {:cause :strict})) -
- - 134                     (simplify (second p) :mexpr)) -
- - 135            :list (if -
- - 136                    (= context :mexpr) -
- - 137                    [:fncall -
- - 138                     [:mvar "list"] -
- - 139                     [:args (apply vector (map simplify (rest p)))]] -
- - 140                    (map #(simplify % context) p)) -
- - 141            ;;default -
- - 142            p))) -
- - 143      p))) -
- - 144   -
- - 145   -
- - 146  ;; # From Lisp 1.5 Programmers Manual, page 10 -
- - 147  ;; Note that I've retyped much of this, since copy/pasting out of PDF is less -
- - 148  ;; than reliable. Any typos are mine. Quote starts [[ -
- - 149   -
- - 150  ;; We are now in a position to define the universal LISP function -
- - 151  ;; evalquote[fn;args], When evalquote is given a function and a list of arguments -
- - 152  ;; for that function, it computes the value of the function applied to the arguments. -
- - 153  ;; LISP functions have S-expressions as arguments. In particular, the argument "fn" -
- - 154  ;; of the function evalquote must be an S-expression. Since we have been -
- - 155  ;; writing functions as M-expressions, it is necessary to translate them into -
- - 156  ;; S-expressions. -
- - 157   -
- - 158  ;; The following rules define a method of translating functions written in the -
- - 159  ;; meta-language into S-expressions. -
- - 160  ;; 1. If the function is represented by its name, it is translated by changing -
- - 161  ;;    all of the letters to upper case, making it an atomic symbol. Thus is -
- - 162  ;;    translated to CAR. -
- - 163  ;; 2. If the function uses the lambda notation, then the expression -
- - 164  ;;    λ[[x ..;xn]; ε] is translated into (LAMBDA (X1 ...XN) ε*), where ε* is the translation -
- - 165  ;;    of ε. -
- - 166  ;; 3. If the function begins with label, then the translation of -
- - 167  ;;    label[α;ε] is (LABEL α* ε*). -
- - 168   -
- - 169  ;; Forms are translated as follows: -
- - 170  ;; 1. A variable, like a function name, is translated by using uppercase letters. -
- - 171  ;;    Thus the translation of varl is VAR1. -
- - 172  ;; 2. The obvious translation of letting a constant translate into itself will not -
- - 173  ;;    work. Since the translation of x is X, the translation of X must be something -
- - 174  ;;    else to avoid ambiguity. The solution is to quote it. Thus X is translated -
- - 175  ;;    into (QUOTE X). -
- - 176  ;; 3. The form fn[argl;. ..;argn] is translated into (fn* argl* ...argn*) -
- - 177  ;; 4. The conditional expression [pl-el;...;pn-en] is translated into -
- - 178  ;;    (COND (p1* e1*)...(pn* en*)) -
- - 179   -
- - 180  ;; ## Examples -
- - 181   -
- - 182  ;; M-expressions                                S-expressions -
- - 183  ;; x                                            X -
- - 184  ;; car                                          CAR -
- - 185  ;; car[x]                                       (CAR X) -
- - 186  ;; T                                            (QUOTE T) -
- - 187  ;; ff[car [x]]                                  (FF (CAR X)) -
- - 188  ;; [atom[x]->x; T->ff[car[x]]]                  (COND ((ATOM X) X) -
- - 189  ;;                                                ((QUOTE T)(FF (CAR X)))) -
- - 190  ;; label[ff;λ[[x];[atom[x]->x; T->ff[car[x]]]]] (LABEL FF (LAMBDA (X) (COND -
- - 191  ;;                                                ((ATOM X) X) -
- - 192  ;;                                                ((QUOTE T)(FF (CAR X)))))) -
- - 193   -
- - 194  ;; ]] quote ends -
- - 195   -
- - 196  (defn gen-cond-clause -
- - 197    "Generate a cond clause from this simplified parse tree fragment `p`; -
- - 198    returns `nil` if `p` does not represent a cond clause." -
- - 199    [p] -
- - 200    (if -
- - 201      (and (coll? p)(= :cond-clause (first p))) -
- - 202      (make-beowulf-list -
- - 203        (list (generate (nth p 1)) -
- - 204                       (generate (nth p 2)))))) -
- - 205   -
- - 206  (defn gen-cond -
- - 207    "Generate a cond statement from this simplified parse tree fragment `p`; -
- - 208    returns `nil` if `p` does not represent a (MEXPR) cond statement." -
- - 209    [p] -
- - 210    (if -
- - 211      (and (coll? p)(= :cond (first p))) -
- - 212      (make-beowulf-list -
- - 213        (cons -
- - 214          'COND -
- - 215          (map -
- - 216            gen-cond-clause -
- - 217            (rest p)))))) -
- - 218   -
- - 219  (defn gen-fn-call -
- - 220    "Generate a function call from this simplified parse tree fragment `p`; -
- - 221    returns `nil` if `p` does not represent a (MEXPR) function call." -
- - 222    [p] -
- - 223    (if -
- - 224      (and (coll? p)(= :fncall (first p))(= :mvar (first (second p)))) -
- - 225      (make-cons-cell -
- - 226        (generate (second p)) -
- - 227        (generate (nth p 2))))) -
- - 228   -
- - 229   -
- - 230  (defn gen-dot-terminated-list -
- - 231    "Generate a list, which may be dot-terminated, from this partial parse tree -
- - 232    'p'. Note that the function acts recursively and progressively decapitates -
- - 233    its argument, so that the argument will not always be a valid parse tree." -
- - 234    [p] -
- - 235    (cond -
- - 236      (empty? p) -
- - 237      NIL -
- - 238      (and (coll? (first p)) (= :dot-terminal (first (first p)))) -
- - 239      (let [dt (first p)] -
- - 240        (make-cons-cell -
- - 241          (generate (nth dt 1)) -
- - 242          (generate (nth dt 2)))) -
- - 243      :else -
- - 244      (make-cons-cell -
- - 245        (generate (first p)) -
- - 246        (gen-dot-terminated-list (rest p))))) -
- - 247   -
- - 248   -
- - 249  (defn strip-leading-zeros -
- - 250    "`read-string` interprets strings with leading zeros as octal; strip -
- - 251    any from this string `s`. If what's left is empty (i.e. there were -
- - 252    only zeros, return `\"0\"`." -
- - 253    ([s] -
- - 254     (strip-leading-zeros s "")) -
- - 255    ([s prefix] -
- - 256     (if -
- - 257       (empty? s) "0" -
- - 258       (case (first s) -
- - 259         (\+ \-)(strip-leading-zeros (subs s 1) (str (first s) prefix)) -
- - 260         "0" (strip-leading-zeros (subs s 1) prefix) -
- - 261         (str prefix s))))) -
- - 262   -
- - 263  (defn generate -
- - 264    "Generate lisp structure from this parse tree `p`. It is assumed that -
- - 265    `p` has been simplified." -
- - 266    [p] -
- - 267    (if -
- - 268      (coll? p) -
- - 269      (case (first p) -
- - 270        :λ "LAMBDA" -
- - 271        :λexpr (make-cons-cell -
- - 272                 (generate (nth p 1)) -
- - 273                 (make-cons-cell (generate (nth p 2)) -
- - 274                                 (generate (nth p 3)))) -
- - 275        (:args :list) (gen-dot-terminated-list (rest p)) -
- - 276        :atom (symbol (second p)) -
- - 277        :bindings (generate (second p)) -
- - 278        :body (make-beowulf-list (map generate (rest p))) -
- - 279        :cond (gen-cond p) -
- - 280        (:decimal :integer) (read-string (strip-leading-zeros (second p))) -
- - 281        :dotted-pair (make-cons-cell -
- - 282                       (generate (nth p 1)) -
- - 283                       (generate (nth p 2))) -
- - 284        :exponent (generate (second p)) -
- - 285        :fncall (gen-fn-call p) -
- - 286        :mvar (symbol (upper-case (second p))) + 056          (remove
- 287        :octal (let [n (read-string (strip-leading-zeros (second p) "0")) + 057           #(or (empty? %)
- - 288                     scale (generate (nth p 2))] + + 058                (starts-with? (trim %) ";;"))
- - 289                 (* n (expt 8 scale))) + + 059           (split s #"\n"))))
- 290   + 060   +
+ + 061  (defn number-lines
- 291        ;; the quote read macro (which probably didn't exist in Lisp 1.5, but...) + 062    ([^String s]
- - 292        :quoted-expr (make-beowulf-list (list 'QUOTE (generate (second p)))) + + 063     (number-lines s nil))
- - 293        :scale-factor (if + + 064    ([^String s ^Failure e] +
+ + 065     (let [l (-> e :line) +
+ + 066           c (-> e :column)] +
+ + 067       (join "\n" +
+ + 068             (map #(str (format "%5d %s" (inc %1) %2) +
+ + 069                        (when (= l (inc %1)) +
+ + 070                          (str "\n" (apply str (repeat c " ")) "^"))) +
+ + 071                  (range) +
+ + 072                  (split s #"\n")))))) +
+ + 073   +
+ + 074  (defn gsp +
+ + 075    "Shortcut macro - the internals of read; or, if you like, read-string. +
+ + 076    Argument `s` should be a string representation of a valid Lisp +
+ + 077    expression." +
+ + 078    [s] +
+ + 079    (let [source (strip-line-comments s) +
+ + 080          parse-tree (parse source)]
- 294                        (empty? (second p)) 0 -
- - 295                        (read-string (strip-leading-zeros (second p)))) -
- - 296        :scientific (let [n (generate (second p)) -
- - 297                          exponent (generate (nth p 2))] -
- - 298                      (* n (expt 10 exponent))) -
- - 299   -
- - 300        ;; default + 081      (if (instance? Failure parse-tree)
- 301        (throw (Exception. (str "Cannot yet generate " (first p))))) + 082        (doall (println (number-lines source parse-tree))
- - 302      p)) + + 083               (throw (ex-info "Ne can forstande " (assoc parse-tree :source source)))) +
+ + 084        (generate (simplify parse-tree)))))
- 303   -
- - 304  (defmacro gsp -
- - 305    "Shortcut macro - the internals of read; or, if you like, read-string. -
- - 306    Argument `s` should be a string representation of a valid Lisp -
- - 307    expression." -
- - 308    [s] + 085  
- 309    `(generate (simplify (parse ~s)))) + 086  (defn- dummy-read-chars [prompt] +
+ + 087    (loop [r "" p prompt] +
+ + 088      (if (and (seq r) +
+ + 089               (= (count (re-seq #"\(" r)) +
+ + 090                  (count (re-seq #"\)" r))) +
+ + 091               (= (count (re-seq #"\[" r)) +
+ + 092                  (count (re-seq #"\]" r)))) +
+ + 093        r +
+ + 094        (do +
+ + 095          (print (str p " ")) +
+ + 096          (flush) +
+ + 097          (recur (str r "\n" (read-line)) "::")))))
- 310   + 098  
- 311  (defn READ + 099  (defn read-from-console
- 312    "An implementation of a Lisp reader sufficient for bootstrapping; not necessarily + 100    "Attempt to read a complete lisp expression from the console.
- 313    the final Lisp reader." + 101     
- 314    [input] + 102     There's a major problem here that the read-chars reader messes up testing.
- - 315    (gsp (or input (read-line)))) + + 103     We need to be able to disable it while testing!" +
+ + 104    [prompt] +
+ + 105    (if (:testing *options*) +
+ + 106      (dummy-read-chars prompt) +
+ + 107      (read-chars prompt))) +
+ + 108   +
+ + 109  (defn READ +
+ + 110    "An implementation of a Lisp reader sufficient for bootstrapping; not necessarily +
+ + 111    the final Lisp reader. `input` should be either a string representation of a LISP +
+ + 112    expression, or else an input stream. A single form will be read." +
+ + 113    ([] +
+ + 114     (gsp (read-from-console (:prompt *options*)))) +
+ + 115    ([input] +
+ + 116     (cond +
+ + 117       (empty? input) (READ) +
+ + 118       (string? input) (gsp input) +
+ + 119       (instance? InputStream input) (READ (slurp input)) +
+ + 120       :else    (throw (ex-info "READ: `input` should be a string or an input stream" {})))))
diff --git a/docs/cloverage/beowulf/reader/char_reader.clj.html b/docs/cloverage/beowulf/reader/char_reader.clj.html new file mode 100644 index 0000000..a0ac0f9 --- /dev/null +++ b/docs/cloverage/beowulf/reader/char_reader.clj.html @@ -0,0 +1,329 @@ + + + + beowulf/reader/char_reader.clj + + + + 001  (ns beowulf.reader.char-reader +
+ + 002    "Provide sensible line editing, auto completion, and history recall. +
+ + 003      +
+ + 004     None of what's needed here is really working yet, and a pull request with +
+ + 005     a working implementation would be greatly welcomed. +
+ + 006      +
+ + 007     ## What's needed (rough specification) +
+ + 008      +
+ + 009     1. Carriage return **does not** cause input to be returned, **unless** +
+ + 010         a. the number of open brackets `(` and closing brackets `)` match; and +
+ + 011         b. the number of open square brackets `[` and closing square brackets `]` also match; +
+ + 012     2. <Ctrl-D> aborts editing and returns the string `STOP`; +
+ + 013     3. <Up-arrow> and <down-arrow> scroll back and forward through history, but ideally I'd like  +
+ + 014        this to be the Lisp history (i.e. the history of S-Expressions actually read by `READ`,  +
+ + 015        rather than the strings which were supplied to `READ`); +
+ + 016     4. <Tab> offers potential auto-completions taken from the value of `(OBLIST)`, ideally the +
+ + 017        current value, not the value at the time the session started; +
+ + 018     5. <Back-arrow> and <Forward-arrow> offer movement and editing within the line. +
+ + 019      +
+ + 020     TODO: There are multiple problems with JLine; a better solution might be +
+ + 021     to start from here: +
+ + 022     https://stackoverflow.com/questions/7931988/how-to-manipulate-control-characters" +
+ + 023    (:require [beowulf.oblist :refer [*options* oblist]]) +
+ + 024    (:import [org.jline.reader.impl.completer StringsCompleter] +
+ + 025             [org.jline.reader.impl DefaultParser DefaultParser$Bracket] +
+ + 026             [org.jline.reader LineReaderBuilder] +
+ + 027             [org.jline.terminal TerminalBuilder] +
+ + 028             [org.jline.widget AutopairWidgets AutosuggestionWidgets])) +
+ + 029   +
+ + 030  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +
+ + 031  ;;; +
+ + 032  ;;; Copyright (C) 2022-2023 Simon Brooke +
+ + 033  ;;; +
+ + 034  ;;; This program is free software; you can redistribute it and/or +
+ + 035  ;;; modify it under the terms of the GNU General Public License +
+ + 036  ;;; as published by the Free Software Foundation; either version 2 +
+ + 037  ;;; of the License, or (at your option) any later version. +
+ + 038  ;;;  +
+ + 039  ;;; This program is distributed in the hope that it will be useful, +
+ + 040  ;;; but WITHOUT ANY WARRANTY; without even the implied warranty of +
+ + 041  ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the +
+ + 042  ;;; GNU General Public License for more details. +
+ + 043  ;;;  +
+ + 044  ;;; You should have received a copy of the GNU General Public License +
+ + 045  ;;; along with this program; if not, write to the Free Software +
+ + 046  ;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA. +
+ + 047  ;;; +
+ + 048  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +
+ + 049   +
+ + 050  ;; It looks from the example given [here](https://github.com/jline/jline3/blob/master/demo/src/main/java/org/jline/demo/Repl.java) +
+ + 051  ;; as though JLine could be used to build a perfect line-reader for Beowulf; but it also +
+ + 052  ;; looks as though you'd need a DPhil in JLine to write it, and I don't have +
+ + 053  ;; the time. +
+ + 054   +
+ + 055  (defn build-completer +
+ + 056    "Build a completer which takes tokens from the oblist. +
+ + 057      +
+ + 058     This is sort-of working, in as much as hitting <TAB> on a blank line will  +
+ + 059     show a table of values from the oblist, but hitting <TAB> after you've  +
+ + 060     started input does not show potential completions for tokens you've started." +
+ + 061    [] +
+ + 062    (StringsCompleter. (map #(str (first %)) @oblist))) +
+ + 063   +
+ + 064  ;; This breaks; it is not correctly resolving the Enum, although I can't work out +
+ + 065  ;; why not. +
+ + 066  ;; (defn build-parser +
+ + 067  ;;   [] +
+ + 068  ;;   (println "Building parser") +
+ + 069  ;;   (let [parser (DefaultParser.)] +
+ + 070  ;;     (doall +
+ + 071  ;;      (.setEofOnUnclosedBracket  +
+ + 072  ;;       parser DefaultParser$Bracket/ROUND)))) +
+ + 073   +
+ + 074  (def get-reader +
+ + 075    "Return a reader, first constructing it if necessary. +
+ + 076      +
+ + 077     **NOTE THAT** this is not settled API. The existence and call signature of +
+ + 078     this function is not guaranteed in future versions." +
+ + 079    (memoize (fn [] +
+ + 080              (let [term (.build (.system (TerminalBuilder/builder) true)) +
+ + 081                    reader (-> (LineReaderBuilder/builder) +
+ + 082                                (.terminal  term) +
+ + 083                                (.completer  (build-completer)) +
+ + 084   ;;       #(.parser % (build-parser)) +
+ + 085                                (.build)) +
+ + 086                    ;; apw (AutopairWidgets. reader false) +
+ + 087                    ;; asw (AutosuggestionWidgets. reader) +
+ + 088                    ] +
+ + 089                ;; (.enable apw) +
+ + 090                ;; (.enable asw) +
+ + 091                reader)))) +
+ + 092   +
+ + 093  (defn read-chars +
+ + 094    "A drop-in replacement for `clojure.core/read-line`, except that line editing +
+ + 095     and history should be enabled. +
+ + 096      +
+ + 097     **NOTE THAT** this does not fully work yet, but it is in the API because I  +
+ + 098     hope that it will work later!" +
+ + 099    [prompt] +
+ + 100    (let [eddie (get-reader)] +
+ + 101      (loop [s (.readLine eddie (str prompt " "))] +
+ + 102        (if (and (= (count (re-seq #"\(" s)) +
+ + 103                    (count (re-seq #"\)" s))) +
+ + 104                 (= (count (re-seq #"\[]" s)) +
+ + 105                    (count (re-seq #"\]" s)))) +
+ + 106          s +
+ + 107          (recur (str s " " (.readLine eddie ":: "))))))) +
+ + diff --git a/docs/cloverage/beowulf/reader/generate.clj.html b/docs/cloverage/beowulf/reader/generate.clj.html new file mode 100644 index 0000000..a1be840 --- /dev/null +++ b/docs/cloverage/beowulf/reader/generate.clj.html @@ -0,0 +1,836 @@ + + + + beowulf/reader/generate.clj + + + + 001  (ns beowulf.reader.generate +
+ + 002    "Generating S-Expressions from parse trees.  +
+ + 003      +
+ + 004     ## From Lisp 1.5 Programmers Manual, page 10 +
+ + 005     *Note that I've retyped much of this, since copy/pasting out of PDF is less +
+ + 006     than reliable. Any typos are mine.* +
+ + 007      +
+ + 008     *Quote starts:* +
+ + 009   +
+ + 010     We are now in a position to define the universal LISP function +
+ + 011     `evalquote[fn;args]`, When evalquote is given a function and a list of arguments +
+ + 012     for that function, it computes the value of the function applied to the arguments. +
+ + 013     LISP functions have S-expressions as arguments. In particular, the argument `fn` +
+ + 014     of the function evalquote must be an S-expression. Since we have been +
+ + 015     writing functions as M-expressions, it is necessary to translate them into +
+ + 016     S-expressions. +
+ + 017   +
+ + 018     The following rules define a method of translating functions written in the +
+ + 019     meta-language into S-expressions. +
+ + 020     1. If the function is represented by its name, it is translated by changing +
+ + 021        all of the letters to upper case, making it an atomic symbol. Thus `car` is  +
+ + 022        translated to `CAR`. +
+ + 023     2. If the function uses the lambda notation, then the expression +
+ + 024        `λ[[x ..;xn]; ε]` is translated into `(LAMBDA (X1 ...XN) ε*)`, where ε* is the translation +
+ + 025        of ε. +
+ + 026     3. If the function begins with label, then the translation of +
+ + 027        `label[α;ε]` is `(LABEL α* ε*)`. +
+ + 028   +
+ + 029     Forms are translated as follows: +
+ + 030     1. A variable, like a function name, is translated by using uppercase letters. +
+ + 031        Thus the translation of `var1` is `VAR1`. +
+ + 032     2. The obvious translation of letting a constant translate into itself will not +
+ + 033        work. Since the translation of `x` is `X`, the translation of `X` must be something +
+ + 034        else to avoid ambiguity. The solution is to quote it. Thus `X` is translated +
+ + 035        into `(QUOTE X)`. +
+ + 036     3. The form `fn[argl;. ..;argn]` is translated into `(fn* argl* ...argn*)` +
+ + 037     4. The conditional expression `[pl-el;...;pn-en]` is translated into +
+ + 038        `(COND (p1* e1*)...(pn* en*))` +
+ + 039   +
+ + 040     ## Examples +
+ + 041     ``` +
+ + 042       M-expressions                                  S-expressions              +
+ + 043     +
+ + 044       x                                              X                          +
+ + 045       car                                            CAR                        +
+ + 046       car[x]                                         (CAR X)                    +
+ + 047       T                                              (QUOTE T)                  +
+ + 048       ff[car [x]]                                    (FF (CAR X))               +
+ + 049       [atom[x]->x; T->ff[car[x]]]                    (COND ((ATOM X) X)  +
+ + 050                                                          ((QUOTE T)(FF (CAR X)))) +
+ + 051       label[ff;λ[[x];[atom[x]->x;                    (LABEL FF (LAMBDA (X)  +
+ + 052            T->ff[car[x]]]]]                              (COND ((ATOM X) X)  +
+ + 053                                                              ((QUOTE T)(FF (CAR X)))))) +
+ + 054     ``` +
+ + 055   +
+ + 056     *quote ends* +
+ + 057  " +
+ + 058    (:require [beowulf.cons-cell :refer [make-beowulf-list make-cons-cell]] +
+ + 059              [beowulf.reader.macros :refer [expand-macros]] +
+ + 060              [beowulf.oblist :refer [NIL]] +
+ + 061              [clojure.math.numeric-tower :refer [expt]] +
+ + 062              [clojure.string :refer [upper-case]] +
+ + 063              [clojure.tools.trace :refer [deftrace]])) +
+ + 064   +
+ + 065  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +
+ + 066  ;;; +
+ + 067  ;;; Copyright (C) 2022-2023 Simon Brooke +
+ + 068  ;;; +
+ + 069  ;;; This program is free software; you can redistribute it and/or +
+ + 070  ;;; modify it under the terms of the GNU General Public License +
+ + 071  ;;; as published by the Free Software Foundation; either version 2 +
+ + 072  ;;; of the License, or (at your option) any later version. +
+ + 073  ;;;  +
+ + 074  ;;; This program is distributed in the hope that it will be useful, +
+ + 075  ;;; but WITHOUT ANY WARRANTY; without even the implied warranty of +
+ + 076  ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the +
+ + 077  ;;; GNU General Public License for more details. +
+ + 078  ;;;  +
+ + 079  ;;; You should have received a copy of the GNU General Public License +
+ + 080  ;;; along with this program; if not, write to the Free Software +
+ + 081  ;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA. +
+ + 082  ;;; +
+ + 083  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +
+ + 084   +
+ + 085  (declare generate) +
+ + 086   +
+ + 087  (defn gen-cond-clause +
+ + 088    "Generate a cond clause from this simplified parse tree fragment `p`; +
+ + 089    returns `nil` if `p` does not represent a cond clause." +
+ + 090    [p context] +
+ + 091    (when +
+ + 092     (and (coll? p) (= :cond-clause (first p))) +
+ + 093      (make-beowulf-list +
+ + 094       (list (if (= (nth p 1) [:quoted-expr [:atom "T"]]) +
+ + 095               'T +
+ + 096               (generate (nth p 1) context)) +
+ + 097             (generate (nth p 2) context))))) +
+ + 098   +
+ + 099  (defn gen-cond +
+ + 100    "Generate a cond statement from this simplified parse tree fragment `p`; +
+ + 101    returns `nil` if `p` does not represent a (MEXPR) cond statement." +
+ + 102    [p context] +
+ + 103    (when +
+ + 104     (and (coll? p) (= :cond (first p))) +
+ + 105      (make-beowulf-list +
+ + 106       (cons +
+ + 107        'COND +
+ + 108        (map +
+ + 109         #(generate % (if (= context :mexpr) :cond-mexpr context)) +
+ + 110         (rest p)))))) +
+ + 111   +
+ + 112  (defn gen-fn-call +
+ + 113    "Generate a function call from this simplified parse tree fragment `p`; +
+ + 114    returns `nil` if `p` does not represent a (MEXPR) function call." +
+ + 115    [p context] +
+ + 116    (when +
+ + 117     (and (coll? p) (= :fncall (first p)) (= :mvar (first (second p)))) +
+ + 118      (make-cons-cell +
+ + 119       (generate (second p) context) +
+ + 120       (generate (nth p 2) context)))) +
+ + 121   +
+ + 122   +
+ + 123  (defn gen-dot-terminated-list +
+ + 124    "Generate a list, which may be dot-terminated, from this partial parse tree +
+ + 125    'p'. Note that the function acts recursively and progressively decapitates +
+ + 126    its argument, so that the argument will not always be a valid parse tree." +
+ + 127    [p] +
+ + 128    (cond +
+ + 129      (empty? p) +
+ + 130      NIL +
+ + 131      (and (coll? (first p)) (= :dot-terminal (first (first p)))) +
+ + 132      (let [dt (first p)] +
+ + 133        (make-cons-cell +
+ + 134         (generate (nth dt 1)) +
+ + 135         (generate (nth dt 2)))) +
+ + 136      :else +
+ + 137      (make-cons-cell +
+ + 138       (generate (first p)) +
+ + 139       (gen-dot-terminated-list (rest p))))) +
+ + 140   +
+ + 141  ;; null[x] = [x = NIL -> T; T -> F] +
+ + 142  ;; [:defn  +
+ + 143  ;;  [:mexpr [:fncall [:mvar "null"] [:bindings [:args [:mexpr [:mvar "x"]]]]]]  +
+ + 144  ;;  "="  +
+ + 145  ;;  [:mexpr [:cond  +
+ + 146  ;;           [:cond-clause [:mexpr [:iexpr [:lhs [:mexpr [:mvar "x"]]] [:iop "="] [:rhs [:mexpr [:mconst "NIL"]]]]] [:mexpr [:mconst "T"]]]  +
+ + 147  ;;           [:cond-clause [:mexpr [:mconst "T"]] [:mexpr [:mconst "F"]]]]]] +
+ + 148   +
+ + 149  (defn generate-defn +
+ + 150    [tree context] +
+ + 151    (if (= :mexpr (first tree)) +
+ + 152      (generate-defn (second tree) context) +
+ + 153      (make-beowulf-list +
+ + 154       (list 'PUT +
+ + 155             (list 'QUOTE (generate (-> tree second second second) context)) +
+ + 156             (list 'QUOTE 'EXPR) +
+ + 157             (list 'QUOTE +
+ + 158                   (cons 'LAMBDA +
+ + 159                         (list (generate (nth (-> tree second second) 2) context) +
+ + 160                               (generate (nth tree 3) context)))))))) +
+ + 161   +
+ + 162  (defn gen-iexpr +
+ + 163    [tree context] +
+ + 164    (let [bundle (reduce #(assoc %1 (first %2) %2) +
+ + 165                         {} +
+ + 166                         (rest tree))] +
+ + 167      (list (generate (:iop bundle) context) +
+ + 168            (generate (:lhs bundle) context) +
+ + 169            (generate (:rhs bundle) context)))) +
+ + 170   +
+ + 171  (defn generate-set +
+ + 172    "Actually not sure what the mexpr representation of set looks like" +
+ + 173    [tree context] +
+ + 174    (throw (ex-info "Not Yet Implemented" {:feature "generate-set"}))) +
+ + 175   +
+ + 176  (defn generate-assign +
+ + 177    "Generate an assignment statement based on this `tree`. If the thing  +
+ + 178     being assigned to is a function signature, then we have to do something  +
+ + 179     different to if it's an atom." +
+ + 180    [tree context] +
+ + 181    (case (first (second tree)) +
+ + 182      :fncall (generate-defn tree context) +
+ + 183      :mexpr (map #(generate % context) (rest (second tree))) +
+ + 184      (:mvar :atom) (generate-set tree context))) +
+ + 185   +
+ + 186  (defn strip-leading-zeros +
+ + 187    "`read-string` interprets strings with leading zeros as octal; strip +
+ + 188    any from this string `s`. If what's left is empty (i.e. there were +
+ + 189    only zeros, return `\"0\"`." +
+ + 190    ([s] +
+ + 191     (strip-leading-zeros s "")) +
+ + 192    ([s prefix] +
+ + 193     (if +
+ + 194      (empty? s) "0" +
+ + 195      (case (first s) +
+ + 196        (\+ \-) (strip-leading-zeros (subs s 1) (str (first s) prefix)) +
+ + 197        "0" (strip-leading-zeros (subs s 1) prefix) +
+ + 198        (str prefix s))))) +
+ + 199   +
+ + 200  (defn generate +
+ + 201    "Generate lisp structure from this parse tree `p`. It is assumed that +
+ + 202    `p` has been simplified." +
+ + 203    ([p] +
+ + 204     (generate p :expr)) +
+ + 205    ([p context] +
+ + 206     (try +
+ + 207       (expand-macros +
+ + 208        (if +
+ + 209         (coll? p) +
+ + 210          (case (first p) +
+ + 211            :λ "LAMBDA" +
+ + 212            :λexpr (make-cons-cell +
+ + 213                    (generate (nth p 1) context) +
+ + 214                    (make-cons-cell (generate (nth p 2) context) +
+ + 215                                    (generate (nth p 3) context))) +
+ + 216            :args (make-beowulf-list (map #(generate % context) (rest p))) +
+ + 217            :atom (symbol (second p)) +
+ + 218            :bindings (generate (second p) context) +
+ + 219            :body (make-beowulf-list (map #(generate % context) (rest p))) +
+ + 220            (:coefficient :exponent) (generate (second p) context) +
+ + 221            :cond (gen-cond p (if (= context :mexpr) :cond-mexpr context)) +
+ + 222            :cond-clause (gen-cond-clause p context) +
+ + 223            :decimal (read-string (apply str (map second (rest p)))) +
+ + 224            :defn (generate-defn p context) +
+ + 225            :dotted-pair (make-cons-cell +
+ + 226                          (generate (nth p 1) context) +
+ + 227                          (generate (nth p 2) context)) +
+ + 228            :fncall (gen-fn-call p context) +
+ + 229            :iexpr (gen-iexpr p context) +
+ + 230            :integer (read-string (strip-leading-zeros (second p))) +
+ + 231            :iop (case (second p) +
+ + 232                   "/" 'DIFFERENCE +
+ + 233                   "=" 'EQUAL +
+ + 234                   ">" 'GREATERP +
+ + 235                   "<" 'LESSP +
+ + 236                   "+" 'PLUS +
+ + 237                   "*" 'TIMES +
+ + 238                  ;; else +
+ + 239                   (throw (ex-info "Unrecognised infix operator symbol" +
+ + 240                                   {:phase :generate +
+ + 241                                    :fragment p}))) +
+ + 242            :list (gen-dot-terminated-list (rest p)) +
+ + 243            (:lhs :rhs) (generate (second p) context) +
+ + 244            :mexpr (generate (second p) (if (= context :cond-mexpr) context :mexpr)) +
+ + 245            :mconst (if (= context :cond-mexpr) +
+ + 246                      (case (second p) +
+ + 247                        ("T" "F" "NIL") (symbol (second p)) +
+ + 248                        ;; else +
+ + 249                        (list 'QUOTE (symbol (second p)))) +
+ + 250                      ;; else +
+ + 251                      (list 'QUOTE (symbol (second p)))) +
+ + 252            :mvar (symbol (upper-case (second p))) +
+ + 253            :number (generate (second p) context) +
+ + 254            :octal (let [n (read-string (strip-leading-zeros (second p) "0")) +
+ + 255                         scale (generate (nth p 3) context)] +
+ + 256                     (* n (expt 8 scale))) +
+ + 257   +
+ + 258        ;; the quote read macro (which probably didn't exist in Lisp 1.5, but...) +
+ + 259            :quoted-expr (make-beowulf-list (list 'QUOTE (generate (second p) context))) +
+ + 260            :scale-factor (if +
+ + 261                           (empty? (second p)) 0 +
+ + 262                           (read-string (strip-leading-zeros (second p)))) +
+ + 263            :scientific (let [n (generate (second p) context) +
+ + 264                              exponent (generate (nth p 3) context)] +
+ + 265                          (* n (expt 10 exponent))) +
+ + 266            :sexpr (generate (second p) :sexpr) +
+ + 267            :subr (symbol (second p)) +
+ + 268   +
+ + 269        ;; default +
+ + 270            (throw (ex-info (str "Unrecognised head: " (first p)) +
+ + 271                            {:generating p}))) +
+ + 272          p)) +
+ + 273       (catch Throwable any +
+ + 274         (throw (ex-info "Could not generate" +
+ + 275                         {:generating p} +
+ + 276                         any)))))) +
+ + diff --git a/docs/cloverage/beowulf/reader/macros.clj.html b/docs/cloverage/beowulf/reader/macros.clj.html new file mode 100644 index 0000000..8a44ffc --- /dev/null +++ b/docs/cloverage/beowulf/reader/macros.clj.html @@ -0,0 +1,212 @@ + + + + beowulf/reader/macros.clj + + + + 001  (ns beowulf.reader.macros +
+ + 002    "Can I implement reader macros? let's see! +
+ + 003      +
+ + 004     We don't need (at least, in the Clojure reader) to rewrite forms like +
+ + 005     `'FOO`, because that's handled by the parser. But we do need to rewrite +
+ + 006     things which don't evaluate their arguments, like `SETQ`, because (unless +
+ + 007     LABEL does it, which I'm not yet sure of) we're not yet able to implement +
+ + 008     things which don't evaluate arguments. +
+ + 009   +
+ + 010     TODO: at this stage, the following should probably also be read macros: +
+ + 011     DEFINE" +
+ + 012    (:require [beowulf.cons-cell :refer [make-beowulf-list]] +
+ + 013              [beowulf.host :refer [CONS LIST]] +
+ + 014              [clojure.string :refer [join]])) +
+ + 015   +
+ + 016  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +
+ + 017  ;;; +
+ + 018  ;;; We don't need (at least, in the Clojure reader) to rewrite forms like +
+ + 019  ;;; "'FOO", because that's handled by the parser. But we do need to rewrite +
+ + 020  ;;; things which don't evaluate their arguments, like `SETQ`, because (unless +
+ + 021  ;;; LABEL does it, which I'm not yet sure of) we're not yet able to implement +
+ + 022  ;;; things which don't evaluate arguments. +
+ + 023  ;;; +
+ + 024  ;;; TODO: at this stage, the following should probably also be read macros: +
+ + 025  ;;; DEFINE +
+ + 026  ;;; +
+ + 027  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +
+ + 028  ;;; +
+ + 029  ;;; Copyright (C) 2022-2023 Simon Brooke +
+ + 030  ;;; +
+ + 031  ;;; This program is free software; you can redistribute it and/or +
+ + 032  ;;; modify it under the terms of the GNU General Public License +
+ + 033  ;;; as published by the Free Software Foundation; either version 2 +
+ + 034  ;;; of the License, or (at your option) any later version. +
+ + 035  ;;;  +
+ + 036  ;;; This program is distributed in the hope that it will be useful, +
+ + 037  ;;; but WITHOUT ANY WARRANTY; without even the implied warranty of +
+ + 038  ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the +
+ + 039  ;;; GNU General Public License for more details. +
+ + 040  ;;;  +
+ + 041  ;;; You should have received a copy of the GNU General Public License +
+ + 042  ;;; along with this program; if not, write to the Free Software +
+ + 043  ;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA. +
+ + 044  ;;; +
+ + 045  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +
+ + 046   +
+ + 047  (def ^:dynamic *readmacros* +
+ + 048    {:car {'DEFUN (fn [f] +
+ + 049                    (LIST 'SET (LIST 'QUOTE (second f)) +
+ + 050                          (LIST 'QUOTE (CONS 'LAMBDA (rest (rest f)))))) +
+ + 051           'SETQ (fn [f] (LIST 'SET (LIST 'QUOTE (second f)) (nth f 2)))}}) +
+ + 052   +
+ + 053  (defn expand-macros +
+ + 054    [form] +
+ + 055    (try +
+ + 056      (if-let [car (when (and (coll? form) (symbol? (first form)))  +
+ + 057                     (first form))] +
+ + 058        (if-let [macro (-> *readmacros* :car car)] +
+ + 059          (make-beowulf-list (apply macro (list form))) +
+ + 060          form) +
+ + 061        form) +
+ + 062      (catch Exception any +
+ + 063        (println (join "\n" +
+ + 064                       ["# ERROR while expanding macro:" +
+ + 065                        (str "# Form: " form) +
+ + 066                        (str "# Error class: " (.getName (.getClass any))) +
+ + 067                        (str "# Message: " (.getMessage any))])) +
+ + 068        form))) +
+ + diff --git a/docs/cloverage/beowulf/reader/parser.clj.html b/docs/cloverage/beowulf/reader/parser.clj.html new file mode 100644 index 0000000..0e8427d --- /dev/null +++ b/docs/cloverage/beowulf/reader/parser.clj.html @@ -0,0 +1,368 @@ + + + + beowulf/reader/parser.clj + + + + 001  (ns beowulf.reader.parser +
+ + 002    "The actual parser, supporting both S-expression and M-expression syntax." +
+ + 003    (:require [instaparse.core :as i])) +
+ + 004   +
+ + 005  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +
+ + 006  ;;; +
+ + 007  ;;; Copyright (C) 2022-2023 Simon Brooke +
+ + 008  ;;; +
+ + 009  ;;; This program is free software; you can redistribute it and/or +
+ + 010  ;;; modify it under the terms of the GNU General Public License +
+ + 011  ;;; as published by the Free Software Foundation; either version 2 +
+ + 012  ;;; of the License, or (at your option) any later version. +
+ + 013  ;;;  +
+ + 014  ;;; This program is distributed in the hope that it will be useful, +
+ + 015  ;;; but WITHOUT ANY WARRANTY; without even the implied warranty of +
+ + 016  ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the +
+ + 017  ;;; GNU General Public License for more details. +
+ + 018  ;;;  +
+ + 019  ;;; You should have received a copy of the GNU General Public License +
+ + 020  ;;; along with this program; if not, write to the Free Software +
+ + 021  ;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA. +
+ + 022  ;;; +
+ + 023  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +
+ + 024   +
+ + 025  (def parse +
+ + 026    "Parse a string presented as argument into a parse tree which can then +
+ + 027    be operated upon further." +
+ + 028    (i/parser +
+ + 029     (str +
+ + 030      ;; we tolerate whitespace and comments around legitimate input +
+ + 031      "raw := expr | opt-comment expr opt-comment;" +
+ + 032      ;; top level: we accept mexprs as well as sexprs. +
+ + 033      "expr := mexpr | sexpr ;" +
+ + 034   +
+ + 035      ;; comments. I'm pretty confident Lisp 1.5 did NOT have these. +
+ + 036      "comment := opt-space <';;'> opt-space #'[^\\n\\r]*';" +
+ + 037   +
+ + 038      ;; there's a notation comprising a left brace followed by mexprs +
+ + 039      ;; followed by a right brace which doesn't seem to be documented  +
+ + 040      ;; but I think must represent assembly code(?) +
+ + 041   +
+ + 042      ;; "assembly := lbrace exprs rbrace;" +
+ + 043   +
+ + 044      ;; mexprs. I'm pretty clear that Lisp 1.5 could never read these, +
+ + 045      ;; but it's a convenience. +
+ + 046   +
+ + 047      ;; TODO: this works for now but in fact the Programmer's Manual +
+ + 048      ;; gives a much simpler formulation of M-expression grammar on +
+ + 049      ;; page 9, and of the S-expression grammar on page 8. It would +
+ + 050      ;; be worth going back and redoing this from the book. +
+ + 051   +
+ + 052      "exprs := expr | exprs;" +
+ + 053      "mexpr := λexpr | fncall | defn | cond | mvar | mconst | iexpr | number | mexpr comment; +
+ + 054        λexpr := λ lsqb bindings semi-colon opt-space body opt-space rsqb; +
+ + 055        λ := 'λ' | 'lambda'; +
+ + 056        bindings := lsqb args rsqb | lsqb rsqb; +
+ + 057        body := (opt-space mexpr semi-colon)* opt-space mexpr; +
+ + 058        fncall := fn-name bindings; +
+ + 059        lsqb := '['; +
+ + 060        rsqb := ']'; +
+ + 061        lbrace := '{'; +
+ + 062        rbrace := '}'; +
+ + 063        defn := mexpr opt-space '=' opt-space mexpr; +
+ + 064        cond := lsqb (opt-space cond-clause semi-colon opt-space)* cond-clause rsqb; +
+ + 065        cond-clause := mexpr opt-space arrow opt-space mexpr opt-space; +
+ + 066        arrow := '->'; +
+ + 067        args := arg | (opt-space arg semi-colon opt-space)* opt-space arg opt-space; +
+ + 068        arg := mexpr; +
+ + 069        fn-name := mvar; +
+ + 070        mvar := #'[a-z][a-z0-9]*'; +
+ + 071        mconst := #'[A-Z][A-Z0-9]*'; +
+ + 072        semi-colon := ';';" +
+ + 073   +
+ + 074      ;; Infix operators appear in mexprs, e.g. on page 7. Ooops! +
+ + 075      ;; I do not know what infix operators are considered legal. +
+ + 076      ;; In particular I do not know what symbol was used for +
+ + 077      ;; multiply +
+ + 078      "iexpr := iexp iop iexp; +
+ + 079       iexp := mexpr | number | opt-space iexp opt-space; +
+ + 080      iop := '>' | '<' | '+' | '-' | '*' '/' | '=' ;" +
+ + 081   +
+ + 082      ;; comments. I'm pretty confident Lisp 1.5 did NOT have these. +
+ + 083      "opt-comment := opt-space | comment;" +
+ + 084      "comment := opt-space <';;'> #'[^\\n\\r]*' opt-space;" +
+ + 085   +
+ + 086      ;; sexprs. Note it's not clear to me whether Lisp 1.5 had the quote macro, +
+ + 087      ;; but I've included it on the basis that it can do little harm. +
+ + 088      "sexpr := quoted-expr | atom | number | subr | dotted-pair | list | sexpr comment; +
+ + 089        list := lpar sexpr rpar | lpar (sexpr sep)* rpar | lpar (sexpr sep)* dot-terminal | lbrace exprs rbrace; +
+ + 090        list := lpar opt-space sexpr rpar | lpar opt-space (sexpr sep)* rpar | lpar opt-space (sexpr sep)* dot-terminal; +
+ + 091        dotted-pair := lpar dot-terminal ; +
+ + 092        dot := '.'; +
+ + 093        lpar := '('; +
+ + 094        rpar := ')'; +
+ + 095        quoted-expr := quote sexpr; +
+ + 096        quote := '\\''; +
+ + 097        dot-terminal := sexpr space dot space sexpr rpar; +
+ + 098        space := #'\\p{javaWhitespace}+'; +
+ + 099        opt-space := #'\\p{javaWhitespace}*'; +
+ + 100        sep := ',' | opt-space; +
+ + 101        atom := #'[A-Z][A-Z0-9]*';" +
+ + 102   +
+ + 103      ;; we need a way of representing Clojure functions on the object list; +
+ + 104      ;; subr objects aren't expected to be normally entered on the REPL, but +
+ + 105      ;; must be on the object list or functions to which functions are passed +
+ + 106      ;; won't be able to access them. +
+ + 107      "subr := #'[a-z][a-z.]*/[A-Za-z][A-Za-z0-9]*';" +
+ + 108   +
+ + 109      ;; Lisp 1.5 supported octal as well as decimal and scientific notation +
+ + 110      "number := integer | decimal | scientific | octal; +
+ + 111        integer := #'-?[0-9]+'; +
+ + 112        decimal := integer dot integer; +
+ + 113        scientific := coefficient e exponent; +
+ + 114        coefficient := decimal | integer; +
+ + 115        exponent := integer; +
+ + 116        e := 'E'; +
+ + 117        octal := #'[+-]?[0-7]+{1,12}' q scale-factor; +
+ + 118        q := 'Q'; +
+ + 119        scale-factor := #'[0-9]*'"))) +
+ + 120   +
+ + diff --git a/docs/cloverage/beowulf/reader/simplify.clj.html b/docs/cloverage/beowulf/reader/simplify.clj.html new file mode 100644 index 0000000..8d50e4d --- /dev/null +++ b/docs/cloverage/beowulf/reader/simplify.clj.html @@ -0,0 +1,401 @@ + + + + beowulf/reader/simplify.clj + + + + 001  (ns beowulf.reader.simplify +
+ + 002    "Simplify parse trees. Be aware that this is very tightly coupled +
+ + 003     with the parser." +
+ + 004    (:require [beowulf.oblist :refer [*options*]] +
+ + 005              [instaparse.failure :as f]) +
+ + 006    (:import [instaparse.gll Failure])) +
+ + 007   +
+ + 008  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +
+ + 009  ;;; +
+ + 010  ;;; Copyright (C) 2022-2023 Simon Brooke +
+ + 011  ;;; +
+ + 012  ;;; This program is free software; you can redistribute it and/or +
+ + 013  ;;; modify it under the terms of the GNU General Public License +
+ + 014  ;;; as published by the Free Software Foundation; either version 2 +
+ + 015  ;;; of the License, or (at your option) any later version. +
+ + 016  ;;;  +
+ + 017  ;;; This program is distributed in the hope that it will be useful, +
+ + 018  ;;; but WITHOUT ANY WARRANTY; without even the implied warranty of +
+ + 019  ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the +
+ + 020  ;;; GNU General Public License for more details. +
+ + 021  ;;;  +
+ + 022  ;;; You should have received a copy of the GNU General Public License +
+ + 023  ;;; along with this program; if not, write to the Free Software +
+ + 024  ;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA. +
+ + 025  ;;; +
+ + 026  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +
+ + 027   +
+ + 028  (declare simplify-tree) +
+ + 029   +
+ + 030  (defn remove-optional-space +
+ + 031    [tree] +
+ + 032    (if (vector? tree) +
+ + 033      (if (= :opt-space (first tree)) +
+ + 034        nil +
+ + 035        (let [v (remove nil? +
+ + 036                        (map remove-optional-space tree))] +
+ + 037          (if (seq v) +
+ + 038            (apply vector v) +
+ + 039            v))) +
+ + 040      tree)) +
+ + 041   +
+ + 042  (defn remove-nesting +
+ + 043    [tree context] +
+ + 044    (let [tree' (remove-optional-space tree)] +
+ + 045      (if-let [key (when (and (vector? tree')  +
+ + 046                              (keyword? (first tree')))  +
+ + 047                     (first tree'))] +
+ + 048        (loop [r tree'] +
+ + 049          (if (and r (vector? r) (keyword? (first r))) +
+ + 050            (if (= (first r) key) +
+ + 051              (recur (simplify-tree (second r) context)) +
+ + 052              r) +
+ + 053            r)) +
+ + 054        tree'))) +
+ + 055   +
+ + 056  (defn simplify-tree +
+ + 057    "Simplify this parse tree `p`. If `p` is an instaparse failure object, throw +
+ + 058     an `ex-info`, with `p` as the value of its `:failure` key. +
+ + 059      +
+ + 060     **NOTE THAT** it is assumed that `remove-optional-space` has been run on the +
+ + 061     parse tree **BEFORE** it is passed to `simplify-tree`." +
+ + 062    ([p] +
+ + 063     (if +
+ + 064      (instance? Failure p) +
+ + 065       (throw (ex-info +
+ + 066               (str "Ic ne behæfd: " (f/pprint-failure p)) +
+ + 067               {:cause :parse-failure +
+ + 068                :phase   :simplify +
+ + 069                :failure p})) +
+ + 070       (simplify-tree p :expr))) +
+ + 071    ([p context] +
+ + 072     (cond +
+ + 073       (string? p) p +
+ + 074       (coll? p) (apply +
+ + 075                  vector +
+ + 076                  (remove +
+ + 077                   #(when (coll? %) (empty? %)) +
+ + 078                   (case (first p) +
+ + 079                     (:λexpr +
+ + 080                      :args :bindings :body :cond :cond-clause :defn :dot-terminal  +
+ + 081                      :fncall :lhs :quoted-expr :rhs ) (map #(simplify-tree % context) p) +
+ + 082                     (:arg :expr :coefficient :fn-name :number) (simplify-tree (second p) context) +
+ + 083                     (:arrow :dot :e :lpar :lsqb  :opt-comment :opt-space :q :quote :rpar :rsqb +
+ + 084                             :semi-colon :sep :space) nil +
+ + 085                     :atom (if +
+ + 086                            (= context :mexpr) +
+ + 087                             [:quoted-expr p] +
+ + 088                             p) +
+ + 089                     :comment (when +
+ + 090                               (:strict *options*) +
+ + 091                                (throw +
+ + 092                                 (ex-info "Cannot parse comments in strict mode" +
+ + 093                                          {:cause :strict}))) +
+ + 094                     (:decimal :integer :mconst :octal :scientific) p +
+ + 095                     :dotted-pair (if +
+ + 096                                   (= context :mexpr) +
+ + 097                                    [:fncall +
+ + 098                                     [:mvar "cons"] +
+ + 099                                     [:args +
+ + 100                                      (simplify-tree (nth p 1) context) +
+ + 101                                      (simplify-tree (nth p 2) context)]] +
+ + 102                                    (map #(simplify-tree % context) p)) +
+ + 103                     :iexp (simplify-tree (second p) context) +
+ + 104                     :iexpr [:iexpr +
+ + 105                             [:lhs (simplify-tree (second p) context)] +
+ + 106                             (simplify-tree (nth p 2) context) ;; really should be the operator +
+ + 107                             [:rhs (simplify-tree (nth p 3) context)]] +
+ + 108                     :mexpr (if +
+ + 109                             (:strict *options*) +
+ + 110                              (throw +
+ + 111                               (ex-info "Cannot parse meta expressions in strict mode" +
+ + 112                                        {:cause :strict})) +
+ + 113                              [:mexpr (simplify-tree (second p) :mexpr)]) +
+ + 114                     :list (if +
+ + 115                            (= context :mexpr) +
+ + 116                             [:fncall +
+ + 117                              [:mvar "list"] +
+ + 118                              [:args (apply vector (map simplify-tree (rest p)))]] +
+ + 119                             (map #(simplify-tree % context) p)) +
+ + 120                     :raw (first (remove empty? (map simplify-tree (rest p)))) +
+ + 121                     :sexpr [:sexpr (simplify-tree (second p) :sexpr)] +
+ + 122            ;;default +
+ + 123                     p))) +
+ + 124       :else p))) +
+ + 125   +
+ + 126  (defn simplify +
+ + 127    "Simplify this parse tree `p`. If `p` is an instaparse failure object, throw +
+ + 128     an `ex-info`, with `p` as the value of its `:failure` key. Calls  +
+ + 129     `remove-optional-space` before processing." +
+ + 130    [p] +
+ + 131    (simplify-tree (remove-optional-space p))) +
+ + diff --git a/docs/cloverage/index.html b/docs/cloverage/index.html index b064548..bb572ba 100644 --- a/docs/cloverage/index.html +++ b/docs/cloverage/index.html @@ -16,88 +16,229 @@ beowulf.bootstrap
759
496
-60.48 % + style="width:68.25251601097895%; + float:left;"> 746
347
+68.25 %
104
42
71
-67.28 % -41446217 + style="width:64.31372549019608%; + float:left;"> 164
21
70
+72.55 % +49843255 beowulf.cons-cell
129
98
-56.83 % + style="width:76.0914760914761%; + float:left;"> 366
115
+76.09 %
39
3
26
-61.76 % -1561568 + style="width:78.62068965517241%; + float:left;"> 114
9
22
+84.83 % +27423145 beowulf.core
170
17
-90.91 % + style="width:73.94366197183099%; + float:left;"> 210
74
+73.94 %
43
1
5
-89.80 % -80349 + style="width:78.26086956521739%; + float:left;"> 54
2
13
+81.16 % +132669 beowulf.host
1410
1067
+56.92 % +
203
32
32
+88.01 % +60769267 + + + beowulf.interop
142
104
+57.72 % +
31
6
29
+56.06 % +1291166 + + + beowulf.io
142
188
+43.03 % +
32
7
36
+52.00 % +1741275 + + + beowulf.manual
1721
73
+95.93 % +
298
17
+94.60 % +7694315 + + + beowulf.oblist
1
+ float:left;"> 11 100.00 %
1
+ float:left;"> 6 100.00 % -511 +4556 beowulf.read
588
130
-81.89 % + style="width:54.36893203883495%; + float:left;"> 112
94
+54.37 %
93
29
3
15
+68.09 % +1201047 + + + beowulf.reader.char-reader
7
63
+10.00 % +
5
14
+26.32 % +107619 + + + beowulf.reader.generate
492
213
+69.79 % +
85
10
23
-81.75 % -31531126 + style="width:24.603174603174605%; + float:left;"> 31 +75.40 % +27621126 + + + beowulf.reader.macros
85
21
+80.19 % +
14
6
+70.00 % +68420 + + + beowulf.reader.parser
17
+100.00 % +
4
+100.00 % +120144 + + + beowulf.reader.simplify
255
190
+57.30 % +
40
3
38
+53.09 % +131681 Totals: -68.97 % +69.16 % -72.89 % +78.39 % diff --git a/docs/codox/beowulf.bootstrap.html b/docs/codox/beowulf.bootstrap.html index 8301c99..c9ba900 100644 --- a/docs/codox/beowulf.bootstrap.html +++ b/docs/codox/beowulf.bootstrap.html @@ -1,17 +1,30 @@ -beowulf.bootstrap documentation

Project

Topics

Namespaces

Public Vars

beowulf.bootstrap

Lisp as defined in Chapter 1 (pages 1-14) of the Lisp 1.5 Programmer's Manual; that is to say, a very simple Lisp language, which should, I believe, be sufficient in conjunction with the functions provided by beowulf.host, be sufficient to bootstrap the full Lisp 1.5 interpreter..

-

The convention is adopted that functions in this file with names in ALLUPPERCASE are Lisp 1.5 functions (although written in Clojure) and that therefore all arguments must be numbers, symbols or beowulf.cons_cell.ConsCell objects.

APPLY

(APPLY function args environment depth)

Apply this function to these arguments in this environment and return the result.

-

For bootstrapping, at least, a version of APPLY written in Clojure. All args are assumed to be symbols or beowulf.cons-cell/ConsCell objects. See page 13 of the Lisp 1.5 Programmers Manual.

view source

EVAL

(EVAL expr)(EVAL expr env depth)

Evaluate this expr and return the result. If environment is not passed, it defaults to the current value of the global object list. The depth argument is part of the tracing system and should not be set by user code.

-

All args are assumed to be numbers, symbols or beowulf.cons-cell/ConsCell objects. However, if called with just a single arg, expr, I’ll assume it’s being called from the Clojure REPL and will coerce the expr to ConsCell.

view source

find-target

TODO: write docs

view source

PROG

(PROG program env depth)

The accursed PROG feature. See page 71 of the manual.

+beowulf.bootstrap documentation

Project

Topics

Namespaces

Public Vars

beowulf.bootstrap

Lisp as defined in Chapter 1 (pages 1-14) of the Lisp 1.5 Programmer's Manual; that is to say, a very simple Lisp language, which should, I believe, be sufficient in conjunction with the functions provided by beowulf.host, be sufficient to bootstrap the full Lisp 1.5 interpreter..

+

The convention is adopted that functions in this file with names in ALLUPPERCASE are Lisp 1.5 functions (although written in Clojure) and that therefore all arguments must be numbers, symbols or beowulf.cons_cell.ConsCell objects.

+

*depth*

dynamic

Stack depth. Unfortunately we need to be able to pass round depth for functions which call EVAL/APPLY but do not know about depth.

+
view source

APPLY

(APPLY function args environment)(APPLY function args environment depth)

Apply this function to these arguments in this environment and return the result.

+

For bootstrapping, at least, a version of APPLY written in Clojure. All args are assumed to be symbols or beowulf.cons-cell/ConsCell objects. See page 13 of the Lisp 1.5 Programmers Manual.

+
view source

apply-label

(apply-label function args environment depth)

Apply in the special case that the first element in the function is LABEL.

+
view source

EVAL

(EVAL expr)(EVAL expr env depth)

Evaluate this expr and return the result. If environment is not passed, it defaults to the current value of the global object list. The depth argument is part of the tracing system and should not be set by user code.

+

All args are assumed to be numbers, symbols or beowulf.cons-cell/ConsCell objects. However, if called with just a single arg, expr, I’ll assume it’s being called from the Clojure REPL and will coerce the expr to ConsCell.

+
view source

find-target

TODO: write docs

+
view source

PROG

(PROG program env depth)

The accursed PROG feature. See page 71 of the manual.

Lisp 1.5 introduced PROG, and most Lisps have been stuck with it ever since. It introduces imperative programming into what should be a pure functional language, and consequently it’s going to be a pig to implement.

Broadly, PROG is a variadic pseudo function called as a FEXPR (or possibly an FSUBR, although I’m not presently sure that would even work.)

-

The arguments, which are unevaluated, are a list of forms, the first of which is expected to be a list of symbols which will be treated as names of variables within the program, and the rest of which (the ‘program body’) are either lists or symbols. Lists are treated as Lisp expressions which may be evaulated in turn. Symbols are treated as targets for the GO statement.

+

The arguments, which are unevaluated, are a list of forms, the first of which is expected to be a list of symbols which will be treated as names of variables within the program, and the rest of which (the ‘program body’) are either lists or symbols. Lists are treated as Lisp expressions which may be evaulated in turn. Symbols are treated as targets for the GO statement.

GO: A GO statement takes the form of (GO target), where target should be one of the symbols which occur at top level among that particular invocation of PROGs arguments. A GO statement may occur at top level in a PROG, or in a clause of a COND statement in a PROG, but not in a function called from the PROG statement. When a GO statement is evaluated, execution should transfer immediately to the expression which is the argument list immediately following the symbol which is its target.

If the target is not found, an error with the code A6 should be thrown.

-

RETURN: A RETURN statement takes the form (RETURN value), where value is any value. Following the evaluation of a RETURN statement, the PROG should immediately exit without executing any further expressions, returning the value.

+

RETURN: A RETURN statement takes the form (RETURN value), where value is any value. Following the evaluation of a RETURN statement, the PROG should immediately exit without executing any further expressions, returning the value.

SET and SETQ: In addition to the above, if a SET or SETQ expression is encountered in any expression within the PROG body, it should affect not the global object list but instead only the local variables of the program.

COND: In strict mode, when in normal execution, a COND statement none of whose clauses match should not return NIL but should throw an error with the code A3… except that inside a PROG body, it should not do so. sigh.

Flow of control: Apart from the exceptions specified above, expressions in the program body are evaluated sequentially. If execution reaches the end of the program body, NIL is returned.

Got all that?

-

Good.

view source

prog-eval

(prog-eval expr vars env depth)

Like EVAL, q.v., except handling symbols, and expressions starting GO, RETURN, SET and SETQ specially.

view source

try-resolve-subroutine

(try-resolve-subroutine subr args)

Attempt to resolve this subr with these args.

view source
\ No newline at end of file +

Good.

+
view source

prog-eval

(prog-eval expr vars env depth)

Like EVAL, q.v., except handling symbols, and expressions starting GO, RETURN, SET and SETQ specially.

+
view source

SASSOC

(SASSOC x y u)

Like ASSOC, but with an action to take if no value is found.

+

From the manual, page 60:

+

‘The function sassoc searches y, which is a list of dotted pairs, for a pair whose first element that is x. If such a pair is found, the value of sassoc is this pair. Otherwise the function u of no arguments is taken as the value of sassoc.’

+
view source

try-resolve-subroutine

(try-resolve-subroutine subr args)

Attempt to resolve this subr with these args.

+
view source

value

(value s)(value s indicators)

Seek a value for this symbol s by checking each of these indicators in turn.

+
view source
\ No newline at end of file diff --git a/docs/codox/beowulf.cons-cell.html b/docs/codox/beowulf.cons-cell.html index 6e2b315..035aeb5 100644 --- a/docs/codox/beowulf.cons-cell.html +++ b/docs/codox/beowulf.cons-cell.html @@ -1,3 +1,16 @@ -beowulf.cons-cell documentation

Project

Topics

Namespaces

Public Vars

beowulf.cons-cell

The fundamental cons cell on which all Lisp structures are built. Lisp 1.5 lists do not necessarily have a sequence as their CDR, and must have both CAR and CDR mutable, so cannot be implemented on top of Clojure lists.

cons-cell?

(cons-cell? o)

Is this object o a beowulf cons-cell?

view source

F

The canonical false value - different from NIL, which is not canonically false in Lisp 1.5.

view source

make-beowulf-list

(make-beowulf-list x)

Construct a linked list of cons cells with the same content as the sequence x.

view source

make-cons-cell

(make-cons-cell car cdr)

Construct a new instance of cons cell with this car and cdr.

view source

MutableSequence

protocol

Like a sequence, but mutable.

members

getCar

(getCar this)

Return the first element of this sequence.

getCdr

(getCdr this)

like more, q.v., but returns List NIL not Clojure nil when empty.

getUid

(getUid this)

Returns a unique identifier for this object

rplaca

(rplaca this value)

replace the first element of this sequence with this value

rplacd

(rplacd this value)

replace the rest (but-first; cdr) of this sequence with this value

view source

pretty-print

(pretty-print cell)(pretty-print cell width level)

This isn’t the world’s best pretty printer but it sort of works.

view source

T

The canonical true value.

view source
\ No newline at end of file +beowulf.cons-cell documentation

Project

Topics

Namespaces

Public Vars

beowulf.cons-cell

The fundamental cons cell on which all Lisp structures are built. Lisp 1.5 lists do not necessarily have a sequence as their CDR, and must have both CAR and CDR mutable, so cannot be implemented on top of Clojure lists.

+

cons-cell?

(cons-cell? o)

Is this object o a beowulf cons-cell?

+
view source

F

The canonical false value - different from NIL, which is not canonically false in Lisp 1.5.

+
view source

make-beowulf-list

(make-beowulf-list x)

Construct a linked list of cons cells with the same content as the sequence x.

+
view source

make-cons-cell

(make-cons-cell car cdr)

Construct a new instance of cons cell with this car and cdr.

+
view source

MutableSequence

protocol

Like a sequence, but mutable.

+

members

getCar

(getCar this)

Return the first element of this sequence.

+

getCdr

(getCdr this)

like more, q.v., but returns List NIL not Clojure nil when empty.

+

getUid

(getUid this)

Returns a unique identifier for this object

+

rplaca

(rplaca this value)

replace the first element of this sequence with this value

+

rplacd

(rplacd this value)

replace the rest (but-first; cdr) of this sequence with this value

+
view source

pretty-print

(pretty-print cell)(pretty-print cell width level)

This isn’t the world’s best pretty printer but it sort of works.

+
view source

T

The canonical true value.

+
view source
\ No newline at end of file diff --git a/docs/codox/beowulf.core.html b/docs/codox/beowulf.core.html index 8b8b2ef..fe738c1 100644 --- a/docs/codox/beowulf.core.html +++ b/docs/codox/beowulf.core.html @@ -1,3 +1,8 @@ -beowulf.core documentation

Project

Topics

Namespaces

Public Vars

beowulf.core

Essentially, the -main function and the bootstrap read-eval-print loop.

-main

(-main & opts)

Parse options, print the banner, read the init file if any, and enter the read/eval/print loop.

view source

cli-options

TODO: write docs

view source

repl

(repl prompt)

Read/eval/print loop.

view source

stop-word

The word which, if submitted an an input line, will cause Beowulf to quit. Question: should this be forlǣte?

view source
\ No newline at end of file +beowulf.core documentation

Project

Topics

Namespaces

Public Vars

beowulf.core

Essentially, the -main function and the bootstrap read-eval-print loop.

+

-main

(-main & opts)

Parse options, print the banner, read the init file if any, and enter the read/eval/print loop.

+
view source

cli-options

TODO: write docs

+
view source

repl

(repl prompt)

Read/eval/print loop.

+
view source

stop-word

The word which, if submitted an an input line, will cause Beowulf to quit. Question: should this be forlǣte?

+
view source
\ No newline at end of file diff --git a/docs/codox/beowulf.gendoc.html b/docs/codox/beowulf.gendoc.html index 763e8ab..2414d81 100644 --- a/docs/codox/beowulf.gendoc.html +++ b/docs/codox/beowulf.gendoc.html @@ -1,4 +1,13 @@ -beowulf.gendoc documentation

Project

Topics

Namespaces

Public Vars

beowulf.gendoc

Generate table of documentation of Lisp symbols and functions.

-

NOTE: this is very hacky. You almost certainly do not want to use this!

find-documentation

(find-documentation entry)

Find appropriate documentation for this entry from the oblist.

view source

gen-doc-table

(gen-doc-table)

TODO: write docs

view source

gen-index

(gen-index)(gen-index url destination)

TODO: write docs

view source

host-functions

Functions which we can infer are written in Clojure. We need to collect these at run-time, not compile time, hence memoised function, not variable.

view source

infer-implementation

(infer-implementation entry)

TODO: write docs

view source

infer-signature

(infer-signature entry)

Infer the signature of the function value of this oblist entry, if any.

view source

infer-type

(infer-type entry)

Try to work out what this entry from the oblist actually represents.

view source

open-doc

(open-doc symbol)

Open the documentation page for this symbol, if known, in the default web browser.

view source
\ No newline at end of file +beowulf.gendoc documentation

Project

Topics

Namespaces

Public Vars

beowulf.gendoc

Generate table of documentation of Lisp symbols and functions.

+

NOTE: this is very hacky. You almost certainly do not want to use this!

+

find-documentation

(find-documentation entry)

Find appropriate documentation for this entry from the oblist.

+
view source

gen-doc-table

(gen-doc-table)

TODO: write docs

+
view source

gen-index

(gen-index)(gen-index url destination)

TODO: write docs

+
view source

host-functions

Functions which we can infer are written in Clojure. We need to collect these at run-time, not compile time, hence memoised function, not variable.

+
view source

infer-implementation

(infer-implementation entry)

TODO: write docs

+
view source

infer-signature

(infer-signature entry)

Infer the signature of the function value of this oblist entry, if any.

+
view source

infer-type

(infer-type entry)

Try to work out what this entry from the oblist actually represents.

+
view source

open-doc

(open-doc symbol)

Open the documentation page for this symbol, if known, in the default web browser.

+
view source
\ No newline at end of file diff --git a/docs/codox/beowulf.host.html b/docs/codox/beowulf.host.html index d6c6f6f..1b803cc 100644 --- a/docs/codox/beowulf.host.html +++ b/docs/codox/beowulf.host.html @@ -1,19 +1,100 @@ -beowulf.host documentation

Project

Topics

Namespaces

Public Vars

beowulf.host

provides Lisp 1.5 functions which can’t be (or can’t efficiently be) implemented in Lisp 1.5, which therefore need to be implemented in the host language, in this case Clojure.

ADD1

(ADD1 x)

TODO: write docs

view source

AND

(AND & args)

T if and only if none of my args evaluate to either F or NIL, else F.

-

In beowulf.host principally because I don’t yet feel confident to define varargs functions in Lisp.

view source

ASSOC

(ASSOC x a)

If a is an association list such as the one formed by PAIRLIS in the above example, then assoc will produce the first pair whose first term is x. Thus it is a table searching function.

+beowulf.host documentation

Project

Topics

Namespaces

Public Vars

beowulf.host

provides Lisp 1.5 functions which can’t be (or can’t efficiently be) implemented in Lisp 1.5, which therefore need to be implemented in the host language, in this case Clojure.

+

ADD1

(ADD1 x)

TODO: write docs

+
view source

AND

(AND & args)

T if and only if none of my args evaluate to either F or NIL, else F.

+

In beowulf.host principally because I don’t yet feel confident to define varargs functions in Lisp.

+
view source

ASSOC

(ASSOC x a)

If a is an association list such as the one formed by PAIRLIS in the above example, then assoc will produce the first pair whose first term is x. Thus it is a table searching function.

All args are assumed to be beowulf.cons-cell/ConsCell objects. See page 12 of the Lisp 1.5 Programmers Manual.

-

NOTE THAT this function is overridden by an implementation in Lisp, but is currently still present for bootstrapping.

view source

ATOM

(ATOM x)

Returns T if and only if the argument x is bound to an atom; else F. It is not clear to me from the documentation whether (ATOM 7) should return T or F. I’m going to assume T.

view source

ATOM?

macro

(ATOM? x)

The convention of returning F from predicates, rather than NIL, is going to tie me in knots. This is a variant of ATOM which returns NIL on failure.

view source

CAAAAR

macro

(CAAAAR x)

TODO: write docs

view source

CAAADR

macro

(CAAADR x)

TODO: write docs

view source

CAAAR

macro

(CAAAR x)

TODO: write docs

view source

CAADAR

macro

(CAADAR x)

TODO: write docs

view source

CAADDR

macro

(CAADDR x)

TODO: write docs

view source

CAADR

macro

(CAADR x)

TODO: write docs

view source

CAAR

macro

(CAAR x)

TODO: write docs

view source

CADAAR

macro

(CADAAR x)

TODO: write docs

view source

CADADR

macro

(CADADR x)

TODO: write docs

view source

CADAR

macro

(CADAR x)

TODO: write docs

view source

CADDAR

macro

(CADDAR x)

TODO: write docs

view source

CADDDR

macro

(CADDDR x)

TODO: write docs

view source

CADDR

macro

(CADDR x)

TODO: write docs

view source

CADR

macro

(CADR x)

TODO: write docs

view source

CAR

(CAR x)

Return the item indicated by the first pointer of a pair. NIL is treated specially: the CAR of NIL is NIL.

view source

CDAAAR

macro

(CDAAAR x)

TODO: write docs

view source

CDAADR

macro

(CDAADR x)

TODO: write docs

view source

CDAAR

macro

(CDAAR x)

TODO: write docs

view source

CDADAR

macro

(CDADAR x)

TODO: write docs

view source

CDADDR

macro

(CDADDR x)

TODO: write docs

view source

CDADR

macro

(CDADR x)

TODO: write docs

view source

CDAR

macro

(CDAR x)

TODO: write docs

view source

CDDAAR

macro

(CDDAAR x)

TODO: write docs

view source

CDDADR

macro

(CDDADR x)

TODO: write docs

view source

CDDAR

macro

(CDDAR x)

TODO: write docs

view source

CDDDAR

macro

(CDDDAR x)

TODO: write docs

view source

CDDDDR

macro

(CDDDDR x)

TODO: write docs

view source

CDDDR

macro

(CDDDR x)

TODO: write docs

view source

CDDR

macro

(CDDR x)

TODO: write docs

view source

CDR

(CDR x)

Return the item indicated by the second pointer of a pair. NIL is treated specially: the CDR of NIL is NIL.

view source

CONS

(CONS car cdr)

Construct a new instance of cons cell with this car and cdr.

view source

CONSP

(CONSP o)

Return T if object o is a cons cell, else F.

-

NOTE THAT this is an extension function, not available in strct mode. I believe that Lisp 1.5 did not have any mechanism for testing whether an argument was, or was not, a cons cell.

view source

DEFINE

(DEFINE a-list)

Bootstrap-only version of DEFINE which, post boostrap, can be overwritten in LISP.

-

The single argument to DEFINE should be an association list of symbols to lambda functions. See page 58 of the manual.

view source

DEFLIST

(DEFLIST a-list indicator)

For each pair in this association list a-list, set the property with this indicator of the symbol which is the first element of the pair to the value which is the second element of the pair. See page 58 of the manual.

view source

DIFFERENCE

(DIFFERENCE x y)

TODO: write docs

view source

DOC

(DOC symbol)

Open the page for this symbol in the Lisp 1.5 manual, if known, in the default web browser.

-

NOTE THAT this is an extension function, not available in strct mode.

view source

EQ

(EQ x y)

Returns T if and only if both x and y are bound to the same atom, else NIL.

view source

EQUAL

(EQUAL x y)

This is a predicate that is true if its two arguments are identical S-expressions, and false if they are different. (The elementary predicate EQ is defined only for atomic arguments.) The definition of EQUAL is an example of a conditional expression inside a conditional expression.

-

NOTE: returns F on failure, not NIL

view source

ERROR

(ERROR & args)

Throw an error

view source

FIXP

(FIXP x)

TODO: write docs

view source

GENSYM

(GENSYM)

Generate a unique symbol.

view source

GET

(GET symbol indicator)

From the manual:

+

NOTE THAT this function is overridden by an implementation in Lisp, but is currently still present for bootstrapping.

+
view source

ATOM

(ATOM x)

Returns T if and only if the argument x is bound to an atom; else F. It is not clear to me from the documentation whether (ATOM 7) should return T or F. I’m going to assume T.

+
view source

ATOM?

macro

(ATOM? x)

The convention of returning F from predicates, rather than NIL, is going to tie me in knots. This is a variant of ATOM which returns NIL on failure.

+
view source

ATTRIB

(ATTRIB x e)

Destructive append. From page 59 of the manual:

+

The function attrib concatenates its two arguments by changing the last element of its first argument to point to the second argument. Thus it is commonly used to tack something onto the end of a property list. The value of attrib is the second argument.

+

For example

+
attrib[FF; (EXPR (LAMBDA (X) (COND ((ATOM X) X) (T (FF (CAR x))))))]
+
+

would put EXPR followed by the LAMBDA expression for FF onto the end of the property list for FF.

+
view source

CAAAAR

macro

(CAAAAR x)

TODO: write docs

+
view source

CAAADR

macro

(CAAADR x)

TODO: write docs

+
view source

CAAAR

macro

(CAAAR x)

TODO: write docs

+
view source

CAADAR

macro

(CAADAR x)

TODO: write docs

+
view source

CAADDR

macro

(CAADDR x)

TODO: write docs

+
view source

CAADR

macro

(CAADR x)

TODO: write docs

+
view source

CAAR

macro

(CAAR x)

TODO: write docs

+
view source

CADAAR

macro

(CADAAR x)

TODO: write docs

+
view source

CADADR

macro

(CADADR x)

TODO: write docs

+
view source

CADAR

macro

(CADAR x)

TODO: write docs

+
view source

CADDAR

macro

(CADDAR x)

TODO: write docs

+
view source

CADDDR

macro

(CADDDR x)

TODO: write docs

+
view source

CADDR

macro

(CADDR x)

TODO: write docs

+
view source

CADR

macro

(CADR x)

TODO: write docs

+
view source

CAR

(CAR x)

Return the item indicated by the first pointer of a pair. NIL is treated specially: the CAR of NIL is NIL.

+
view source

CDAAAR

macro

(CDAAAR x)

TODO: write docs

+
view source

CDAADR

macro

(CDAADR x)

TODO: write docs

+
view source

CDAAR

macro

(CDAAR x)

TODO: write docs

+
view source

CDADAR

macro

(CDADAR x)

TODO: write docs

+
view source

CDADDR

macro

(CDADDR x)

TODO: write docs

+
view source

CDADR

macro

(CDADR x)

TODO: write docs

+
view source

CDAR

macro

(CDAR x)

TODO: write docs

+
view source

CDDAAR

macro

(CDDAAR x)

TODO: write docs

+
view source

CDDADR

macro

(CDDADR x)

TODO: write docs

+
view source

CDDAR

macro

(CDDAR x)

TODO: write docs

+
view source

CDDDAR

macro

(CDDDAR x)

TODO: write docs

+
view source

CDDDDR

macro

(CDDDDR x)

TODO: write docs

+
view source

CDDDR

macro

(CDDDR x)

TODO: write docs

+
view source

CDDR

macro

(CDDR x)

TODO: write docs

+
view source

CDR

(CDR x)

Return the item indicated by the second pointer of a pair. NIL is treated specially: the CDR of NIL is NIL.

+
view source

CONS

(CONS car cdr)

Construct a new instance of cons cell with this car and cdr.

+
view source

CONSP

(CONSP o)

Return T if object o is a cons cell, else F.

+

NOTE THAT this is an extension function, not available in strct mode. I believe that Lisp 1.5 did not have any mechanism for testing whether an argument was, or was not, a cons cell.

+
view source

DEFINE

(DEFINE a-list)

Bootstrap-only version of DEFINE which, post boostrap, can be overwritten in LISP.

+

The single argument to DEFINE should be an association list of symbols to lambda functions. See page 58 of the manual.

+
view source

DEFLIST

(DEFLIST a-list indicator)

For each pair in this association list a-list, set the property with this indicator of the symbol which is the first element of the pair to the value which is the second element of the pair. See page 58 of the manual.

+
view source

DIFFERENCE

(DIFFERENCE x y)

TODO: write docs

+
view source

DOC

(DOC symbol)

Open the page for this symbol in the Lisp 1.5 manual, if known, in the default web browser.

+

NOTE THAT this is an extension function, not available in strct mode.

+
view source

EQ

(EQ x y)

Returns T if and only if both x and y are bound to the same atom, else NIL.

+
view source

EQUAL

(EQUAL x y)

This is a predicate that is true if its two arguments are identical S-expressions, and false if they are different. (The elementary predicate EQ is defined only for atomic arguments.) The definition of EQUAL is an example of a conditional expression inside a conditional expression.

+

NOTE: returns F on failure, not NIL

+
view source

ERROR

(ERROR & args)

Throw an error

+
view source

FIXP

(FIXP x)

TODO: write docs

+
view source

GENSYM

(GENSYM)

Generate a unique symbol.

+
view source

GET

(GET symbol indicator)

From the manual:

‘get is somewhat like prop; however its value is car of the rest of the list if the indicator is found, and NIL otherwise.’

It’s clear that GET is expected to be defined in terms of PROP, but we can’t implement PROP here because we lack EVAL; and we can’t have EVAL here because both it and APPLY depends on GET.

-

OK, It’s worse than that: the statement of the definition of GET (and of) PROP on page 59 says that the first argument to each must be a list; But the in the definition of ASSOC on page 70, when GET is called its first argument is always an atom. Since it’s ASSOC and EVAL which I need to make work, I’m going to assume that page 59 is wrong.

view source

GREATERP

(GREATERP x y)

TODO: write docs

view source

lax?

(lax? symbol)

Are we in lax mode? If so. return true; is not, throw an exception with this symbol.

view source

LESSP

(LESSP x y)

TODO: write docs

view source

LIST

(LIST & args)

TODO: write docs

view source

magic-marker

The unexplained magic number which marks the start of a property list.

view source

NILP

macro

(NILP x)

Not part of LISP 1.5: T if o is NIL, else NIL.

view source

NULL

macro

(NULL x)

Returns T if and only if the argument x is bound to NIL; else F.

view source

NUMBERP

(NUMBERP x)

TODO: write docs

view source

OBLIST

(OBLIST)

Return a list of the symbols currently bound on the object list.

-

NOTE THAT in the Lisp 1.5 manual, footnote at the bottom of page 69, it implies that an argument can be passed but I’m not sure of the semantics of this.

view source

OR

(OR & args)

T if and only if at least one of my args evaluates to something other than either F or NIL, else F.

-

In beowulf.host principally because I don’t yet feel confident to define varargs functions in Lisp.

view source

PAIRLIS

(PAIRLIS x y a)

This function gives the list of pairs of corresponding elements of the lists x and y, and APPENDs this to the list a. The resultant list of pairs, which is like a table with two columns, is called an association list.

+

OK, It’s worse than that: the statement of the definition of GET (and of) PROP on page 59 says that the first argument to each must be a list; But the in the definition of ASSOC on page 70, when GET is called its first argument is always an atom. Since it’s ASSOC and EVAL which I need to make work, I’m going to assume that page 59 is wrong.

+
view source

GREATERP

(GREATERP x y)

TODO: write docs

+
view source

hit-or-miss-assoc

(hit-or-miss-assoc target plist)

Find the position of the binding of this target in a Lisp 1.5 property list plist.

+

Lisp 1.5 property lists are not assoc lists, but lists of the form (name value name value name value...). It’s therefore necessary to recurse down the list two entries at a time to avoid confusing names with values.

+
view source

lax?

(lax? symbol)

Are we in lax mode? If so. return true; is not, throw an exception with this symbol.

+
view source

LESSP

(LESSP x y)

TODO: write docs

+
view source

LIST

(LIST & args)

TODO: write docs

+
view source

magic-marker

The unexplained magic number which marks the start of a property list.

+
view source

NILP

macro

(NILP x)

Not part of LISP 1.5: T if o is NIL, else NIL.

+
view source

NULL

macro

(NULL x)

Returns T if and only if the argument x is bound to NIL; else F.

+
view source

NUMBERP

(NUMBERP x)

TODO: write docs

+
view source

OBLIST

(OBLIST)

Return a list of the symbols currently bound on the object list.

+

NOTE THAT in the Lisp 1.5 manual, footnote at the bottom of page 69, it implies that an argument can be passed but I’m not sure of the semantics of this.

+
view source

OR

(OR & args)

T if and only if at least one of my args evaluates to something other than either F or NIL, else F.

+

In beowulf.host principally because I don’t yet feel confident to define varargs functions in Lisp.

+
view source

PAIRLIS

(PAIRLIS x y a)

This function gives the list of pairs of corresponding elements of the lists x and y, and APPENDs this to the list a. The resultant list of pairs, which is like a table with two columns, is called an association list.

Eessentially, it builds the environment on the stack, implementing shallow binding.

All args are assumed to be beowulf.cons-cell/ConsCell objects. See page 12 of the Lisp 1.5 Programmers Manual.

-

NOTE THAT this function is overridden by an implementation in Lisp, but is currently still present for bootstrapping.

view source

PLUS

(PLUS & args)

TODO: write docs

view source

PUT

(PUT symbol indicator value)

Put this value as the value of the property indicated by this indicator of this symbol. Return value on success.

-

NOTE THAT there is no PUT defined in the manual, but it would have been easy to have defined it so I don’t think this fully counts as an extension.

view source

QUOTIENT

(QUOTIENT x y)

I’m not certain from the documentation whether Lisp 1.5 QUOTIENT returned the integer part of the quotient, or a realnum representing the whole quotient. I am for now implementing the latter.

view source

REMAINDER

(REMAINDER x y)

TODO: write docs

view source

RPLACA

(RPLACA cell value)

Replace the CAR pointer of this cell with this value. Dangerous, should really not exist, but does in Lisp 1.5 (and was important for some performance hacks in early Lisps)

view source

RPLACD

(RPLACD cell value)

Replace the CDR pointer of this cell with this value. Dangerous, should really not exist, but does in Lisp 1.5 (and was important for some performance hacks in early Lisps)

view source

SET

(SET symbol val)

Implementation of SET in Clojure. Add to the oblist a binding of the value of var to the value of val. NOTE WELL: this is not SETQ!

view source

SUB1

(SUB1 x)

TODO: write docs

view source

TIMES

(TIMES & args)

TODO: write docs

view source

TRACE

(TRACE s)

Add this s to the set of symbols currently being traced. If s is not a symbol or sequence of symbols, does nothing.

view source

traced-symbols

Symbols currently being traced.

view source

traced?

(traced? s)

Return true iff s is a symbol currently being traced, else nil.

view source

uaf

(uaf l path)

Universal access function; l is expected to be an arbitrary LISP list, path a (clojure) list of the characters a and d. Intended to make declaring all those fiddly #'c[ad]+r' functions a bit easier

view source

UNTRACE

(UNTRACE s)

Remove this s from the set of symbols currently being traced. If s is not a symbol or sequence of symbols, does nothing.

view source
\ No newline at end of file +

NOTE THAT this function is overridden by an implementation in Lisp, but is currently still present for bootstrapping.

+
view source

PLUS

(PLUS & args)

TODO: write docs

+
view source

PUT

(PUT symbol indicator value)

Put this value as the value of the property indicated by this indicator of this symbol. Return value on success.

+

NOTE THAT there is no PUT defined in the manual, but it would have been easy to have defined it so I don’t think this fully counts as an extension.

+
view source

QUOTIENT

(QUOTIENT x y)

I’m not certain from the documentation whether Lisp 1.5 QUOTIENT returned the integer part of the quotient, or a realnum representing the whole quotient. I am for now implementing the latter.

+
view source

REMAINDER

(REMAINDER x y)

TODO: write docs

+
view source

RPLACA

(RPLACA cell value)

Replace the CAR pointer of this cell with this value. Dangerous, should really not exist, but does in Lisp 1.5 (and was important for some performance hacks in early Lisps)

+
view source

RPLACD

(RPLACD cell value)

Replace the CDR pointer of this cell with this value. Dangerous, should really not exist, but does in Lisp 1.5 (and was important for some performance hacks in early Lisps)

+
view source

SET

(SET symbol val)

Implementation of SET in Clojure. Add to the oblist a binding of the value of var to the value of val. NOTE WELL: this is not SETQ!

+
view source

SUB1

(SUB1 x)

TODO: write docs

+
view source

TIMES

(TIMES & args)

TODO: write docs

+
view source

TRACE

(TRACE s)

Add this s to the set of symbols currently being traced. If s is not a symbol or sequence of symbols, does nothing.

+
view source

traced-symbols

Symbols currently being traced.

+
view source

traced?

(traced? s)

Return true iff s is a symbol currently being traced, else nil.

+
view source

uaf

(uaf l path)

Universal access function; l is expected to be an arbitrary LISP list, path a (clojure) list of the characters a and d. Intended to make declaring all those fiddly #'c[ad]+r' functions a bit easier

+
view source

UNTRACE

(UNTRACE s)

Remove this s from the set of symbols currently being traced. If s is not a symbol or sequence of symbols, does nothing.

+
view source
\ No newline at end of file diff --git a/docs/codox/beowulf.interop.html b/docs/codox/beowulf.interop.html index cd46169..8d4ec99 100644 --- a/docs/codox/beowulf.interop.html +++ b/docs/codox/beowulf.interop.html @@ -1,11 +1,17 @@ -beowulf.interop documentation

Project

Topics

Namespaces

Public Vars

beowulf.interop

TODO: write docs

INTEROP

(INTEROP fn-symbol args)

Clojure (or other host environment) interoperation API. fn-symbol is expected to be either

+beowulf.interop documentation

Project

Topics

Namespaces

Public Vars

beowulf.interop

TODO: write docs

+

INTEROP

(INTEROP fn-symbol args)

Clojure (or other host environment) interoperation API. fn-symbol is expected to be either

    -
  1. a symbol bound in the host environment to a function; or
    2. -
  2. a sequence (list) of symbols forming a qualified path name bound to a function.
    3. +
  3. a symbol bound in the host environment to a function; or
    4. +
  4. a sequence (list) of symbols forming a qualified path name bound to a function.

Lower case characters cannot normally be represented in Lisp 1.5, so both the upper case and lower case variants of fn-symbol will be tried. If the function you’re looking for has a mixed case name, that is not currently accessible.

args is expected to be a Lisp 1.5 list of arguments to be passed to that function. Return value must be something acceptable to Lisp 1.5, so either a symbol, a number, or a Lisp 1.5 list.

-

If fn-symbol is not found (even when cast to lower case), or is not a function, or the value returned cannot be represented in Lisp 1.5, an exception is thrown with :cause bound to :interop and :detail set to a value representing the actual problem.

view source

interpret-qualified-name

(interpret-qualified-name l)

For interoperation with Clojure, it will often be necessary to pass qualified names that are not representable in Lisp 1.5. This function takes a sequence in the form (PART PART PART... NAME) and returns a symbol in the form part.part.part/NAME. This symbol will then be tried in both that form and lower-cased. Names with hyphens or underscores cannot be represented with this scheme.

view source

listify-qualified-name

(listify-qualified-name subr)

We need to be able to print something we can link to the particular Clojure function subr in a form in which Lisp 1.5 is able to read it back in and relink it.

-

This assumes subr is either 1. a string in the format #'beowulf.io/SYSIN or beowulf.io/SYSIN; or 2. something which, when coerced to a string with str, will have such a format.

view source

to-beowulf

(to-beowulf o)

Return a beowulf-native representation of the Clojure object o. Numbers and symbols are unaffected. Collections have to be converted; strings must be converted to symbols.

view source

to-clojure

(to-clojure l)

If l is a beowulf.cons_cell.ConsCell, return a Clojure list having the same members in the same order.

view source
\ No newline at end of file +

If fn-symbol is not found (even when cast to lower case), or is not a function, or the value returned cannot be represented in Lisp 1.5, an exception is thrown with :cause bound to :interop and :detail set to a value representing the actual problem.

+
view source

interpret-qualified-name

(interpret-qualified-name l)

For interoperation with Clojure, it will often be necessary to pass qualified names that are not representable in Lisp 1.5. This function takes a sequence in the form (PART PART PART... NAME) and returns a symbol in the form part.part.part/NAME. This symbol will then be tried in both that form and lower-cased. Names with hyphens or underscores cannot be represented with this scheme.

+
view source

listify-qualified-name

(listify-qualified-name subr)

We need to be able to print something we can link to the particular Clojure function subr in a form in which Lisp 1.5 is able to read it back in and relink it.

+

This assumes subr is either 1. a string in the format #'beowulf.io/SYSIN or beowulf.io/SYSIN; or 2. something which, when coerced to a string with str, will have such a format.

+
view source

to-beowulf

(to-beowulf o)

Return a beowulf-native representation of the Clojure object o. Numbers and symbols are unaffected. Collections have to be converted; strings must be converted to symbols.

+
view source

to-clojure

(to-clojure l)

If l is a beowulf.cons_cell.ConsCell, return a Clojure list having the same members in the same order.

+
view source
\ No newline at end of file diff --git a/docs/codox/beowulf.io.html b/docs/codox/beowulf.io.html index d5bae54..b0aa1ea 100644 --- a/docs/codox/beowulf.io.html +++ b/docs/codox/beowulf.io.html @@ -1,13 +1,19 @@ -beowulf.io documentation

Project

Topics

Namespaces

Public Vars

beowulf.io

Non-standard extensions to Lisp 1.5 to read and write to the filesystem.

+beowulf.io documentation

Project

Topics

Namespaces

Public Vars

beowulf.io

Non-standard extensions to Lisp 1.5 to read and write to the filesystem.

Lisp 1.5 had only READ, which read one S-Expression at a time, and various forms of PRIN* functions, which printed to the line printer. There was also PUNCH, which wrote to a card punch. It does not seem that there was any concept of an interactive terminal.

-

See Appendix E, OVERLORD - THE MONITOR, and Appendix F, LISP INPUT -AND OUTPUT.

+

See Appendix E, OVERLORD - THE MONITOR, and Appendix F, LISP INPUT AND OUTPUT.

For our purposes, to save the current state of the Lisp system it should be sufficient to print the current contents of the oblist to file; and to restore a previous state from file, to overwrite the contents of the oblist with data from that file.

-

Hence functions SYSOUT and SYSIN, which do just that.

default-sysout

TODO: write docs

view source

resolve-subr

(resolve-subr entry)(resolve-subr entry prop)

If this oblist entry references a subroutine, attempt to fix up that reference.

view source

safely-wrap-subr

(safely-wrap-subr entry)

TODO: write docs

view source

safely-wrap-subrs

(safely-wrap-subrs objects)

TODO: write docs

view source

SYSIN

(SYSIN)(SYSIN filename)

Read the contents of the file at this filename into the object list.

+

Hence functions SYSOUT and SYSIN, which do just that.

+

default-sysout

TODO: write docs

+
view source

resolve-subr

(resolve-subr entry)(resolve-subr entry prop)

If this oblist entry references a subroutine, attempt to fix up that reference.

+
view source

safely-wrap-subr

(safely-wrap-subr entry)

TODO: write docs

+
view source

safely-wrap-subrs

(safely-wrap-subrs objects)

TODO: write docs

+
view source

SYSIN

(SYSIN)(SYSIN filename)

Read the contents of the file at this filename into the object list.

If the file is not a valid Beowulf sysout file, this will probably corrupt the system, you have been warned. File paths will be considered relative to the filepath set when starting Lisp.

It is intended that sysout files can be read both from resources within the jar file, and from the file system. If a named file exists in both the file system and the resources, the file system will be preferred.

NOTE THAT if the provided filename does not end with .lsp (which, if you’re writing it from the Lisp REPL, it won’t), the extension .lsp will be appended.

-

NOTE THAT this is an extension function, not available in strct mode.

view source

SYSOUT

(SYSOUT)(SYSOUT filepath)

Dump the current content of the object list to file. If no filepath is specified, a file name will be constructed of the symbol Sysout and the current date. File paths will be considered relative to the filepath set when starting Lisp.

-

NOTE THAT this is an extension function, not available in strct mode.

view source
\ No newline at end of file +

NOTE THAT this is an extension function, not available in strct mode.

+
view source

SYSOUT

(SYSOUT)(SYSOUT filepath)

Dump the current content of the object list to file. If no filepath is specified, a file name will be constructed of the symbol Sysout and the current date. File paths will be considered relative to the filepath set when starting Lisp.

+

NOTE THAT this is an extension function, not available in strct mode.

+
view source
\ No newline at end of file diff --git a/docs/codox/beowulf.manual.html b/docs/codox/beowulf.manual.html index cd01906..b38f14c 100644 --- a/docs/codox/beowulf.manual.html +++ b/docs/codox/beowulf.manual.html @@ -1,3 +1,8 @@ -beowulf.manual documentation

Project

Topics

Namespaces

Public Vars

beowulf.manual

Experimental code for accessing the manual online.

*manual-url*

dynamic

TODO: write docs

view source

format-page-references

(format-page-references fn-symbol)

Format page references from the manual index for the function whose name is fn-symbol.

view source

index

This is data extracted from the index pages of Lisp 1.5 Programmer's Manual. It’s here in the hope that we can automatically link to an online PDF link to the manual when the user invokes a function probably called DOC or HELP.

view source

page-url

(page-url page-no)

Format the URL for the page in the manual with this page-no.

view source
\ No newline at end of file +beowulf.manual documentation

Project

Topics

Namespaces

Public Vars

beowulf.manual

Experimental code for accessing the manual online.

+

*manual-url*

dynamic

TODO: write docs

+
view source

format-page-references

(format-page-references fn-symbol)

Format page references from the manual index for the function whose name is fn-symbol.

+
view source

index

This is data extracted from the index pages of Lisp 1.5 Programmer's Manual. It’s here in the hope that we can automatically link to an online PDF link to the manual when the user invokes a function probably called DOC or HELP.

+
view source

page-url

(page-url page-no)

Format the URL for the page in the manual with this page-no.

+
view source
\ No newline at end of file diff --git a/docs/codox/beowulf.oblist.html b/docs/codox/beowulf.oblist.html index 74f48e7..a468d75 100644 --- a/docs/codox/beowulf.oblist.html +++ b/docs/codox/beowulf.oblist.html @@ -1,5 +1,9 @@ -beowulf.oblist documentation

Project

Topics

Namespaces

Public Vars

beowulf.oblist

A namespace mainly devoted to the object list and other top level global variables.

-

Yes, this makes little sense, but if you put them anywhere else you end up in cyclic dependency hell.

*options*

dynamic

Command line options from invocation.

view source

NIL

The canonical empty list symbol.

-

TODO: this doesn’t really work, because (from Clojure) (empty? NIL) throws an exception. It might be better to subclass beowulf.cons_cell.ConsCell to create a new singleton class Nil which overrides the empty method of IPersistentCollection?

view source

oblist

The default environment.

view source
\ No newline at end of file +beowulf.oblist documentation

Project

Topics

Namespaces

Public Vars

beowulf.oblist

A namespace mainly devoted to the object list and other top level global variables.

+

Yes, this makes little sense, but if you put them anywhere else you end up in cyclic dependency hell.

+

*options*

dynamic

Command line options from invocation.

+
view source

NIL

The canonical empty list symbol.

+

TODO: this doesn’t really work, because (from Clojure) (empty? NIL) throws an exception. It might be better to subclass beowulf.cons_cell.ConsCell to create a new singleton class Nil which overrides the empty method of IPersistentCollection?

+
view source

oblist

The default environment.

+
view source
\ No newline at end of file diff --git a/docs/codox/beowulf.read.html b/docs/codox/beowulf.read.html index cfa7e94..0e9c56b 100644 --- a/docs/codox/beowulf.read.html +++ b/docs/codox/beowulf.read.html @@ -1,9 +1,16 @@ -beowulf.read documentation

Project

Topics

Namespaces

Public Vars

beowulf.read

This provides the reader required for boostrapping. It’s not a bad reader - it provides feedback on errors found in the input - but it isn’t the real Lisp reader.

+beowulf.read documentation

Project

Topics

Namespaces

Public Vars

beowulf.read

This provides the reader required for boostrapping. It’s not a bad reader - it provides feedback on errors found in the input - but it isn’t the real Lisp reader.

Intended deviations from the behaviour of the real Lisp reader are as follows:

    -
  1. It reads the meta-expression language MEXPR in addition to the symbolic expression language SEXPR, which I do not believe the Lisp 1.5 reader ever did;
    2. -
  2. It treats everything between a double semi-colon and an end of line as a comment, as most modern Lisps do; but I do not believe Lisp 1.5 had this feature.
    3. +
  3. It reads the meta-expression language MEXPR in addition to the symbolic expression language SEXPR, which I do not believe the Lisp 1.5 reader ever did;
    4. +
  4. It treats everything between a double semi-colon and an end of line as a comment, as most modern Lisps do; but I do not believe Lisp 1.5 had this feature.
-

Both these extensions can be disabled by using the --strict command line switch.

gsp

(gsp s)

Shortcut macro - the internals of read; or, if you like, read-string. Argument s should be a string representation of a valid Lisp expression.

view source

number-lines

(number-lines s)(number-lines s e)

TODO: write docs

view source

READ

(READ)(READ input)

An implementation of a Lisp reader sufficient for bootstrapping; not necessarily the final Lisp reader. input should be either a string representation of a LISP expression, or else an input stream. A single form will be read.

view source

read-from-console

(read-from-console)

Attempt to read a complete lisp expression from the console. NOTE that this will only really work for S-Expressions, not M-Expressions.

view source

strip-line-comments

(strip-line-comments s)

Strip blank lines and comment lines from this string s, expected to be Lisp source.

view source
\ No newline at end of file +

Both these extensions can be disabled by using the --strict command line switch.

+

gsp

(gsp s)

Shortcut macro - the internals of read; or, if you like, read-string. Argument s should be a string representation of a valid Lisp expression.

+
view source

number-lines

(number-lines s)(number-lines s e)

TODO: write docs

+
view source

READ

(READ)(READ input)

An implementation of a Lisp reader sufficient for bootstrapping; not necessarily the final Lisp reader. input should be either a string representation of a LISP expression, or else an input stream. A single form will be read.

+
view source

read-from-console

(read-from-console prompt)

Attempt to read a complete lisp expression from the console.

+

There’s a major problem here that the read-chars reader messes up testing. We need to be able to disable it while testing!

+
view source

strip-line-comments

(strip-line-comments s)

Strip blank lines and comment lines from this string s, expected to be Lisp source.

+
view source
\ No newline at end of file diff --git a/docs/codox/beowulf.reader.char-reader.html b/docs/codox/beowulf.reader.char-reader.html index a014787..d5a0f22 100644 --- a/docs/codox/beowulf.reader.char-reader.html +++ b/docs/codox/beowulf.reader.char-reader.html @@ -1,13 +1,20 @@ -beowulf.reader.char-reader documentation

Project

Topics

Namespaces

Public Vars

    beowulf.reader.char-reader

    Provide sensible line editing, auto completion, and history recall.

    +beowulf.reader.char-reader documentation

    Project

    Topics

    Namespaces

    Public Vars

    beowulf.reader.char-reader

    Provide sensible line editing, auto completion, and history recall.

    None of what’s needed here is really working yet, and a pull request with a working implementation would be greatly welcomed.

    -

    What’s needed (rough specification)

    +

    What’s needed (rough specification)

      -
    1. Carriage return does not cause input to be returned, unless a. the number of open brackets ( and closing brackets ) match; and b. the number of open square brackets [ and closing square brackets ] also match;
      2. -
    2. aborts editing and returns the string STOP;
      3. -
    3. and scroll back and forward through history, but ideally I’d like this to be the Lisp history (i.e. the history of S-Expressions actually read by READ, rather than the strings which were supplied to READ);
      4. -
    4. offers potential auto-completions taken from the value of (OBLIST), ideally the current value, not the value at the time the session started;
      5. -
    5. and offer movement and editing within the line.
      6. +
    6. Carriage return does not cause input to be returned, unless a. the number of open brackets ( and closing brackets ) match; and b. the number of open square brackets [ and closing square brackets ] also match;
      7. +
    7. aborts editing and returns the string STOP;
      8. +
    8. and scroll back and forward through history, but ideally I’d like this to be the Lisp history (i.e. the history of S-Expressions actually read by READ, rather than the strings which were supplied to READ);
      9. +
    9. offers potential auto-completions taken from the value of (OBLIST), ideally the current value, not the value at the time the session started;
      10. +
    10. and offer movement and editing within the line.
    -

    TODO: There are multiple problems with JLine; a better solution might be to start from here: https://stackoverflow.com/questions/7931988/how-to-manipulate-control-characters

    \ No newline at end of file +

    TODO: There are multiple problems with JLine; a better solution might be to start from here: https://stackoverflow.com/questions/7931988/how-to-manipulate-control-characters

    +

    build-completer

    (build-completer)

    Build a completer which takes tokens from the oblist.

    +

    This is sort-of working, in as much as hitting on a blank line will show a table of values from the oblist, but hitting after you’ve started input does not show potential completions for tokens you’ve started.

    +
    view source

    get-reader

    Return a reader, first constructing it if necessary.

    +

    NOTE THAT this is not settled API. The existence and call signature of this function is not guaranteed in future versions.

    +
    view source

    read-chars

    (read-chars prompt)

    A drop-in replacement for clojure.core/read-line, except that line editing and history should be enabled.

    +

    NOTE THAT this does not fully work yet, but it is in the API because I hope that it will work later!

    +
    view source
    \ No newline at end of file diff --git a/docs/codox/beowulf.reader.generate.html b/docs/codox/beowulf.reader.generate.html index 58d4e15..0325184 100644 --- a/docs/codox/beowulf.reader.generate.html +++ b/docs/codox/beowulf.reader.generate.html @@ -1,13 +1,13 @@ -beowulf.reader.generate documentation

    Project

    Topics

    Namespaces

    Public Vars

    beowulf.reader.generate

    Generating S-Expressions from parse trees.

    -

    From Lisp 1.5 Programmers Manual, page 10

    +beowulf.reader.generate documentation

    Project

    Topics

    Namespaces

    Public Vars

    beowulf.reader.generate

    Generating S-Expressions from parse trees.

    +

    From Lisp 1.5 Programmers Manual, page 10

    Note that I’ve retyped much of this, since copy/pasting out of PDF is less than reliable. Any typos are mine.

    Quote starts:

    We are now in a position to define the universal LISP function evalquote[fn;args], When evalquote is given a function and a list of arguments for that function, it computes the value of the function applied to the arguments. LISP functions have S-expressions as arguments. In particular, the argument fn of the function evalquote must be an S-expression. Since we have been writing functions as M-expressions, it is necessary to translate them into S-expressions.

    -

    The following rules define a method of translating functions written in the meta-language into S-expressions. 1. If the function is represented by its name, it is translated by changing all of the letters to upper case, making it an atomic symbol. Thus car is translated to CAR. 2. If the function uses the lambda notation, then the expression λ[[x ..;xn]; ε] is translated into (LAMBDA (X1 ...XN) ε*), where ε* is the translation of ε. 3. If the function begins with label, then the translation of label[α;ε] is (LABEL α* ε*).

    -

    Forms are translated as follows: 1. A variable, like a function name, is translated by using uppercase letters. Thus the translation of var1 is VAR1. 2. The obvious translation of letting a constant translate into itself will not work. Since the translation of x is X, the translation of X must be something else to avoid ambiguity. The solution is to quote it. Thus X is translated into (QUOTE X). 3. The form fn[argl;. ..;argn] is translated into (fn* argl* ...argn*) 4. The conditional expression [pl-el;...;pn-en] is translated into (COND (p1* e1*)...(pn* en*))

    -

    Examples

    +

    The following rules define a method of translating functions written in the meta-language into S-expressions. 1. If the function is represented by its name, it is translated by changing all of the letters to upper case, making it an atomic symbol. Thus car is translated to CAR. 2. If the function uses the lambda notation, then the expression λ[[x ..;xn]; ε] is translated into (LAMBDA (X1 ...XN) ε*), where ε* is the translation of ε. 3. If the function begins with label, then the translation of label[α;ε] is (LABEL α* ε*).

    +

    Forms are translated as follows: 1. A variable, like a function name, is translated by using uppercase letters. Thus the translation of var1 is VAR1. 2. The obvious translation of letting a constant translate into itself will not work. Since the translation of x is X, the translation of X must be something else to avoid ambiguity. The solution is to quote it. Thus X is translated into (QUOTE X). 3. The form fn[argl;. ..;argn] is translated into (fn* argl* ...argn*) 4. The conditional expression [pl-el;...;pn-en] is translated into (COND (p1* e1*)...(pn* en*))

    +

    Examples

      M-expressions                                  S-expressions             
 
   x                                              X                         
@@ -21,4 +21,15 @@
        T->ff[car[x]]]]]                              (COND ((ATOM X) X) 
                                                          ((QUOTE T)(FF (CAR X))))))
    -

    quote ends

    gen-cond

    (gen-cond p context)

    Generate a cond statement from this simplified parse tree fragment p; returns nil if p does not represent a (MEXPR) cond statement.

    view source

    gen-cond-clause

    (gen-cond-clause p context)

    Generate a cond clause from this simplified parse tree fragment p; returns nil if p does not represent a cond clause.

    view source

    gen-dot-terminated-list

    (gen-dot-terminated-list p)

    Generate a list, which may be dot-terminated, from this partial parse tree ‘p’. Note that the function acts recursively and progressively decapitates its argument, so that the argument will not always be a valid parse tree.

    view source

    gen-fn-call

    (gen-fn-call p context)

    Generate a function call from this simplified parse tree fragment p; returns nil if p does not represent a (MEXPR) function call.

    view source

    gen-iexpr

    (gen-iexpr tree context)

    TODO: write docs

    view source

    generate

    (generate p)(generate p context)

    Generate lisp structure from this parse tree p. It is assumed that p has been simplified.

    view source

    generate-assign

    (generate-assign tree context)

    Generate an assignment statement based on this tree. If the thing being assigned to is a function signature, then we have to do something different to if it’s an atom.

    view source

    generate-defn

    (generate-defn tree context)

    TODO: write docs

    view source

    generate-set

    (generate-set tree context)

    Actually not sure what the mexpr representation of set looks like

    view source

    strip-leading-zeros

    (strip-leading-zeros s)(strip-leading-zeros s prefix)

    read-string interprets strings with leading zeros as octal; strip any from this string s. If what’s left is empty (i.e. there were only zeros, return "0".

    view source
    \ No newline at end of file +

    quote ends

    +

    gen-cond

    (gen-cond p context)

    Generate a cond statement from this simplified parse tree fragment p; returns nil if p does not represent a (MEXPR) cond statement.

    +
    view source

    gen-cond-clause

    (gen-cond-clause p context)

    Generate a cond clause from this simplified parse tree fragment p; returns nil if p does not represent a cond clause.

    +
    view source

    gen-dot-terminated-list

    (gen-dot-terminated-list p)

    Generate a list, which may be dot-terminated, from this partial parse tree ‘p’. Note that the function acts recursively and progressively decapitates its argument, so that the argument will not always be a valid parse tree.

    +
    view source

    gen-fn-call

    (gen-fn-call p context)

    Generate a function call from this simplified parse tree fragment p; returns nil if p does not represent a (MEXPR) function call.

    +
    view source

    gen-iexpr

    (gen-iexpr tree context)

    TODO: write docs

    +
    view source

    generate

    (generate p)(generate p context)

    Generate lisp structure from this parse tree p. It is assumed that p has been simplified.

    +
    view source

    generate-assign

    (generate-assign tree context)

    Generate an assignment statement based on this tree. If the thing being assigned to is a function signature, then we have to do something different to if it’s an atom.

    +
    view source

    generate-defn

    (generate-defn tree context)

    TODO: write docs

    +
    view source

    generate-set

    (generate-set tree context)

    Actually not sure what the mexpr representation of set looks like

    +
    view source

    strip-leading-zeros

    (strip-leading-zeros s)(strip-leading-zeros s prefix)

    read-string interprets strings with leading zeros as octal; strip any from this string s. If what’s left is empty (i.e. there were only zeros, return "0".

    +
    view source
    \ No newline at end of file diff --git a/docs/codox/beowulf.reader.macros.html b/docs/codox/beowulf.reader.macros.html index 19c4982..4cd6085 100644 --- a/docs/codox/beowulf.reader.macros.html +++ b/docs/codox/beowulf.reader.macros.html @@ -1,5 +1,8 @@ -beowulf.reader.macros documentation

    Project

    Topics

    Namespaces

    Public Vars

    beowulf.reader.macros

    Can I implement reader macros? let’s see!

    +beowulf.reader.macros documentation

    Project

    Topics

    Namespaces

    Public Vars

    beowulf.reader.macros

    Can I implement reader macros? let’s see!

    We don’t need (at least, in the Clojure reader) to rewrite forms like 'FOO, because that’s handled by the parser. But we do need to rewrite things which don’t evaluate their arguments, like SETQ, because (unless LABEL does it, which I’m not yet sure of) we’re not yet able to implement things which don’t evaluate arguments.

    -

    TODO: at this stage, the following should probably also be read macros: DEFINE

    *readmacros*

    dynamic

    TODO: write docs

    view source

    expand-macros

    (expand-macros form)

    TODO: write docs

    view source
    \ No newline at end of file +

    TODO: at this stage, the following should probably also be read macros: DEFINE

    +

    *readmacros*

    dynamic

    TODO: write docs

    +
    view source

    expand-macros

    (expand-macros form)

    TODO: write docs

    +
    view source
    \ No newline at end of file diff --git a/docs/codox/beowulf.reader.parser.html b/docs/codox/beowulf.reader.parser.html index 7499c5e..128d2ee 100644 --- a/docs/codox/beowulf.reader.parser.html +++ b/docs/codox/beowulf.reader.parser.html @@ -1,3 +1,5 @@ -beowulf.reader.parser documentation

    Project

    Topics

    Namespaces

    Public Vars

    beowulf.reader.parser

    The actual parser, supporting both S-expression and M-expression syntax.

    parse

    Parse a string presented as argument into a parse tree which can then be operated upon further.

    view source
    \ No newline at end of file +beowulf.reader.parser documentation

    Project

    Topics

    Namespaces

    Public Vars

    beowulf.reader.parser

    The actual parser, supporting both S-expression and M-expression syntax.

    +

    parse

    Parse a string presented as argument into a parse tree which can then be operated upon further.

    +
    view source
    \ No newline at end of file diff --git a/docs/codox/beowulf.reader.simplify.html b/docs/codox/beowulf.reader.simplify.html index 52fa75b..f2176ef 100644 --- a/docs/codox/beowulf.reader.simplify.html +++ b/docs/codox/beowulf.reader.simplify.html @@ -1,4 +1,9 @@ -beowulf.reader.simplify documentation

    Project

    Topics

    Namespaces

    Public Vars

    beowulf.reader.simplify

    Simplify parse trees. Be aware that this is very tightly coupled with the parser.

    remove-nesting

    (remove-nesting tree context)

    TODO: write docs

    view source

    remove-optional-space

    (remove-optional-space tree)

    TODO: write docs

    view source

    simplify

    (simplify p)

    Simplify this parse tree p. If p is an instaparse failure object, throw an ex-info, with p as the value of its :failure key. Calls remove-optional-space before processing.

    view source

    simplify-tree

    (simplify-tree p)(simplify-tree p context)

    Simplify this parse tree p. If p is an instaparse failure object, throw an ex-info, with p as the value of its :failure key.

    -

    NOTE THAT it is assumed that remove-optional-space has been run on the parse tree BEFORE it is passed to simplify-tree.

    view source
    \ No newline at end of file +beowulf.reader.simplify documentation

    Project

    Topics

    Namespaces

    Public Vars

    beowulf.reader.simplify

    Simplify parse trees. Be aware that this is very tightly coupled with the parser.

    +

    remove-nesting

    (remove-nesting tree context)

    TODO: write docs

    +
    view source

    remove-optional-space

    (remove-optional-space tree)

    TODO: write docs

    +
    view source

    simplify

    (simplify p)

    Simplify this parse tree p. If p is an instaparse failure object, throw an ex-info, with p as the value of its :failure key. Calls remove-optional-space before processing.

    +
    view source

    simplify-tree

    (simplify-tree p)(simplify-tree p context)

    Simplify this parse tree p. If p is an instaparse failure object, throw an ex-info, with p as the value of its :failure key.

    +

    NOTE THAT it is assumed that remove-optional-space has been run on the parse tree BEFORE it is passed to simplify-tree.

    +
    view source
    \ No newline at end of file diff --git a/docs/codox/beowulf.scratch.html b/docs/codox/beowulf.scratch.html index bdd1149..3209599 100644 --- a/docs/codox/beowulf.scratch.html +++ b/docs/codox/beowulf.scratch.html @@ -1,3 +1,8 @@ -beowulf.scratch documentation

    Project

    Topics

    Namespaces

    Public Vars

    beowulf.scratch

    This namespace is for temporary functions and is intentionally excluded from Git.

    accessor-body

    (accessor-body l v)

    TODO: write docs

    view source

    accessor-symbol

    (accessor-symbol l)

    Generate a symbol by prepending C and appending A to this list of string fragments l.

    view source

    accessors-generator

    (accessors-generator n)

    TODO: write docs

    view source

    manual-index

    TODO: write docs

    view source

    mogrify-plist

    (mogrify-plist entry fns)

    TODO: write docs

    view source
    \ No newline at end of file +beowulf.scratch documentation

    Project

    Topics

    Namespaces

    Public Vars

    beowulf.scratch

    This namespace is for temporary functions and is intentionally excluded from Git.

    +

    fns

    TODO: write docs

    +
    view source

    interop-listify-q-name

    (interop-listify-q-name subr)

    We need to be able to print something we can link to the particular Clojure function subr in a form in which Lisp 1.5 is able to read it back in and relink it.

    +

    This assumes subr is either 1. a string in the format #'beowulf.io/SYSIN or beowulf.io/SYSIN; or 2. something which, when coerced to a string with str, will have such a format.

    +
    view source

    mogrify-plist

    (mogrify-plist entry fns)

    TODO: write docs

    +
    view source
    \ No newline at end of file diff --git a/resources/codox/themes/journeyman/css/default.css b/docs/codox/default.css similarity index 100% rename from resources/codox/themes/journeyman/css/default.css rename to docs/codox/default.css diff --git a/docs/codox/further_reading.html b/docs/codox/further_reading.html index 4ff9617..236e98a 100644 --- a/docs/codox/further_reading.html +++ b/docs/codox/further_reading.html @@ -1,17 +1,19 @@ -Further Reading

    Project

    Topics

    Namespaces

    Further Reading

    +Further Reading

    Project

    Topics

    Namespaces

    Further Reading

      -
    1. CODING for the MIT-IBM 704 COMPUTER, October 1957 This paper is not about Lisp. But it is about the particular individual computer on which Lisp was first implemented, and it is written in part by members of the Lisp team. I have found it useful in understanding the software environment in which, and the constraints under which, Lisp was written.
      2. -
    2. MIT AI Memo 1, John McCarthy, September 1958 This is, as far as I can find, the earliest specification document of the Lisp project.
      3. -
    3. Lisp 1 Programmer’s Manual, Phyllis Fox, March 1960
      4. -
    4. Lisp 1.5 Programmer’s Manual, Michael I. Levin, August 1962 This book is essential reading: it documents in some detail the first fully realised Lisp language system.
      5. -
    5. Early LISP History (1956 - 1959), Herbert Stoyan, August 1984
      6. -
    6. -

      The Roots of Lisp, Paul Graham, 2001

      7. -
    7. -

      The Revenge of the Nerds, Paul Graham, 2002 This is mainly about why to use Lisp as a language for modern commercial software, but has useful insights into where it comes from.

      -
      -

      So the short explanation of why this 1950s language is not obsolete is that it was not technology but math, and math doesn’t get stale.

      -
      8. -
    \ No newline at end of file +
  • CODING for the MIT-IBM 704 COMPUTER, October 1957 This paper is not about Lisp. But it is about the particular individual computer on which Lisp was first implemented, and it is written in part by members of the Lisp team. I have found it useful in understanding the software environment in which, and the constraints under which, Lisp was written.
    • +
  • MIT AI Memo 1, John McCarthy, September 1958 This is, as far as I can find, the earliest specification document of the Lisp project.
    • +
  • Lisp 1 Programmer’s Manual, Phyllis Fox, March 1960
    • +
  • Lisp 1.5 Programmer’s Manual, Michael I. Levin, August 1962 This book is essential reading: it documents in some detail the first fully realised Lisp language system.
    • +
  • Early LISP History (1956 - 1959), Herbert Stoyan, August 1984
    • +
  • +

    The Roots of Lisp, Paul Graham, 2001

    +
    • +
  • The Revenge of the Nerds, Paul Graham, 2002 This is mainly about why to use Lisp as a language for modern commercial software, but has useful insights into where it comes from. +
    +

    So the short explanation of why this 1950s language is not obsolete is that it was not technology but math, and math doesn’t get stale.

    +
    +
    • + +
    \ No newline at end of file diff --git a/resources/codox/themes/journeyman/css/highlight.css b/docs/codox/highlight.css similarity index 100% rename from resources/codox/themes/journeyman/css/highlight.css rename to docs/codox/highlight.css diff --git a/docs/codox/index.html b/docs/codox/index.html index 5d09c60..bd07442 100644 --- a/docs/codox/index.html +++ b/docs/codox/index.html @@ -1,3 +1,18 @@ -Beowulf 0.3.0

    Project

    Topics

    Namespaces

    Beowulf 0.3.0

    Released under the GPL-2.0-or-later

    LISP 1.5 is to all Lisp dialects as Beowulf is to English literature.

    Installation

    To install, add the following dependency to your project or build file:

    [beowulf "0.3.0"]

    Topics

    Namespaces

    beowulf.bootstrap

    Lisp as defined in Chapter 1 (pages 1-14) of the Lisp 1.5 Programmer's Manual; that is to say, a very simple Lisp language, which should, I believe, be sufficient in conjunction with the functions provided by beowulf.host, be sufficient to bootstrap the full Lisp 1.5 interpreter..

    Public variables and functions:

    beowulf.cons-cell

    The fundamental cons cell on which all Lisp structures are built. Lisp 1.5 lists do not necessarily have a sequence as their CDR, and must have both CAR and CDR mutable, so cannot be implemented on top of Clojure lists.

    Public variables and functions:

    beowulf.core

    Essentially, the -main function and the bootstrap read-eval-print loop.

    Public variables and functions:

    beowulf.gendoc

    Generate table of documentation of Lisp symbols and functions.

    Public variables and functions:

    beowulf.host

    provides Lisp 1.5 functions which can’t be (or can’t efficiently be) implemented in Lisp 1.5, which therefore need to be implemented in the host language, in this case Clojure.

    Public variables and functions:

    beowulf.interop

    TODO: write docs

    Public variables and functions:

    beowulf.io

    Non-standard extensions to Lisp 1.5 to read and write to the filesystem.

    Public variables and functions:

    beowulf.manual

    Experimental code for accessing the manual online.

    Public variables and functions:

    beowulf.oblist

    A namespace mainly devoted to the object list and other top level global variables.

    Public variables and functions:

    beowulf.read

    This provides the reader required for boostrapping. It’s not a bad reader - it provides feedback on errors found in the input - but it isn’t the real Lisp reader.

    Public variables and functions:

    beowulf.reader.char-reader

    Provide sensible line editing, auto completion, and history recall.

    Public variables and functions:

      beowulf.reader.generate

      Generating S-Expressions from parse trees.

      Public variables and functions:

      beowulf.reader.macros

      Can I implement reader macros? let’s see!

      Public variables and functions:

      beowulf.reader.parser

      The actual parser, supporting both S-expression and M-expression syntax.

      Public variables and functions:

      beowulf.reader.simplify

      Simplify parse trees. Be aware that this is very tightly coupled with the parser.

      Public variables and functions:

      \ No newline at end of file +Beowulf 0.3.1-SNAPSHOT

      Project

      Topics

      Namespaces

      Beowulf 0.3.1-SNAPSHOT

      Released under the GPL-2.0-or-later

      LISP 1.5 is to all Lisp dialects as Beowulf is to English literature.

      Installation

      To install, add the following dependency to your project or build file:

      [beowulf "0.3.1-SNAPSHOT"]

      Topics

      Namespaces

      beowulf.bootstrap

      Lisp as defined in Chapter 1 (pages 1-14) of the Lisp 1.5 Programmer's Manual; that is to say, a very simple Lisp language, which should, I believe, be sufficient in conjunction with the functions provided by beowulf.host, be sufficient to bootstrap the full Lisp 1.5 interpreter..

      +

      Public variables and functions:

      beowulf.cons-cell

      The fundamental cons cell on which all Lisp structures are built. Lisp 1.5 lists do not necessarily have a sequence as their CDR, and must have both CAR and CDR mutable, so cannot be implemented on top of Clojure lists.

      +

      Public variables and functions:

      beowulf.core

      Essentially, the -main function and the bootstrap read-eval-print loop.

      +

      Public variables and functions:

      beowulf.gendoc

      Generate table of documentation of Lisp symbols and functions.

      +

      Public variables and functions:

      beowulf.host

      provides Lisp 1.5 functions which can’t be (or can’t efficiently be) implemented in Lisp 1.5, which therefore need to be implemented in the host language, in this case Clojure.

      +

      Public variables and functions:

      beowulf.interop

      TODO: write docs

      +

      Public variables and functions:

      beowulf.io

      Non-standard extensions to Lisp 1.5 to read and write to the filesystem.

      +

      Public variables and functions:

      beowulf.manual

      Experimental code for accessing the manual online.

      +

      Public variables and functions:

      beowulf.oblist

      A namespace mainly devoted to the object list and other top level global variables.

      +

      Public variables and functions:

      beowulf.read

      This provides the reader required for boostrapping. It’s not a bad reader - it provides feedback on errors found in the input - but it isn’t the real Lisp reader.

      +

      Public variables and functions:

      beowulf.reader.char-reader

      Provide sensible line editing, auto completion, and history recall.

      +

      Public variables and functions:

      beowulf.reader.generate

      Generating S-Expressions from parse trees.

      +

      Public variables and functions:

      beowulf.reader.macros

      Can I implement reader macros? let’s see!

      +

      Public variables and functions:

      beowulf.reader.parser

      The actual parser, supporting both S-expression and M-expression syntax.

      +

      Public variables and functions:

      beowulf.reader.simplify

      Simplify parse trees. Be aware that this is very tightly coupled with the parser.

      +

      Public variables and functions:

      \ No newline at end of file diff --git a/docs/codox/intro.html b/docs/codox/intro.html index 0875f1d..35c0e33 100644 --- a/docs/codox/intro.html +++ b/docs/codox/intro.html @@ -1,66 +1,74 @@ -beowulf

      Project

      Topics

      Namespaces

      beowulf

      -

      Þý liste cræfte spræc

      +beowulf

      Project

      Topics

      Namespaces

      beowulf

      +

      Þý liste cræfte spræc

      LISP 1.5 is to all Lisp dialects as Beowulf is to English literature.

      Beowulf logo

      -

      Contents

      +

      Contents

      +

      Table of contents generated with markdown-toc

      +

      What this is

      A work-in-progress towards an implementation of Lisp 1.5 in Clojure. The objective is to build a complete and accurate implementation of Lisp 1.5 as described in the manual, with, in so far as is possible, exactly the same bahaviour - except as documented below.

      -

      BUT WHY?!!?!

      +

      BUT WHY?!!?!

      Because.

      Because Lisp is the only computer language worth learning, and if a thing is worth learning, it’s worth learning properly; which means going back to the beginning and trying to understand that.

      -

      Because there is, so far as I know, no working implementation of Lisp 1.5 for modern machines.

      Because I’m barking mad, and this is therapy.

      -

      Status

      +

      There are other barking mad people out there

      +

      Since I wrote Beowulf, I’ve become aware of other modern reimplementations of Lisp 1.5:

      +
        +
      1. Kenichi Sasagawa’s in C;
        2. +
      2. Ichigo Lisp, in JavaScript, which compiles to Web Assembly;
        3. +
      3. Geert Bosch’s implementation in ADA;
        4. +
      +

      There are probably others.

      +

      In addition, this appears to be a transcription of the original IBM 709 card deck for the Lisp 1.5 system. There’s an IBM 709 emulator here on which it might be possible to actually run this.

      +

      Status

      Working Lisp interpreter, but some key features not yet implemented.

      -

      Project Target

      +

      Project Target

      The project target is to be able to run the Wang algorithm for the propositional calculus given in chapter 8 of the Lisp 1.5 Programmer’s Manual. When that runs, the project is as far as I am concerned feature complete. I may keep tinkering with it after that and I’ll certainly accept pull requests which are in the spirit of the project (i.e. making Beowulf more usable, and/or implementing parts of Lisp 1.5 which I have not implemented), but this isn’t intended to be a new language for doing real work; it’s an educational and archaeological project, not serious engineering.

      Some readline-like functionality would be really useful, but my attempt to integrate JLine has not (yet) been successful.

      An in-core structure editor would be an extremely nice thing, and I may well implement one.

      You are of course welcome to fork the project and do whatever you like with it!

      -

      Invoking

      +

      Invoking

      Invoke with

      -
      java -jar target/uberjar/beowulf-0.3.0-standalone.jar --help
+
      java -jar target/uberjar/beowulf-0.3.1-standalone.jar --help
 
      
 
      (Obviously, check your version number)
      
 
      Command line arguments as follows:
      
@@ -72,764 +80,171 @@
                                            without extensions.

      To end a session, type STOP at the command prompt.

      -

      Building and Invoking

      +

      Building and Invoking

      Build with

      lein uberjar
      -

      Reader macros

      +

      Reader macros

      Currently SETQ and DEFUN are implemented as reader macros, sort of. It would now be possible to reimplement them as FEXPRs and so the reader macro functionality will probably go away.

      -

      Functions and symbols implemented

      +

      Functions and symbols implemented

      - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      Function Type Signature Implementation Documentation
      NIL Lisp variable ? see manual pages 22, 69
      T Lisp variable ? see manual pages 22, 69
      F Lisp variable ? see manual pages 22, 69
      ADD1 Host lambda function ? ?
      AND Host lambda function ? PREDICATE T if and only if none of my args evaluate to either F or NIL, else F. In beowulf.host principally because I don’t yet feel confident to define varargs functions in Lisp.
      APPEND Lisp lambda function ? see manual pages 11, 61
      APPLY Host lambda function ? Apply this function to these arguments in this environment and return the result. For bootstrapping, at least, a version of APPLY written in Clojure. All args are assumed to be symbols or beowulf.cons-cell/ConsCell objects. See page 13 of the Lisp 1.5 Programmers Manual.
      ASSOC Lisp lambda function, Host lambda function ? ? If a is an association list such as the one formed by PAIRLIS in the above example, then assoc will produce the first pair whose first term is x. Thus it is a table searching function. All args are assumed to be beowulf.cons-cell/ConsCell objects. See page 12 of the Lisp 1.5 Programmers Manual. NOTE THAT this function is overridden by an implementation in Lisp, but is currently still present for bootstrapping.
      ATOM Host lambda function ? PREDICATE Returns T if and only if the argument x is bound to an atom; else F. It is not clear to me from the documentation whether (ATOM 7) should return T or F. I’m going to assume T.
      CAR Host lambda function ? Return the item indicated by the first pointer of a pair. NIL is treated specially: the CAR of NIL is NIL.
      CAAAAR Lisp lambda function ? ? ?
      CAAADR Lisp lambda function ? ? ?
      CAAAR Lisp lambda function ? ? ?
      CAADAR Lisp lambda function ? ? ?
      CAADDR Lisp lambda function ? ? ?
      CAADR Lisp lambda function ? ? ?
      CAAR Lisp lambda function ? ? ?
      CADAAR Lisp lambda function ? ? ?
      CADADR Lisp lambda function ? ? ?
      CADAR Lisp lambda function ? ? ?
      CADDAR Lisp lambda function ? ? ?
      CADDDR Lisp lambda function ? ? ?
      CADDR Lisp lambda function ? ? ?
      CADR Lisp lambda function ? ? ?
      CDAAAR Lisp lambda function ? ? ?
      CDAADR Lisp lambda function ? ? ?
      CDAAR Lisp lambda function ? ? ?
      CDADAR Lisp lambda function ? ? ?
      CDADDR Lisp lambda function ? ? ?
      CDADR Lisp lambda function ? ? ?
      CDAR Lisp lambda function ? ? ?
      CDDAAR Lisp lambda function ? ? ?
      CDDADR Lisp lambda function ? ? ?
      CDDAR Lisp lambda function ? ? ?
      CDDDAR Lisp lambda function ? ? ?
      CDDDDR Lisp lambda function ? ? ?
      CDDDR Lisp lambda function ? ? ?
      CDDR Lisp lambda function ? ? ?
      CDR Host lambda function ? Return the item indicated by the second pointer of a pair. NIL is treated specially: the CDR of NIL is NIL.
      CONS Host lambda function ? Construct a new instance of cons cell with this car and cdr.
      CONSP Host lambda function ? ? Return T if object o is a cons cell, else F. NOTE THAT this is an extension function, not available in strct mode. I believe that Lisp 1.5 did not have any mechanism for testing whether an argument was, or was not, a cons cell.
      COPY Lisp lambda function ? see manual pages 62
      DEFINE Host lambda function ? PSEUDO-FUNCTION Bootstrap-only version of DEFINE which, post boostrap, can be overwritten in LISP. The single argument to DEFINE should be an association list of symbols to lambda functions. See page 58 of the manual.
      DIFFERENCE Host lambda function ? ?
      DIVIDE Lisp lambda function ? see manual pages 26, 64
      DOC Host lambda function ? ? Open the page for this symbol in the Lisp 1.5 manual, if known, in the default web browser. NOTE THAT this is an extension function, not available in strct mode.
      EFFACE Lisp lambda function ? PSEUDO-FUNCTION see manual pages 63
      ERROR Host lambda function ? PSEUDO-FUNCTION Throw an error
      EQ Host lambda function ? PREDICATE Returns T if and only if both x and y are bound to the same atom, else NIL.
      EQUAL Host lambda function ? PREDICATE This is a predicate that is true if its two arguments are identical S-expressions, and false if they are different. (The elementary predicate EQ is defined only for atomic arguments.) The definition of EQUAL is an example of a conditional expression inside a conditional expression. NOTE: returns F on failure, not NIL
      EVAL Host lambda function ? Evaluate this expr and return the result. If environment is not passed, it defaults to the current value of the global object list. The depth argument is part of the tracing system and should not be set by user code. All args are assumed to be numbers, symbols or beowulf.cons-cell/ConsCell objects. However, if called with just a single arg, expr, I’ll assume it’s being called from the Clojure REPL and will coerce the expr to ConsCell.
      FACTORIAL Lisp lambda function ? ? ?
      FIXP Host lambda function ? PREDICATE ?
      GENSYM Host lambda function ? Generate a unique symbol.
      GET Host lambda function ? From the manual: ‘get is somewhat like prop; however its value is car of the rest of the list if the indicator is found, and NIL otherwise.’ It’s clear that GET is expected to be defined in terms of PROP, but we can’t implement PROP here because we lack EVAL; and we can’t have EVAL here because both it and APPLY depends on GET. OK, It’s worse than that: the statement of the definition of GET (and of) PROP on page 59 says that the first argument to each must be a list; But the in the definition of ASSOC on page 70, when GET is called its first argument is always an atom. Since it’s ASSOC and EVAL which I need to make work, I’m going to assume that page 59 is wrong.
      GREATERP Host lambda function ? PREDICATE ?
      INTEROP Host lambda function ? ? ?
      INTERSECTION Lisp lambda function ? ? ?
      LENGTH Lisp lambda function ? see manual pages 62
      LESSP Host lambda function ? PREDICATE ?
      MAPLIST Lisp lambda function ? FUNCTIONAL see manual pages 20, 21, 63
      MEMBER Lisp lambda function ? PREDICATE see manual pages 11, 62
      MINUSP Lisp lambda function ? PREDICATE see manual pages 26, 64
      NOT Lisp lambda function ? PREDICATE see manual pages 21, 23, 58
      NULL Lisp lambda function ? PREDICATE see manual pages 11, 57
      NUMBERP Host lambda function ? PREDICATE ?
      OBLIST Host lambda function ? Return a list of the symbols currently bound on the object list. NOTE THAT in the Lisp 1.5 manual, footnote at the bottom of page 69, it implies that an argument can be passed but I’m not sure of the semantics of this.
      ONEP Lisp lambda function ? PREDICATE see manual pages 26, 64
      OR Host lambda function ? PREDICATE T if and only if at least one of my args evaluates to something other than either F or NIL, else F. In beowulf.host principally because I don’t yet feel confident to define varargs functions in Lisp.
      PAIR Lisp lambda function ? see manual pages 60
      PAIRLIS Lisp lambda function, Host lambda function ? ? This function gives the list of pairs of corresponding elements of the lists x and y, and APPENDs this to the list a. The resultant list of pairs, which is like a table with two columns, is called an association list. Eessentially, it builds the environment on the stack, implementing shallow binding. All args are assumed to be beowulf.cons-cell/ConsCell objects. See page 12 of the Lisp 1.5 Programmers Manual. NOTE THAT this function is overridden by an implementation in Lisp, but is currently still present for bootstrapping.
      PLUS Host lambda function ? ?
      PRETTY ? ? ?
      PRINT ? PSEUDO-FUNCTION see manual pages 65, 84
      PROG Host nlambda function ? The accursed PROG feature. See page 71 of the manual. Lisp 1.5 introduced PROG, and most Lisps have been stuck with it ever since. It introduces imperative programming into what should be a pure functional language, and consequently it’s going to be a pig to implement. Broadly, PROG is a variadic pseudo function called as a FEXPR (or possibly an FSUBR, although I’m not presently sure that would even work.) The arguments, which are unevaluated, are a list of forms, the first of which is expected to be a list of symbols which will be treated as names of variables within the program, and the rest of which (the ‘program body’) are either lists or symbols. Lists are treated as Lisp expressions which may be evaulated in turn. Symbols are treated as targets for the GO statement. GO: A GO statement takes the form of (GO target), where target should be one of the symbols which occur at top level among that particular invocation of PROGs arguments. A GO statement may occur at top level in a PROG, or in a clause of a COND statement in a PROG, but not in a function called from the PROG statement. When a GO statement is evaluated, execution should transfer immediately to the expression which is the argument list immediately following the symbol which is its target. If the target is not found, an error with the code A6 should be thrown. RETURN: A RETURN statement takes the form (RETURN value), where value is any value. Following the evaluation of a RETURN statement, the PROG should immediately exit without executing any further expressions, returning the value. SET and SETQ: In addition to the above, if a SET or SETQ expression is encountered in any expression within the PROG body, it should affect not the global object list but instead only the local variables of the program. COND: In strict mode, when in normal execution, a COND statement none of whose clauses match should not return NIL but should throw an error with the code A3… except that inside a PROG body, it should not do so. sigh. Flow of control: Apart from the exceptions specified above, expressions in the program body are evaluated sequentially. If execution reaches the end of the program body, NIL is returned. Got all that? Good.
      PROP Lisp lambda function ? FUNCTIONAL see manual pages 59
      QUOTE Lisp lambda function ? see manual pages 10, 22, 71
      QUOTIENT Host lambda function ? I’m not certain from the documentation whether Lisp 1.5 QUOTIENT returned the integer part of the quotient, or a realnum representing the whole quotient. I am for now implementing the latter.
      RANGE Lisp lambda function ? ? ?
      READ Host lambda function ? PSEUDO-FUNCTION An implementation of a Lisp reader sufficient for bootstrapping; not necessarily the final Lisp reader. input should be either a string representation of a LISP expression, or else an input stream. A single form will be read.
      REMAINDER Host lambda function ? ?
      REPEAT Lisp lambda function ? ? ?
      RPLACA Host lambda function ? PSEUDO-FUNCTION Replace the CAR pointer of this cell with this value. Dangerous, should really not exist, but does in Lisp 1.5 (and was important for some performance hacks in early Lisps)
      RPLACD Host lambda function ? PSEUDO-FUNCTION Replace the CDR pointer of this cell with this value. Dangerous, should really not exist, but does in Lisp 1.5 (and was important for some performance hacks in early Lisps)
      SEARCH Lisp lambda function ? FUNCTIONAL see manual pages 63
      SET Host lambda function ? PSEUDO-FUNCTION Implementation of SET in Clojure. Add to the oblist a binding of the value of var to the value of val. NOTE WELL: this is not SETQ!
      SUB1 Lisp lambda function, Host lambda function ? ?
      SUB2 Lisp lambda function ? ? ?
      SUBLIS Lisp lambda function ? see manual pages 12, 61
      SUBST Lisp lambda function ? see manual pages 11, 61
      SYSIN Host lambda function ? ? Read the contents of the file at this filename into the object list. If the file is not a valid Beowulf sysout file, this will probably corrupt the system, you have been warned. File paths will be considered relative to the filepath set when starting Lisp. It is intended that sysout files can be read both from resources within the jar file, and from the file system. If a named file exists in both the file system and the resources, the file system will be preferred. NOTE THAT if the provided filename does not end with .lsp (which, if you’re writing it from the Lisp REPL, it won’t), the extension .lsp will be appended. NOTE THAT this is an extension function, not available in strct mode.
      SYSOUT Host lambda function ? ? Dump the current content of the object list to file. If no filepath is specified, a file name will be constructed of the symbol Sysout and the current date. File paths will be considered relative to the filepath set when starting Lisp. NOTE THAT this is an extension function, not available in strct mode.
      TERPRI ? PSEUDO-FUNCTION see manual pages 65, 84
      TIMES Host lambda function ? ?
      TRACE Host lambda function ? PSEUDO-FUNCTION Add this s to the set of symbols currently being traced. If s is not a symbol or sequence of symbols, does nothing.
      UNION Lisp lambda function ? ? ?
      UNTRACE Host lambda function ? PSEUDO-FUNCTION Remove this s from the set of symbols currently being traced. If s is not a symbol or sequence of symbols, does nothing.
      ZEROP Lisp lambda function ? PREDICATE see manual pages 26, 64
      Function Type Signature Implementation Documentation
      NIL Lisp variable ? see manual pages 22, 69
      T Lisp variable ? see manual pages 22, 69
      F Lisp variable ? see manual pages 22, 69
      ADD1 Host lambda function ? ?
      AND Host lambda function ? PREDICATE T if and only if none of my args evaluate to either F or NIL, else F. In beowulf.host principally because I don’t yet feel confident to define varargs functions in Lisp.
      APPEND Lisp lambda function ? see manual pages 11, 61
      APPLY Host lambda function ? Apply this function to these arguments in this environment and return the result. For bootstrapping, at least, a version of APPLY written in Clojure. All args are assumed to be symbols or beowulf.cons-cell/ConsCell objects. See page 13 of the Lisp 1.5 Programmers Manual.
      ASSOC Lisp lambda function, Host lambda function ? ? If a is an association list such as the one formed by PAIRLIS in the above example, then assoc will produce the first pair whose first term is x. Thus it is a table searching function. All args are assumed to be beowulf.cons-cell/ConsCell objects. See page 12 of the Lisp 1.5 Programmers Manual. NOTE THAT this function is overridden by an implementation in Lisp, but is currently still present for bootstrapping.
      ATOM Host lambda function ? PREDICATE Returns T if and only if the argument x is bound to an atom; else F. It is not clear to me from the documentation whether (ATOM 7) should return T or F. I’m going to assume T.
      CAR Host lambda function ? Return the item indicated by the first pointer of a pair. NIL is treated specially: the CAR of NIL is NIL.
      CAAAAR Lisp lambda function ? ? ?
      CAAADR Lisp lambda function ? ? ?
      CAAAR Lisp lambda function ? ? ?
      CAADAR Lisp lambda function ? ? ?
      CAADDR Lisp lambda function ? ? ?
      CAADR Lisp lambda function ? ? ?
      CAAR Lisp lambda function ? ? ?
      CADAAR Lisp lambda function ? ? ?
      CADADR Lisp lambda function ? ? ?
      CADAR Lisp lambda function ? ? ?
      CADDAR Lisp lambda function ? ? ?
      CADDDR Lisp lambda function ? ? ?
      CADDR Lisp lambda function ? ? ?
      CADR Lisp lambda function ? ? ?
      CDAAAR Lisp lambda function ? ? ?
      CDAADR Lisp lambda function ? ? ?
      CDAAR Lisp lambda function ? ? ?
      CDADAR Lisp lambda function ? ? ?
      CDADDR Lisp lambda function ? ? ?
      CDADR Lisp lambda function ? ? ?
      CDAR Lisp lambda function ? ? ?
      CDDAAR Lisp lambda function ? ? ?
      CDDADR Lisp lambda function ? ? ?
      CDDAR Lisp lambda function ? ? ?
      CDDDAR Lisp lambda function ? ? ?
      CDDDDR Lisp lambda function ? ? ?
      CDDDR Lisp lambda function ? ? ?
      CDDR Lisp lambda function ? ? ?
      CDR Host lambda function ? Return the item indicated by the second pointer of a pair. NIL is treated specially: the CDR of NIL is NIL.
      CONS Host lambda function ? Construct a new instance of cons cell with this car and cdr.
      CONSP Host lambda function ? ? Return T if object o is a cons cell, else F. NOTE THAT this is an extension function, not available in strct mode. I believe that Lisp 1.5 did not have any mechanism for testing whether an argument was, or was not, a cons cell.
      COPY Lisp lambda function ? see manual pages 62
      DEFINE Host lambda function ? PSEUDO-FUNCTION Bootstrap-only version of DEFINE which, post boostrap, can be overwritten in LISP. The single argument to DEFINE should be an association list of symbols to lambda functions. See page 58 of the manual.
      DIFFERENCE Host lambda function ? ?
      DIVIDE Lisp lambda function ? see manual pages 26, 64
      DOC Host lambda function ? ? Open the page for this symbol in the Lisp 1.5 manual, if known, in the default web browser. NOTE THAT this is an extension function, not available in strct mode.
      EFFACE Lisp lambda function ? PSEUDO-FUNCTION see manual pages 63
      ERROR Host lambda function ? PSEUDO-FUNCTION Throw an error
      EQ Host lambda function ? PREDICATE Returns T if and only if both x and y are bound to the same atom, else NIL.
      EQUAL Host lambda function ? PREDICATE This is a predicate that is true if its two arguments are identical S-expressions, and false if they are different. (The elementary predicate EQ is defined only for atomic arguments.) The definition of EQUAL is an example of a conditional expression inside a conditional expression. NOTE: returns F on failure, not NIL
      EVAL Host lambda function ? Evaluate this expr and return the result. If environment is not passed, it defaults to the current value of the global object list. The depth argument is part of the tracing system and should not be set by user code. All args are assumed to be numbers, symbols or beowulf.cons-cell/ConsCell objects. However, if called with just a single arg, expr, I’ll assume it’s being called from the Clojure REPL and will coerce the expr to ConsCell.
      FACTORIAL Lisp lambda function ? ? ?
      FIXP Host lambda function ? PREDICATE ?
      GENSYM Host lambda function ? Generate a unique symbol.
      GET Host lambda function ? From the manual: ‘get is somewhat like prop; however its value is car of the rest of the list if the indicator is found, and NIL otherwise.’ It’s clear that GET is expected to be defined in terms of PROP, but we can’t implement PROP here because we lack EVAL; and we can’t have EVAL here because both it and APPLY depends on GET. OK, It’s worse than that: the statement of the definition of GET (and of) PROP on page 59 says that the first argument to each must be a list; But the in the definition of ASSOC on page 70, when GET is called its first argument is always an atom. Since it’s ASSOC and EVAL which I need to make work, I’m going to assume that page 59 is wrong.
      GREATERP Host lambda function ? PREDICATE ?
      INTEROP Host lambda function ? ? ?
      INTERSECTION Lisp lambda function ? ? ?
      LENGTH Lisp lambda function ? see manual pages 62
      LESSP Host lambda function ? PREDICATE ?
      MAPLIST Lisp lambda function ? FUNCTIONAL see manual pages 20, 21, 63
      MEMBER Lisp lambda function ? PREDICATE see manual pages 11, 62
      MINUSP Lisp lambda function ? PREDICATE see manual pages 26, 64
      NOT Lisp lambda function ? PREDICATE see manual pages 21, 23, 58
      NULL Lisp lambda function ? PREDICATE see manual pages 11, 57
      NUMBERP Host lambda function ? PREDICATE ?
      OBLIST Host lambda function ? Return a list of the symbols currently bound on the object list. NOTE THAT in the Lisp 1.5 manual, footnote at the bottom of page 69, it implies that an argument can be passed but I’m not sure of the semantics of this.
      ONEP Lisp lambda function ? PREDICATE see manual pages 26, 64
      OR Host lambda function ? PREDICATE T if and only if at least one of my args evaluates to something other than either F or NIL, else F. In beowulf.host principally because I don’t yet feel confident to define varargs functions in Lisp.
      PAIR Lisp lambda function ? see manual pages 60
      PAIRLIS Lisp lambda function, Host lambda function ? ? This function gives the list of pairs of corresponding elements of the lists x and y, and APPENDs this to the list a. The resultant list of pairs, which is like a table with two columns, is called an association list. Eessentially, it builds the environment on the stack, implementing shallow binding. All args are assumed to be beowulf.cons-cell/ConsCell objects. See page 12 of the Lisp 1.5 Programmers Manual. NOTE THAT this function is overridden by an implementation in Lisp, but is currently still present for bootstrapping.
      PLUS Host lambda function ? ?
      PRETTY ? ? ?
      PRINT ? PSEUDO-FUNCTION see manual pages 65, 84
      PROG Host nlambda function ? The accursed PROG feature. See page 71 of the manual. Lisp 1.5 introduced PROG, and most Lisps have been stuck with it ever since. It introduces imperative programming into what should be a pure functional language, and consequently it’s going to be a pig to implement. Broadly, PROG is a variadic pseudo function called as a FEXPR (or possibly an FSUBR, although I’m not presently sure that would even work.) The arguments, which are unevaluated, are a list of forms, the first of which is expected to be a list of symbols which will be treated as names of variables within the program, and the rest of which (the ‘program body’) are either lists or symbols. Lists are treated as Lisp expressions which may be evaulated in turn. Symbols are treated as targets for the GO statement. GO: A GO statement takes the form of (GO target), where target should be one of the symbols which occur at top level among that particular invocation of PROGs arguments. A GO statement may occur at top level in a PROG, or in a clause of a COND statement in a PROG, but not in a function called from the PROG statement. When a GO statement is evaluated, execution should transfer immediately to the expression which is the argument list immediately following the symbol which is its target. If the target is not found, an error with the code A6 should be thrown. RETURN: A RETURN statement takes the form (RETURN value), where value is any value. Following the evaluation of a RETURN statement, the PROG should immediately exit without executing any further expressions, returning the value. SET and SETQ: In addition to the above, if a SET or SETQ expression is encountered in any expression within the PROG body, it should affect not the global object list but instead only the local variables of the program. COND: In strict mode, when in normal execution, a COND statement none of whose clauses match should not return NIL but should throw an error with the code A3… except that inside a PROG body, it should not do so. sigh. Flow of control: Apart from the exceptions specified above, expressions in the program body are evaluated sequentially. If execution reaches the end of the program body, NIL is returned. Got all that? Good.
      PROP Lisp lambda function ? FUNCTIONAL see manual pages 59
      QUOTE Lisp lambda function ? see manual pages 10, 22, 71
      QUOTIENT Host lambda function ? I’m not certain from the documentation whether Lisp 1.5 QUOTIENT returned the integer part of the quotient, or a realnum representing the whole quotient. I am for now implementing the latter.
      RANGE Lisp lambda function ? ? ?
      READ Host lambda function ? PSEUDO-FUNCTION An implementation of a Lisp reader sufficient for bootstrapping; not necessarily the final Lisp reader. input should be either a string representation of a LISP expression, or else an input stream. A single form will be read.
      REMAINDER Host lambda function ? ?
      REPEAT Lisp lambda function ? ? ?
      RPLACA Host lambda function ? PSEUDO-FUNCTION Replace the CAR pointer of this cell with this value. Dangerous, should really not exist, but does in Lisp 1.5 (and was important for some performance hacks in early Lisps)
      RPLACD Host lambda function ? PSEUDO-FUNCTION Replace the CDR pointer of this cell with this value. Dangerous, should really not exist, but does in Lisp 1.5 (and was important for some performance hacks in early Lisps)
      SEARCH Lisp lambda function ? FUNCTIONAL see manual pages 63
      SET Host lambda function ? PSEUDO-FUNCTION Implementation of SET in Clojure. Add to the oblist a binding of the value of var to the value of val. NOTE WELL: this is not SETQ!
      SUB1 Lisp lambda function, Host lambda function ? ?
      SUB2 Lisp lambda function ? ? ?
      SUBLIS Lisp lambda function ? see manual pages 12, 61
      SUBST Lisp lambda function ? see manual pages 11, 61
      SYSIN Host lambda function ? ? Read the contents of the file at this filename into the object list. If the file is not a valid Beowulf sysout file, this will probably corrupt the system, you have been warned. File paths will be considered relative to the filepath set when starting Lisp. It is intended that sysout files can be read both from resources within the jar file, and from the file system. If a named file exists in both the file system and the resources, the file system will be preferred. NOTE THAT if the provided filename does not end with .lsp (which, if you’re writing it from the Lisp REPL, it won’t), the extension .lsp will be appended. NOTE THAT this is an extension function, not available in strct mode.
      SYSOUT Host lambda function ? ? Dump the current content of the object list to file. If no filepath is specified, a file name will be constructed of the symbol Sysout and the current date. File paths will be considered relative to the filepath set when starting Lisp. NOTE THAT this is an extension function, not available in strct mode.
      TERPRI ? PSEUDO-FUNCTION see manual pages 65, 84
      TIMES Host lambda function ? ?
      TRACE Host lambda function ? PSEUDO-FUNCTION Add this s to the set of symbols currently being traced. If s is not a symbol or sequence of symbols, does nothing.
      UNION Lisp lambda function ? ? ?
      UNTRACE Host lambda function ? PSEUDO-FUNCTION Remove this s from the set of symbols currently being traced. If s is not a symbol or sequence of symbols, does nothing.
      ZEROP Lisp lambda function ? PREDICATE see manual pages 26, 64

      Functions described as ‘Lisp function’ above are defined in the default sysout file, resources/lisp1.5.lsp, which will be loaded by default unless you specify another initfile on the command line.

      Functions described as ‘Host function’ are implemented in Clojure, but if you’re brave you can redefine them in Lisp and the Lisp definitions will take precedence over the Clojure implementations.

      -

      Architectural plan

      +

      Architectural plan

      Not everything documented in this section is yet built. It indicates the direction of travel and intended destination, not the current state.

      -

      resources/lisp1.5.lsp

      +

      resources/lisp1.5.lsp

      The objective is to have within resources/lisp1.5.lsp, all those functions defined in the Lisp 1.5 Programmer’s Manual which can be implemented in Lisp.

      This means that, while Beowulf is hosted on Clojure, all that would be required to rehost Lisp 1.5 on a different platform would be to reimplement

        -
      • bootstrap.clj
        • -
      • host.clj
        • -
      • read.clj
        • +
      • bootstrap.clj
        • +
      • host.clj
        • +
      • read.clj

      The objective this is to make it fairly easy to implement Lisp 1.5 on top of any of the many Make A Lisp implementations.

      -

      beowulf/boostrap.clj

      +

      beowulf/boostrap.clj

      This file is essentially Lisp as defined in Chapter 1 (pages 1-14) of the Lisp 1.5 Programmer’s Manual; that is to say, a very simple Lisp language, which should, I believe, be sufficient in conjunction with the functions provided by beowulf.host, to bootstrap the full Lisp 1.5 interpreter.

      In addition it contains the function INTEROP, which allows host language functions to be called from Lisp.

      -

      beowulf/host.clj

      +

      beowulf/host.clj

      This file provides Lisp 1.5 functions which can’t be (or can’t efficiently be) implemented in Lisp 1.5, which therefore need to be implemented in the host language, in this case Clojure.

      -

      beowulf/read.clj

      +

      beowulf/read.clj

      This file provides the reader required for boostrapping. It’s not a bad reader - it provides feedback on errors found in the input - but it isn’t the real Lisp reader.

      Intended deviations from the behaviour of the real Lisp reader are as follows:

        -
      1. It reads the meta-expression language MEXPR in addition to the symbolic expression language SEXPR, which I do not believe the Lisp 1.5 reader ever did;
        2. -
      2. It treats everything between a double semi-colon and an end of line as a comment, as most modern Lisps do; but I do not believe Lisp 1.5 had this feature.
        3. +
      3. It reads the meta-expression language MEXPR in addition to the symbolic expression language SEXPR, which I do not believe the Lisp 1.5 reader ever did;
        4. +
      4. It treats everything between a double semi-colon and an end of line as a comment, as most modern Lisps do; but I do not believe Lisp 1.5 had this feature.
      -

      Commentary

      -

      What’s surprised me in working on this is how much more polished Lisp 1.5 is than legend had led me to believe. The language is remarkably close to Portable Standard Lisp which is in my opinion one of the best and most usable early Lisp implementations.

      +

      Commentary

      +

      What’s surprised me in working on this is how much more polished Lisp 1.5 is than legend had led me to believe. The language is remarkably close to Portable Standard Lisp which is in my opinion one of the best and most usable early Lisp implementations.

      What’s even more surprising is how faithful a reimplementation of Lisp 1.5 the first Lisp dialect I learned, Acornsoft Lisp, turns out to have been.

      I’m convinced you could still use Lisp 1.5 for interesting and useful software (which isn’t to say that modern Lisps aren’t better, but this is software which is almost sixty years old).

      -

      Installation

      +

      Installation

      Download the latest release ‘uberjar’ and run it using:

      -
          java -jar <path name of uberjar>
+
          java -jar <path name of uberjar>
 
      
 
      Or clone the source and build it using:
      
-
          lein uberjar`
+
          lein uberjar`
 
      
 
      To build it you will require to have Leiningen installed.
      
-
      Input/output
      
+
      Input/output
      
 
      Lisp 1.5 greatly predates modern computers. It had a facility to print to a line printer, or to punch cards on a punch-card machine, and it had a facility to read system images in from tape; but there’s no file I/O as we would currently understand it, and, because there are no character strings and the valid characters within an atom are limited, it isn’t easy to compose a sensible filename.
      
 
      I’ve provided two functions to work around this problem.
      
-
      SYSOUT
      
+
      SYSOUT
      
 
      SYSOUT dumps the global object list to disk as a single S Expression (specifically: an association list). This allows you to persist your session, with all your current work, to disk. The function takes one argument, expected to be a symbol, and, if that argument is provided, writes a file whose name is that symbol with .lsp appended. If no argument is provided, it will construct a filename comprising the token Sysout, followed by the current date, followed by .lsp. In either case the file will be written to the directory given in the FILEPATH argument at startup time, or by default the current directory.
      
 
      Obviously, SYSOUT may be called interactively (and this is the expected practice).
      
-
      SYSIN
      
-
      SYSIN reads a file from disk and overwrites the global object list with its contents. The expected practice is that this will be a file created by SYSOUT. A command line flag --read is provided so that you can specify 
      
-
      Learning Lisp 1.5
      
+
      SYSIN
      
+
      SYSIN reads a file from disk and overwrites the global object list with its contents. The expected practice is that this will be a file created by SYSOUT. A command line flag --read is provided so that you can specify
      
+
      Learning Lisp 1.5
      
 
      The Lisp 1.5 Programmer's Manual is still in print, ISBN 13 978-0-262-13011-0; but it’s also available online.
      
-
      Other Lisp 1.5 resources
      
+
      Other Lisp 1.5 resources
      
 
      The main resource I’m aware of is the Software Preservation Society’s site, here. It has lots of fascinating stuff including full assembler listings for various obsolete processors, but I failed to find the Lisp source of Lisp functions as a text file, which is why resources/lisp1.5.lsp is largely copytyped and reconstructed from the manual.
      
-
      Other implementations
      
+
      Other implementations
      
 
      There’s an online (browser native) Lisp 1.5 implementation here (source code here). It even has a working compiler!
      
-
      History resources
      
-
      I’m compiling a list of links to historical documents on Lisp 1.5.
      
-
      License
      
-
      Copyright © 2019 Simon Brooke. Licensed under the GNU General Public License, version 2.0 or (at your option) any later version.
      \ No newline at end of file +

      History resources

      +

      I’m compiling a list of links to historical documents on Lisp 1.5.

      +

      License

      +

      Copyright © 2019 Simon Brooke. Licensed under the GNU General Public License, version 2.0 or (at your option) any later version.

      +
      \ No newline at end of file diff --git a/docs/codox/mexpr.html b/docs/codox/mexpr.html index 7692fe9..376a85c 100644 --- a/docs/codox/mexpr.html +++ b/docs/codox/mexpr.html @@ -1,16 +1,16 @@ -Interpreting M-Expressions

      Project

      Topics

      Namespaces

      Interpreting M-Expressions

      +Interpreting M-Expressions

      Project

      Topics

      Namespaces

      Interpreting M-Expressions

      M-Expressions (‘mexprs’) are the grammar which John McCarthy origininally used to write Lisp, and the grammar in which many of the function definitions in the Lisp 1.5 Programmer’s Manual are stated. However, I have not seen anywhere a claim that Lisp 1.5 could read M-Expressions, and it is not clear to me whether it was even planned that it should do so, although the discussion on page 10 suggests that it was.

      Rather, it seems to me possible that M-Expressions were only ever a grammar intended to be written on paper, like Backus Naur Form, to describe and to reason about algorithms. I think at the point at which the M-Expression grammar was written, the idea of the universal Lisp function

      I set out to make Beowulf read M-Expressions essentially out of curiousity, to see whether it could be done. I had this idea that if it could be done, I could implement most of Lisp 1.5 simply by copying in the M-Expression definitions out of the manual.

      Consequently, the Beowulf parser can parse the M-Expression grammar as stated in the manual, and generate S-Expressions from it according to the table specified on page 10 of the manual.

      There are two problems with this.

      -

      Problems with interpreting M-Expressions

      -

      Generating idiomatic Lisp

      +

      Problems with interpreting M-Expressions

      +

      Generating idiomatic Lisp

      In the M-Expression notation, a lower case character or sequence of characters represents a variable; an upper case character represents a constant. As the manual says,

      -

      2 . The obvious translation of letting a constant translate into itself will not work. Since the translation of x is X, the translation of X must be something else to avoid ambiguity. The solution is to quote it. Thus X is translated into (QUOTE X).

      +

      2 . The obvious translation of letting a constant translate into itself will not work. Since the translation of x is X, the translation of X must be something else to avoid ambiguity. The solution is to quote it. Thus X is translated into (QUOTE X).

      Thus, necessarily, the translation of a constant must always be quoted. In practice, key constants in Lisp such as T are bound to themselves, so it is idiomatic in Lisp, certainly in the way we have learned to use it, to write, for example,

      (SET (QUOTE NULL) 
@@ -32,11 +32,12 @@
 
      Is the value of NIL the atom NIL, or is it the empty list ()? If the former, then the translation from the M-Expression above is correct. However, that means that recursive functions which recurse down a list seeking the end will fail. So the latter must be the case.
      
 
      NULL is described thus (Ibid, p11):
      
 
      
-  
      This is a predicate useful for deciding when a list is exhausted. It is true if and only if its argument is NIL.
      
+
      This is a predicate useful for deciding when a list is exhausted. It is true if and only if its argument is NIL.
      
 
      
 
      NIL is used explicitly in an M-Expression for example in the definition of intersection (Ibid, p15).
      
 
      I think there is an ambiguity in referencing constants which are not bound to themselves in the M-Expression notation as given in the manual. This is particularly problematic with regards to NIL and F, but there may be others instances.
      
 
      However, so long as F is bound to NIL, and NIL is also bound to NIL (both of which are true by default, although changeable by the user), and NIL is the special marker used in the CDR of the last cons cell of a flat list, this is a difference which in practice does not make a difference. I still find it worrying, though, that rebinding variables could lead to disaster.
      
-
      Curly braces
      
+
      Curly braces
      
 
      The use of curly braces is not defined in the grammar as stated on page 10. They are not used in the initial definition of APPLY on page 13, but they are used in the more developed restatement on page 70. I believe they are to be read as indicating a section of assembly code to be assembled by the Lisp Assembly Program – but I don’t find the exposition here particularly clear and I’m not sure of this.
      
-
      Consequently, the M-Expression interpreter in Beowulf does not interpret curly braces.
      \ No newline at end of file +

      Consequently, the M-Expression interpreter in Beowulf does not interpret curly braces.

      +
      \ No newline at end of file diff --git a/docs/codox/values.html b/docs/codox/values.html index 1bfdc12..70fc1ef 100644 --- a/docs/codox/values.html +++ b/docs/codox/values.html @@ -1,27 +1,29 @@ -The properties of the system, and their values

      Project

      Topics

      Namespaces

      The properties of the system, and their values

      -

      here be dragons

      +The properties of the system, and their values

      Project

      Topics

      Namespaces

      The properties of the system, and their values

      +

      here be dragons

      Lisp is the list processing language; that is what its name means. It processes data structures built of lists - which may be lists of lists, or lists of numbers, or lists of any other sort of data item provided for by the designers of the system.

      But how is a list, in a computer, actually implemented?

      They’re implemented as pairs, or, as the manual sometimes rather delightfully called them, ‘doublets’. Pairs of what? Pairs of pointers. Of the two pointers of a pair, the first points to the current entry of the list, and the second, by default, points to the remainder of the list, or, if the end of the list has been reached, to a special datum known as NIL which among other things indicates that the end of the list has been reached. The pair itself is normally referred to as a ‘cons cell’ for reasons which are nerdy and not important just now (all right, because they are constructed using a function called cons, which is in itself believed to be simply an abbreviation of ‘construct’).

      Two functions are used to access the two pointers of the cell. In modern Lisps these functions are called first and rest, because a lot of people who aren’t greybeards find these names easier. But they aren’t the original names. The original names were CAR and CDR.

      Why?

      -

      History

      -

      Lisp was originally written on an IBM 704 computer at Massachusetts Institute of Technology, almost seventy years ago.

      +

      History

      +

      Lisp was originally written on an IBM 704 computer at Massachusetts Institute of Technology, almost seventy years ago.

      The machine had registers which were not eight, or sixteen, or thirty two, or sixty four, bits wide, or any other number which would seem rational to modern computer scientists, but thirty six. Myth - folk memory - tells us that the machine’s memory was arranged in pages. As I understand it (but this truly is folk memory) the offset within the page of the word to be fetched was known as the ‘decrement’, while the serial number of the page in the addressing sequence was known as the ‘address’. To fetch a word from memory, you first had to select the page using the ‘address’, and secondly the word itself using the ‘decrement’. So there were specific instructions for selecting the address, and the decrement, from the register separately.

      There were two mnemonics for the machine instructions used to access the content of these registers, respectively:

      -
      CAR
      -
      -

      Contents of the Address part of Register; and

      -
      CDR
      -
      -

      Contents of the Decrement part of Register.

      +
      CAR
      +
      +

      Contents of the Address part of Register; and

      +
      +
      CDR
      +
      +

      Contents of the Decrement part of Register.

      +

      Is this actually true?

      I think so. If you look at page 80 of the Lisp 1 Programmer’s Manual, you will see this:

      -
      TEN                       (the TEN-Mode is entered)
+
      TEN                       (the TEN-Mode is entered)
 
 O CAR   (((A,B),C)) () \
                         |
@@ -38,23 +40,23 @@ O14 (read lines O and 1)
 
      
 
      Edited 3rd April to add: I’ve found a document, not related to Lisp (although John McCarthy is credited as one of the authors), which does confirm – or strictly, amend – the story. This is the CODING for the MIT-IBM 704 COMPUTER, dating from October 1957. The registers of the 704 were divided into four parts, named respectively the prefix part, the address part, the tag part, and the decrement part, of 3, 15, 3, and 15 bits respectively. The decrement part was not used in addressing; that part of the folklore I was taught isn’t right. But the names are correct. Consider this excerpt :
      
 
      
-  
      The address, tag and decrement parts of symbolic instructions are given in that order. In some cases the decrement, tag or address parts are not necessary; therefore the following combinations where OP represents the instruction abbreviation are permissible.
      
+
      The address, tag and decrement parts of symbolic instructions are given in that order. In some cases the decrement, tag or address parts are not necessary; therefore the following combinations where OP represents the instruction abbreviation are permissible.
      
 
      
 
      This doesn’t prove there were individual machine instructions with the mnemonics CAR and CDR; in fact, I’m going to say with some confidence that there were not, by reference to the table of instructions appended to the same document. The instructions do have three letter mnemonics, and they do use ‘A’ and ‘D’ as abbreviations for ‘address’ and ‘decrement’ respectively, but CAR and CDR are not included.
      
 
      So it seems probable that CAR and CDR were labels for subroutines, as I hypothesised above. But they were quite likely pre-existing subroutines, in use before the instantiation of the Lisp project, because they would be generally useful; and the suggestion that they are contractions of ‘contents of the address part’ and ‘contents of the decrement part’, respectively, seem confirmed.
      
-
      And, going further down the rabbit hole, there’s this. In 1957, before work on the Lisp project started, McCarthy was writing functions to add list processing to the then-new FORTRAN language, on the very same IBM 704 machine. 
      
+
      And, going further down the rabbit hole, there’s this. In 1957, before work on the Lisp project started, McCarthy was writing functions to add list processing to the then-new FORTRAN language, on the very same IBM 704 machine.
      
 
      
-  
      in this time any function that delivered integer values had to have a first letter X. Any function (as opposited to subroutines) had to have a last letter F in its name. Therefore the functions selecting parts of the IBM704 memory register (word) were introduced to be XCSRF, XCPRF, XCDRF, XCTRF and XCARF
      
+
      in this time any function that delivered integer values had to have a first letter X. Any function (as opposited to subroutines) had to have a last letter F in its name. Therefore the functions selecting parts of the IBM704 memory register (word) were introduced to be XCSRF, XCPRF, XCDRF, XCTRF and XCARF
      
 
      
 
      
 
      I think that the answer has to be that if CAR and CDR had been named by the early Lisp team – John McCarthy and his immediate colleagues – they would not have been named as they were. If not FRST and REST, as in more modern Lisps, then something like P1 and P2. CAR and CDR are distinctive and memorable (and therefore in my opinion worth preserving) because they very specifically name the parts of a cons cell and of nothing else.
      
 
      Let’s be clear, here: when CAR and CDR are used in Lisp, they are returning pointers, certainly – but not in the sense that one points to a page and the other to a word. Each is an offset into a cell array, which is almost certainly an array of single 36 bit words held on a single page. So both are in effect being used as decrements. Their use in Lisp is an overload onto their original semantic meaning; they are no longer being used for the purpose for which they are named.
      
 
      As far as I can tell, these names first appear in print in 1960, both in the Lisp 1 Programmer’s Manual referenced above, and in McCarthy’s paper Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I. The paper was published in April so was presumably written in 1959
      
-
      Grey Anatomy
      
-
      The Object List
      
+
      Grey Anatomy
      
+
      The Object List
      
 
      Lisp keeps track of values by associating them with names. It does so by having what is in effect a global registry of all the names it knows to which values are attached. This being a list processing language, that was of course, in early Lisps, a list: a single specialised first class list known as the ‘object list’, or oblist for short.
      
-
      Of course, a list need not just be a list of single items, it can be a list of pairs: it can be a list of pairs of the form (name . value). Hold onto that, because I want to talk about another fundamental part of a working Lisp system, the stack. 
      
-
      The Stack
      
+
      Of course, a list need not just be a list of single items, it can be a list of pairs: it can be a list of pairs of the form (name . value). Hold onto that, because I want to talk about another fundamental part of a working Lisp system, the stack.
      
+
      The Stack
      
 
      Considering the case of pure interpreter first, let’s think about how a function keeps track of the data it’s working on. In order to do its work, it probably calls other functions, to which it passes off data, and they in turn probably call further functions. So, when control returns to our first function, how does it know where its data is? The answer is that each function pushes its argument bindings onto the stack when it starts work, and pops them off again when it exits. So when control returns to a function, its own data is still on the top of the stack. Or, to be precise, actually it doesn’t; in practice the function EVAL does it for each function in turn. But it doesn’t matter: it gets done.
      
 
      What is this stack? Well, it’s a list of (name . value) pairs. At least, it is in pure Lisps; Clojure, because it runs on the Java Virtual Machine and interoperates with other software running on the JVM, uses the JVM stack which is a permanently reserved vector of memory never used for anything else. Consequently it cannot be very large; and the consequence of that is that it’s very easy to crash JVM programs because they’ve run out of stack space.
      
 
      The advantage of organising your stack as a vector is that on average it’s usually slightly more memory efficient, and that it’s somewhat faster to access. The disadvantage is you need a contiguous block of memory for it, and once you’ve run out, you’ve at best lost both those advantages but in the normal case your program just crashes. Also, the memory you’ve reserved for the stack isn’t available for any other use, even during the most of the time that the stack isn’t using most of it. So of course there’s a temptation to keep the amount reserved for the stack as small as possible.
      
@@ -62,7 +64,7 @@ O14 (read lines O and 1)
 
      The advantage of organising your stack as a list is that, while there is any memory left on the machine at all, you cannot run out of stack.
      
 
      ### The Spine
      
 
      So, there’s an object list where you associate names and values, and there’s a stack where you associate names and values. But, why do they have to be different? And why do you have to search in two places to find the value of a name?
      
-
      The answer is – or it was, and arguably it should be – that you don’t. The stack can simply be pushed onto the front of the object list. This has multiple advantages. The first and most obvious is that you only have to search in one place for the value associated with a name. 
      
+
      The answer is – or it was, and arguably it should be – that you don’t. The stack can simply be pushed onto the front of the object list. This has multiple advantages. The first and most obvious is that you only have to search in one place for the value associated with a name.
      
 
      The second is more subtle: a function can mask a variable in the object list by binding the same name to a new value, and the functions to which it then calls will only see that new value. This is useful if, for example, printed output is usually sent to the user’s terminal, but for a particular operation you want to send it to a line printer or to a file on disk. You simply rebind the name of the standard output stream to your chosen output stream, and call the function whose output you want to redirect.
      
 
      So, in summary, there’s a lot of merit in making the stack and the object list into a single central structure on which the architecture of our Lisp system is built. But there’s more we need to record, and it’s important.
      
 
      ### Fields and Properties
      
@@ -72,35 +74,35 @@ O14 (read lines O and 1)
 
      But if instead of storing a table for each sort of thing on which we hold data, and a row in that table for each item of that sort on which we store data, we simply tagged each thing on which we hold data with those things which are interesting about them? We could tag my friend Lucy with the fact she’s on pilgrimage, and what her pilgrimage route is. Those aren’t things we need to know about most people, it would be absurdly wasteful to add a column to a person table to record pilgrimage route. So in a conventional data system we would lose that data.
      
 
      Lisp has had, right back from the days of Lisp 1.5 – so, for sixty-five years – a different solution. We can give every symbol arbitrarily many, arbitrarily different, properties. A property is a (name . value) pair. We don’t have to store the same properties for every object. The values of the properties don’t have to have a fixed size, and they don’t have to take up space they don’t need. It’s like having a table with as many fields as we choose, and being able to add more fields at any time.
      
 
      So, in summary, I knew, in building Beowulf, that I’d have to implement property lists. I just didn’t know how I was going to do it.
      
-
      Archaeology
      
+
      Archaeology
      
 
      What I’m doing with Beowulf is trying to better understand the history of Lisp by reconstructing a very early example; in this case, Lisp 1.5, from about 1962, or sixty one years ago.
      
 
      I had had the naive assumption that entries on the object list in early Lisps had their CAR pointing to the symbol and their CDR pointing to the related value. Consequently, in building beowulf, I could not work out where the property list went. More careful reading of the text implies, but does not explicitly state, that my naive assumption is wrong.
      
 
      Instead, it appears that the CAR points to the symbol, as expected, but the CDR points to the property list; and that on the property list there are privileged properties at least as follows:
      
 
      
-  
      APVAL
      
-  
      the simple straightforward ordinary value of the symbol, considered as a variable;
      
-  
      EXPR
      
-  
      the definition of the function considered as a normal lambda expression (arguments to be evaluated before applying);
      
-  
      FEXPR
      
-  
      the definition of a function which should be applied to unevaluated arguments (what InterLisp and Portable Standard Lisp would call ‘nlambda’);
      
-  
      SUBR
      
-  
      the definition of a compiled subroutine which should be applied to evaluated arguments;
      
-  
      FSUBR
      
-  
      the definition of a compiled subroutine which should be applied to unevaluated arguments.
      
+
      APVAL
      
+
      the simple straightforward ordinary value of the symbol, considered as a variable;
      
+
      EXPR
      
+
      the definition of the function considered as a normal lambda expression (arguments to be evaluated before applying);
      
+
      FEXPR
      
+
      the definition of a function which should be applied to unevaluated arguments (what InterLisp and Portable Standard Lisp would call ‘nlambda’);
      
+
      SUBR
      
+
      the definition of a compiled subroutine which should be applied to evaluated arguments;
      
+
      FSUBR
      
+
      the definition of a compiled subroutine which should be applied to unevaluated arguments.
      
 
      
 
      I think there was also another privileged property value which contained the property considered as a constant, but I haven’t yet confirmed that.
      
 
      From this it would seem that Lisp 1.5 was not merely a ‘Lisp 2’ but in fact a ‘Lisp 6’, with six effectively first class namespaces. In fact it’s not as bad as that, because of the way EVAL is evaluated.
      
 
      Essentially the properties are tried in turn, and only the first value found is used. Thus the heirarchy is
      
 
        
-  
      1. APVAL
        2. 
-  
      2. EXPR
        3. 
-  
      3. FEXPR
        4. 
-  
      4. SUBR
        5. 
-  
      5. FSUBR
        6. 
+
      6. APVAL
        7. 
+
      7. EXPR
        8. 
+
      8. FEXPR
        9. 
+
      9. SUBR
        10. 
+
      10. FSUBR
        11. 
 
      
 
      This means that, while the other potential values can be retrieved from the property list, interpreted definitions (if present) will always be preferred to uninterpreted definitions, and lambda function definitions (which evaluate their arguments), where present, will always be preferred to non-lamda definitions, which don’t.
      
 
      BUT NOTE THAT the APVAL value is sought only when seeking a variable value for the symbol, while the others are only when seeking a function value, so Lisp 1.5 is a ‘Lisp 2’, not a ‘Lisp 1’. I strongly believe that this is wrong: a function is a value, and should be treated as such. But at the same time I do acknowledge the benefit of being able to store both source and compiled forms of the function as properties of the same symbol.
      
-
      The persistent problem
      
+
      The persistent problem
      
 
      There’s a view in modern software theory – with which I strongly hold – that data should be immutable. Data that changes under you is the source of all sorts of bugs. And in modern multi threaded systems, the act of reading a datum whilst some other process is writing it, or worse, two processes attempting simultaneously to write the same datum, is a source of data corruption and even crashes. So I’m very wary of mutable data; and, in modern systems where we normally have a great deal of space and a lot of processor power, making fresh copies of data structures containing the change we wanted to make is a reasonable price to pay for avoiding a whole class of bugs.
      
 
      But early software was not like that. It was always constrained by the limits of the hardware on which it ran, to a degree that we are not. And the experience that we now have of the problems caused by mutable data, they did not have. So it’s core to the design of Lisp 1.5 that its lists are mutable; and, indeed, one of the biggest challenges in writing Beowulf has been implementing mutable lists in Clojure, a language carefully designed to prevent them.
      
 
      But, just because Lisp 1.5 lists can be mutable, should they be? And when should they be?
      
@@ -108,50 +110,50 @@ O14 (read lines O and 1)
 
      What I do at present, and what I think may be good enough, is that each time execution returns to the read-eval-print loop, the REPL, the user’s command line, I rebuild a new execution stack on the top of the oblist as it exists now. So, if the last operation modified the oblist, the next operation will see the new, modified version. But if someone tried to run some persistent program which was writing stuff to property values and hoping to read them back in the same computation, that wouldn’t work, and it would be a very hard bug to trace down.
      
 
      So my options are:
      
 
        
-  
      1. To implement PUT and GET in Clojure, so that they can operate on the current copy of the object list, not the one at the base of the stack. I’m slightly unwilling to do that, because my objective is to make Beowulf ultimately as self-hosting as possible.
        2. 
-  
      2. To implement PUT and GET in Lisp, and have them destructively modify the working copy of the object list.
        3. 
+
      3. To implement PUT and GET in Clojure, so that they can operate on the current copy of the object list, not the one at the base of the stack. I’m slightly unwilling to do that, because my objective is to make Beowulf ultimately as self-hosting as possible.
        4. 
+
      4. To implement PUT and GET in Lisp, and have them destructively modify the working copy of the object list.
        5. 
 
      
 
      Neither of these particularly appeal.
      
-
      How property lists should work
      
-
      I’m still not fully understanding how property lists in Lisp 1.5 are supposed to work. 
      
-
      List format
      
-
      Firstly, are they association lists comprising dotted pairs of (property-name . value), i.e.: 
      
+
      How property lists should work
      
+
      I’m still not fully understanding how property lists in Lisp 1.5 are supposed to work.
      
+
      List format
      
+
      Firstly, are they association lists comprising dotted pairs of (property-name . value), i.e.:
      
 
      
-  
      ((property-name1 . value1) (property-name2 . value2) … (property-namen . valuen))
      
+
      ((property-name1 . value1) (property-name2 . value2) … (property-namen . valuen))
      
 
      
 
      I have assumed so, and that is what I presently intend to implement, but the diagrams on pages 59 and 60 seem rather to show a flat list of interleaved names and values:
      
 
      
-  
      (property-name1 value1 property-name2 value2 … property-namen valuen)
      
+
      (property-name1 value1 property-name2 value2 … property-namen valuen)
      
 
      
 
      I cannot see what the benefit of this latter arrangement is, and I’m unwilling to do it, although I think it may be what was done. But if it was done that way, why was it done that way? These were bright people, and they certainly knew about association lists. So… I’m puzzled.
      
-
      Function signatures
      
+
      Function signatures
      
 
      To associate the value of a property with a symbol, we need three things: we need the symbol, we need the property name, and we need the value. For this reason, Portable Standard Lisp and others has a function put with three arguments:
      
 
      
-  
      (Put U:id IND:id PROP:any): any The indicator IND with the property PROP is placed on the property list of the id U. If the action of Put occurs, the value of PROP is returned. If either of U and IND are not ids the type mismatch error occurs and no property is placed. (Put 'Jim 'Height 68) The above returns 68 and places (Height . 68) on the property list of the id Jim
      
+
      (Put U:id IND:id PROP:any): any The indicator IND with the property PROP is placed on the property list of the id U. If the action of Put occurs, the value of PROP is returned. If either of U and IND are not ids the type mismatch error occurs and no property is placed. (Put 'Jim 'Height 68) The above returns 68 and places (Height . 68) on the property list of the id Jim
      
 
      
 
      Cambridge Lisp is identical to this except in lower case. InterLisp and several others have putprop:
      
 
      
-  
      (PUTPROP ATM PROP VAL) [Function] Puts the property PROP with value VAL on the property list of ATM. VAL replaces any previous value for the property PROP on this property list. Returns VAL.
      
+
      (PUTPROP ATM PROP VAL) [Function] Puts the property PROP with value VAL on the property list of ATM. VAL replaces any previous value for the property PROP on this property list. Returns VAL.
      
 
      
 
      The execrable Common Lisp uses its execrable macro setf but really the less said about that the better.
      
-
      So I was looking for a function of three arguments to set properties, and I didn’t find one. 
      
+
      So I was looking for a function of three arguments to set properties, and I didn’t find one.
      
 
      There’s a function DEFINE which takes one argument, an association list of pairs:
      
-
      	(function-name . function-definition)`
+
      	(function-name . function-definition)`
 
      
 
      So how does that work, if what it’s doing is setting properties? If all you’re passing is pairs of name and definition, where does the property name come from?
      
 
      The answer is as follows, taken from the manual:
      
 
      
-  
      define [x] : EXPR pseudo-function
      
-  
      The argument of define, x, is a list of pairs
      
-  
      
-    
      ((ul vl) (u2 v2) … (un vn))
      
-  
      
-  
      where each u is a name and each v is a λ-expression for a function . For each pair, define puts an EXPR on the property list for u pointing to v. The function of define puts things on at the front of the property list. The value of define is the list of us.
      
+
      define x : EXPR pseudo-function
      
+
      The argument of define, x, is a list of pairs
      
+
      
+
      ((ul vl) (u2 v2) … (un vn))
      
+
      
+
      where each u is a name and each v is a λ-expression for a function . For each pair, define puts an EXPR on the property list for u pointing to v. The function of define puts things on at the front of the property list. The value of define is the list of us.
      
 
      
 
      So, in fact, the value of the property being set by define is fixed: hard wired, not parameterised. That seems an astonishing decision, until you realise that Lisp 1.5’s creators weren’t creating their functions one by one, in a playful exploration with their system, but entering them in a batch.
      
-
      Learning by doing
      
+
      Learning by doing
      
 
      In fact, when I got over my surprise, I realised that that (name . function-definition) list is actually very much like this, which is an excerpt from a sysout from a Beowulf prototype:
      
-
      (...
+
      (...
 	(MAPLIST LAMBDA (L F) 
            (COND ((NULL L) NIL) 
                  ((QUOTE T) (CONS (F (CAR L)) (MAPLIST (CDR L) F)))))
@@ -172,81 +174,45 @@ O14 (read lines O and 1)
 
      Because the point of a sysout is you don’t write it. The point about the REPL – the Read Eval Print Loop which is the heart of the interactive Lisp development cycle, where you sit playing with things and fiddling with them interactively, and where when one thing works you get onto the next without bothering to make some special effort to record it.
      
 
      The point of a sysout is that, at the end of the working day, you invoke one function
      
 
-  
-    
-      
-      
-      
-      
-      
-    
-  
-  
-    
-      
-      
-      
-      
-      
-    
-  
+
+
+
+
+
+
      Function Type Signature Implementation Documentation 
      SYSOUT Host function (SYSOUT); (SYSOUT FILEPATH) SUBR Dump the current content of the object list to file. If no filepath is specified, a file name will be constructed of the symbol Sysout and the current date. File paths will be considered relative to the filepath set when starting Lisp. 
       Function  Type  Signature  Implementation  Documentation 
       SYSOUT        Host function   (SYSOUT); (SYSOUT FILEPATH)  SUBR     Dump the current content of the object list to file. If no filepath is    specified, a file name will be constructed of the symbol Sysout and the current date. File paths will be considered relative to the filepath set when starting Lisp. 
      
 
      
 
      At the start of the next working day, you load that sysout in and continue your session.
      
 
      The sysout captures the entire working state of the machine. No-one types it in, as an operation in itself. Instead, data structures – corpuses of functions among them – simply build up on the object list almost casually, as a side effect of the fact that you’re enjoying exploring your problem and finding elegant ways of solving it. So SYSOUT and SYSIN seem to me, as someone who all his adult life has worked with Lisp interactively, as just an automatic part of the cycle of the day.
      
-
      The process of discovery
      
-
      The thing is, I don’t think anyone is ever going to use Beowulf the way Lisp 1.5 was used. I mean, probably, no one is ever going to use Beowulf at all; but if they did they wouldn’t use Beowulf the way Lisp 1.5 was used. 
      
+
      The process of discovery
      
+
      The thing is, I don’t think anyone is ever going to use Beowulf the way Lisp 1.5 was used. I mean, probably, no one is ever going to use Beowulf at all; but if they did they wouldn’t use Beowulf the way Lisp 1.5 was used.
      
 
      I’m a second generation software person. I have worked, in my career, with two people who personally knew and had worked with Alan Turing. I have worked with, and to an extent been mentored by, Chris Burton, who in his apprenticeship was part of the team that built the Manchester Mark One, and who in his retirement led the team who restored it. But I never knew the working conditions they were accustomed to. In my first year at university we used card punches, and, later, when we had a bit of seniority, teletypewriters (yes, that’s what TTY stands for), but by the time I’d completed my undergraduate degree and become a research associate I had a Xerox 1108 workstation with a huge bitmapped graphic screen, and an optical mouse, goddamit, running InterLisp, all to myself.
      
 
      People in the heroic age did not have computers all to themselves. They did not have terminals all to themselves. They didn’t sit at a terminal experimenting in the REPL. They wrote their algorithms in pencil on paper. When they were certain they’d got it right, they’d use a card punch to punch a deck of cards carrying the text of the program, and then they were certain they’d got that right, they’d drop it into the input hopper. Some time later their batch would run, and the operator would put the consequent printout into their pigeon hole for them to collect.
      
 
      (They wrote amazingly clean code, those old masters. I could tell you a story about Chris Burton, the train, and the printer driver, that software people of today simply would not believe. But it’s true. And I think that what taught them that discipline was the high cost of even small errors.)
      
 
      Lisp 1.5 doesn’t have PUT, PUTPROP or DEFUN because setting properties individually, defining functions individually one at a time, was not something they ever thought about doing. And in learning that, I’ve learned more than I ever expected to about the real nature of Lisp 1.5, and the (great) people who wrote it.
      
 
      
-
      Deeper delving
      
-
      After writing, and publishing, this essay, I went on procrastinating, which is what I do when I’m sure I’m missing something; and to procrastinate, I went on reading the earliest design documents of Lisp I could find. And so I came across the MIT AI team’s first ever memo, written by John McCarthy in September 1958. And in that, I find this:
      
+
      Deeper delving
      
+
      After writing, and publishing, this essay, I went on procrastinating, which is what I do when I’m sure I’m missing something; and to procrastinate, I went on reading the earliest design documents  of Lisp I could find. And so I came across the MIT AI team’s first ever memo, written by John McCarthy in September 1958. And in that, I find this:
      
 
      
-  
      3.2.1. First we have those that extract parts of a 704 word and form a word from parts. We shall distinguish the following parts of a word and indicate each of them by a characteristic letter.
      
-  
-    
-      
-        
-        
-      
-    
-    
-      
-        
-        
-      
-      
-        
-        
-      
-      
-        
-        
-      
-      
-        
-        
-      
-      
-        
-        
-      
-      
-        
-        
-      
-      
-        
-        
-      
-    
-  
      Letter Description 
      w the whole word 
      p the prefix (bits s, 1, 2) 
      i the indicator (bits 1 and 2) 
      s the sign bit 
      d the decrement (bits 3-17) 
      t the tag (bits 18-20) 
      a the address (bits 21-35) 
      
+
      3.2.1. First we have those that extract parts of a 704 word and form a word from parts. We shall distinguish the following parts of a word and indicate each of them by a characteristic letter.
      
+
+
+
+
+
+
+
+
+
+
+
+
+
+
       Letter  Description        
       w     the whole word               
       p     the prefix (bits s, 1, 2)    
       i     the indicator (bits 1 and 2) 
       s     the sign bit                 
       d     the decrement (bits 3-17)    
       t     the tag (bits 18-20)         
       a     the address (bits 21-35)     
      
 
      
 
      In the discussion of functions which access properties on page 58 of the Lisp 1.5 programmer’s manual, the word ‘indicator’ is used in preference to ‘symbol’ for the name of a property: for example
      
 
      
-  
      The function deflist is a more general defining function. Its first argument is a list of pairs as for define. Its second argument is the indicator that is to be used. After deflist has been executed with (ui vi) among its first argument, the property list of ui will begin:
      
-  
      If deflist or define is used twice on the same object with the same indicator, the old value will be replaced by the new one.
      
+
      The function deflist is a more general defining function. Its first argument is a list of pairs as for define. Its second argument is the indicator that is to be used. After deflist has been executed with (ui vi) among its first argument, the property list of ui will begin:
      
+
      If deflist or define is used twice on the same object with the same indicator, the old value will be replaced by the new one.
      
 
      
 
      (my emphasis).
      
 
      That use of ‘indicator’ has been nagging at me for a week. It looks like a term of art. If it’s just an ordinary atomic symbol, why isn’t it called a symbol?
      
@@ -254,10 +220,11 @@ O14 (read lines O and 1)
 
      The reason I don’t think so is that there are only two bits in the indicator part of the word, so only four distinct values; whereas we know that Lisp 1.5 has (at least) five distinct indicator values, APVAL, EXPR, FEXPR, SUBR and FSUBR.
      
 
      Furthermore, on page 39, we have:
      
 
      
-  
      A property list is characterized by having the special constant 777778 (i. e., minus 1) as the first element of the list. The rest of the list contains various properties of the atomic symbol. Each property is preceded by an atomic symbol which is called its indicator.
      
+
      A property list is characterized by having the special constant 777778 (i. e., minus 1) as the first element of the list. The rest of the list contains various properties of the atomic symbol. Each property is preceded by an atomic symbol which is called its indicator.
      
 
      
 
      (again, my emphasis)
      
 
      But I’m going to hypothesise that the properties were originally intended to be discriminated by the indicator bits in the cons cell, that they were originally coded that way, and that there was some code which depended on property lists being flat lists; and that, when it was discovered that four indicators were not enough and that something else was going to have to be used, the new format of the property list using atomic symbols as indicators was bodged in.
      
 
      
 
      So what this is about is I’ve spent most of a whole day procrastinating, because I’m not exactly sure how I’m going to make the change I’ve got to make. Versions of Beowulf up to and including 0.2.1 used the naive understanding of the architecture; version 0.3.0 should use the corrected version. But before it can, I need to be reasonably confident that I understand what the correct solution is.
      
-
      I shall implement PUT, even though it isn’t in the spec, because it’s a useful building block on which to build DEFINE and DEFLIS, both of which are. And also, because PUT would have been very easy for the Lisp 1.5 implementers to implement, if it had been relevant to their working environment. And I shall implement property list as flat lists of interleaved ‘indicator’ symbols and values, even with that nonsense 777778 as a prefix, because now I know (or think I know) that it was a bodge, it seems right in the spirit of historical reconstruction to reconstruct the bodge.
      \ No newline at end of file +

      I shall implement PUT, even though it isn’t in the spec, because it’s a useful building block on which to build DEFINE and DEFLIS, both of which are. And also, because PUT would have been very easy for the Lisp 1.5 implementers to implement, if it had been relevant to their working environment. And I shall implement property list as flat lists of interleaved ‘indicator’ symbols and values, even with that nonsense 777778 as a prefix, because now I know (or think I know) that it was a bodge, it seems right in the spirit of historical reconstruction to reconstruct the bodge.

      +
      \ No newline at end of file diff --git a/project.clj b/project.clj index b57eeb4..64742f2 100644 --- a/project.clj +++ b/project.clj @@ -1,17 +1,12 @@ -(defproject beowulf "0.3.0" +(defproject beowulf "0.3.1-SNAPSHOT" :aot :all :cloverage {:output "docs/cloverage" :ns-exclude-regex [#"beowulf\.gendoc" #"beowulf\.scratch"]} - :codox {:html {:transforms [[:head] [:append - [:link {:rel "icon" - :type "image/x-icon" - :href "../img/beowulf_logo_favicon.png"}]]]} - :metadata {:doc "**TODO**: write docs" + :codox {:metadata {:doc "**TODO**: write docs" :doc/format :markdown} :output-path "docs/codox" :source-uri "https://github.com/simon-brooke/beowulf/blob/master/{filepath}#L{line}" - ;; :themes [:journeyman] - } + :themes [:journeyman]} :description "LISP 1.5 is to all Lisp dialects as Beowulf is to English literature." :license {:name "GPL-2.0-or-later" :url "https://www.gnu.org/licenses/old-licenses/gpl-2.0.en.html"} @@ -23,15 +18,17 @@ [clojure.java-time "1.2.0"] [environ "1.2.0"] [instaparse "1.4.12"] -;; [org.jline/jline "3.23.0"] - [rhizome "0.2.9"] ;; not needed in production builds + [org.jline/jline "3.23.0"] + [com.github.seancorfield/expectations "2.0.165"] + ;; [rhizome "0.2.9"] ;; not needed in production builds ] :main beowulf.core :plugins [[lein-cloverage "1.2.2"] - [lein-codox "0.10.7"] + [lein-codox "0.10.8"] [lein-environ "1.1.0"]] :profiles {:jar {:aot :all} - :uberjar {:aot :all}} + :uberjar {:aot :all} + :dev {:resource-paths ["resources"]}} :release-tasks [["vcs" "assert-committed"] ["change" "version" "leiningen.release/bump-version" "release"] ["vcs" "commit"] @@ -42,4 +39,4 @@ ["change" "version" "leiningen.release/bump-version"] ["vcs" "commit"]] :target-path "target/%s" - :url "https://github.com/simon-brooke/the-great-game") + :url "https://github.com/simon-brooke/beowulf") diff --git a/resources/codox/theme/journeyman/css/default.css b/resources/codox/theme/journeyman/css/default.css new file mode 100644 index 0000000..a445e91 --- /dev/null +++ b/resources/codox/theme/journeyman/css/default.css @@ -0,0 +1,563 @@ +body { + font-family: Helvetica, Arial, sans-serif; + font-size: 15px; + color: limegreen; + background-color: black; +} + +a { + color: lime; +} + +a:active, a:hover { + color: yellowgreen; +} + +a:visited { + color: green; +} + +pre, code { + font-family: Monaco, DejaVu Sans Mono, Consolas, monospace; + font-size: 9pt; + margin: 15px 0; + color: limegreen; + background-color: #111; +} + +h1 { + font-weight: normal; + font-size: 29px; + margin: 10px 0 2px 0; + padding: 0; +} + +h2 { + font-weight: normal; + font-size: 25px; +} + +th, td { + vertical-align: top; +} + +h5.license { + margin: 9px 0 22px 0; + color: lime; + font-weight: normal; + font-size: 12px; + font-style: italic; +} + +.document h1, .namespace-index h1 { + font-size: 32px; + margin-top: 12px; +} + +#header, #content, .sidebar { + position: fixed; +} + +#header { + top: 0; + left: 0; + right: 0; + height: 22px; + color: limegreen; + padding: 5px 7px; +} + +#content { + top: 32px; + right: 0; + bottom: 0; + overflow: auto; + background: black; + color: green; + padding: 0 18px; +} + +.sidebar { + position: fixed; + top: 32px; + bottom: 0; + overflow: auto; +} + +.sidebar.primary { + background: #080808; + border-right: solid 1px forestgreen; + left: 0; + width: 250px; +} + +.sidebar.secondary { + background: #111; + border-right: solid 1px darkgreen; + left: 251px; + width: 200px; +} + +#content.namespace-index, #content.document { + left: 251px; +} + +#content.namespace-docs { + left: 452px; +} + +#content.document { + padding-bottom: 10%; +} + +#header { + background: #080808; + box-shadow: 0 0 8px rgba(192, 255, 192, 0.4); + z-index: 100; +} + +#header h1 { + margin: 0; + padding: 0; + font-size: 18px; + font-weight: lighter; + text-shadow: -1px -1px 0px #333; +} + +#header h1 .project-version { + font-weight: normal; +} + +.project-version { + padding-left: 0.15em; +} + +#header a, .sidebar a { + display: block; + text-decoration: none; +} + +#header h2 { + float: right; + font-size: 9pt; + font-weight: normal; + margin: 4px 3px; + padding: 0; + color: #5f5; +} + +#header h2 a { + display: inline; +} + +.sidebar h3 { + margin: 0; + padding: 10px 13px 0 13px; + font-size: 19px; + font-weight: lighter; +} + +.sidebar h3 a { + color: #4f4; +} + +.sidebar h3.no-link { + color: green; +} + +.sidebar ul { + padding: 7px 0 6px 0; + margin: 0; +} + +.sidebar ul.index-link { + padding-bottom: 4px; +} + +.sidebar li { + display: block; + vertical-align: middle; +} + +.sidebar li a, .sidebar li .no-link { + border-left: 3px solid transparent; + padding: 0 10px; + white-space: nowrap; +} + +.sidebar li .no-link { + display: block; + color: #7F7; + font-style: italic; +} + +.sidebar li .inner { + display: inline-block; + padding-top: 7px; + height: 24px; +} + +.sidebar li a, .sidebar li .tree { + height: 31px; +} + +.depth-1 .inner { padding-left: 2px; } +.depth-2 .inner { padding-left: 6px; } +.depth-3 .inner { padding-left: 20px; } +.depth-4 .inner { padding-left: 34px; } +.depth-5 .inner { padding-left: 48px; } +.depth-6 .inner { padding-left: 62px; } + +.sidebar li .tree { + display: block; + float: left; + position: relative; + top: -10px; + margin: 0 4px 0 0; + padding: 0; +} + +.sidebar li.depth-1 .tree { + display: none; +} + +.sidebar li .tree .top, .sidebar li .tree .bottom { + display: block; + margin: 0; + padding: 0; + width: 7px; +} + +.sidebar li .tree .top { + border-left: 1px solid yellowgreen; + border-bottom: 1px solid yellowgreen; + height: 19px; +} + +.sidebar li .tree .bottom { + height: 22px; +} + +.sidebar li.branch .tree .bottom { + border-left: 1px solid yellowgreen; +} + +.sidebar.primary li.current a { + border-left: 3px solid goldenrod; + color: goldenrod; +} + +.sidebar.secondary li.current a { + border-left: 3px solid yellow; + color: yellow; +} + +.namespace-index h2 { + margin: 30px 0 0 0; +} + +.namespace-index h3 { + font-size: 16px; + font-weight: bold; + margin-bottom: 0; +} + +.namespace-index .topics { + padding-left: 30px; + margin: 11px 0 0 0; +} + +.namespace-index .topics li { + padding: 5px 0; +} + +.namespace-docs h3 { + font-size: 18px; + font-weight: bold; +} + +.public h3 { + margin: 0; + float: left; +} + +.usage { + clear: both; +} + +.public { + margin: 0; + border-top: 1px solid lime; + padding-top: 14px; + padding-bottom: 6px; +} + +.public:last-child { + margin-bottom: 20%; +} + +.members .public:last-child { + margin-bottom: 0; +} + +.members { + margin: 15px 0; +} + +.members h4 { + color: lime; + font-weight: normal; + font-variant: small-caps; + margin: 0 0 5px 0; +} + +.members .inner { + padding-top: 5px; + padding-left: 12px; + margin-top: 2px; + margin-left: 7px; + border-left: 1px solid #5f5; +} + +#content .members .inner h3 { + font-size: 12pt; +} + +.members .public { + border-top: none; + margin-top: 0; + padding-top: 6px; + padding-bottom: 0; +} + +.members .public:first-child { + padding-top: 0; +} + +h4.type, +h4.dynamic, +h4.added, +h4.deprecated { + float: left; + margin: 3px 10px 15px 0; + font-size: 15px; + font-weight: bold; + font-variant: small-caps; +} + +.public h4.type, +.public h4.dynamic, +.public h4.added, +.public h4.deprecated { + font-size: 13px; + font-weight: bold; + margin: 3px 0 0 10px; +} + +.members h4.type, +.members h4.added, +.members h4.deprecated { + margin-top: 1px; +} + +h4.type { + color: #717171; +} + +h4.dynamic { + color: #9933aa; +} + +h4.added { + color: #7acc32; +} + +h4.deprecated { + color: #880000; +} + +.namespace { + margin-bottom: 30px; +} + +.namespace:last-child { + margin-bottom: 10%; +} + +.index { + padding: 0; + font-size: 80%; + margin: 15px 0; + line-height: 16px; +} + +.index * { + display: inline; +} + +.index p { + padding-right: 3px; +} + +.index li { + padding-right: 5px; +} + +.index ul { + padding-left: 0; +} + +.type-sig { + clear: both; + color: goldenrod; +} + +.type-sig pre { + padding-top: 10px; + margin: 0; +} + +.usage code { + display: block; + margin: 2px 0; + color: limegreen; +} + +.usage code:first-child { + padding-top: 10px; +} + +p { + margin: 15px 0; +} + +.public p:first-child, .public pre.plaintext { + margin-top: 12px; +} + +.doc { + margin: 0 0 26px 0; + clear: both; +} + +.public .doc { + margin: 0; +} + +.namespace-index .doc { + margin-bottom: 20px; +} + +.namespace-index .namespace .doc { + margin-bottom: 10px; +} + +.markdown p, .markdown li, .markdown dt, .markdown dd, .markdown td { + line-height: 22px; +} + +.markdown li { + padding: 2px 0; +} + +.markdown h2 { + font-weight: normal; + font-size: 25px; + margin: 30px 0 10px 0; +} + +.markdown h3 { + font-weight: normal; + font-size: 20px; + margin: 30px 0 0 0; +} + +.markdown h4 { + font-size: 15px; + margin: 22px 0 -4px 0; +} + +.doc, .public, .namespace .index { + max-width: 680px; + overflow-x: visible; +} + +.markdown pre > code { + display: block; + padding: 10px; +} + +.markdown pre > code, .src-link a { + border: 1px solid lime; + border-radius: 2px; +} + +.markdown code:not(.hljs), .src-link a { + background: #111; +} + +pre.deps { + display: inline-block; + margin: 0 10px; + border: 1px solid lime; + border-radius: 2px; + padding: 10px; + background-color: #111; +} + +.markdown hr { + border-style: solid; + border-top: none; + color: goldenrod; +} + +.doc ul, .doc ol { + padding-left: 30px; +} + +.doc table { + border-collapse: collapse; + margin: 0 10px; +} + +.doc table td, .doc table th { + border: 1px solid goldenrod; + padding: 4px 6px; +} + +.doc table th { + background: #111; +} + +.doc dl { + margin: 0 10px 20px 10px; +} + +.doc dl dt { + font-weight: bold; + margin: 0; + padding: 3px 0; + border-bottom: 1px solid goldenrod; +} + +.doc dl dd { + padding: 5px 0; + margin: 0 0 5px 10px; +} + +.doc abbr { + border-bottom: 1px dotted goldenrod; + font-variant: none; + cursor: help; +} + +.src-link { + margin-bottom: 15px; +} + +.src-link a { + font-size: 70%; + padding: 1px 4px; + text-decoration: none; + color: lime5bb; +} diff --git a/resources/codox/theme/journeyman/css/highlight.css b/resources/codox/theme/journeyman/css/highlight.css new file mode 100644 index 0000000..d0cdaa3 --- /dev/null +++ b/resources/codox/theme/journeyman/css/highlight.css @@ -0,0 +1,97 @@ +/* +github.com style (c) Vasily Polovnyov +*/ + +.hljs { + display: block; + overflow-x: auto; + padding: 0.5em; + color: #333; + background: #f8f8f8; +} + +.hljs-comment, +.hljs-quote { + color: #998; + font-style: italic; +} + +.hljs-keyword, +.hljs-selector-tag, +.hljs-subst { + color: #333; + font-weight: bold; +} + +.hljs-number, +.hljs-literal, +.hljs-variable, +.hljs-template-variable, +.hljs-tag .hljs-attr { + color: #008080; +} + +.hljs-string, +.hljs-doctag { + color: #d14; +} + +.hljs-title, +.hljs-section, +.hljs-selector-id { + color: #900; + font-weight: bold; +} + +.hljs-subst { + font-weight: normal; +} + +.hljs-type, +.hljs-class .hljs-title { + color: #458; + font-weight: bold; +} + +.hljs-tag, +.hljs-name, +.hljs-attribute { + color: #000080; + font-weight: normal; +} + +.hljs-regexp, +.hljs-link { + color: #009926; +} + +.hljs-symbol, +.hljs-bullet { + color: #990073; +} + +.hljs-built_in, +.hljs-builtin-name { + color: #0086b3; +} + +.hljs-meta { + color: #999; + font-weight: bold; +} + +.hljs-deletion { + background: #fdd; +} + +.hljs-addition { + background: #dfd; +} + +.hljs-emphasis { + font-style: italic; +} + +.hljs-strong { + font-weight: bold; +} diff --git a/resources/codox/theme/journeyman/theme.edn b/resources/codox/theme/journeyman/theme.edn new file mode 100644 index 0000000..0875f7f --- /dev/null +++ b/resources/codox/theme/journeyman/theme.edn @@ -0,0 +1,11 @@ +{:resources ["css/default.css" "css/highlight.css"] + :transforms [[:head] [:append + [:link {:rel "stylesheet" + :type "text/css" + :href "css/default.css"}] + [:link {:rel "stylesheet" + :type "text/css" + :href "css/highlight.css"}] + [:link {:rel "icon" + :type "image/x-icon" + :href "../img/beowulf_logo_favicon.png"}]]]} \ No newline at end of file diff --git a/resources/codox/themes/journeyman/theme.edn b/resources/codox/themes/journeyman/theme.edn deleted file mode 100644 index e1fdd5e..0000000 --- a/resources/codox/themes/journeyman/theme.edn +++ /dev/null @@ -1 +0,0 @@ -{:resources ["css/default.css" "css/highlight.css"]} \ No newline at end of file diff --git a/resources/lisp1.5.lsp b/resources/lisp1.5.lsp index e56bc7d..ad537a5 100644 --- a/resources/lisp1.5.lsp +++ b/resources/lisp1.5.lsp @@ -25,6 +25,7 @@ (T (ASSOC X (CDR L))))) SUBR (BEOWULF HOST ASSOC)) (ATOM 32767 SUBR (BEOWULF HOST ATOM)) + (ATTRIB 32767 SUBR (BEOWULF HOST ATTRIB)) (CAR 32767 SUBR (BEOWULF HOST CAR)) (CAAAAR 32767 EXPR (LAMBDA (X) (CAR (CAR (CAR (CAR X)))))) (CAAADR 32767 EXPR (LAMBDA (X) (CAR (CAR (CAR (CDR X)))))) @@ -55,6 +56,16 @@ (CDDDR 32767 EXPR (LAMBDA (X) (CDR (CDR (CDR X))))) (CDDR 32767 EXPR (LAMBDA (X) (CDR (CDR X)))) (CDR 32767 SUBR (BEOWULF HOST CDR)) + (CONC + 32767 + FEXPR + (LABEL + ARGS + (COND + ((COND + ((ONEP (LENGTH ARGS)) ARGS) + (T (ATTRIB (CAR ARGS) (APPLY CONC (CDR ARGS) NIL)))) + ARGS)))) (CONS 32767 SUBR (BEOWULF HOST CONS)) (CONSP 32767 SUBR (BEOWULF HOST CONSP)) (COPY @@ -170,6 +181,7 @@ (COND ((NULL X) (U)) ((EQ (CAR X) Y) (CDR X)) (T (PROP (CDR X) Y U))))) + (PUT 32767 SUBR (BEOWULF HOST PUT)) (QUOTE 32767 EXPR (LAMBDA (X) X)) (QUOTIENT 32767 SUBR (BEOWULF HOST QUOTIENT)) (RANGE @@ -187,6 +199,7 @@ (LAMBDA (N X) (COND ((EQ N 0) NIL) (T (CONS X (REPEAT (SUB1 N) X)))))) (RPLACA 32767 SUBR (BEOWULF HOST RPLACA)) (RPLACD 32767 SUBR (BEOWULF HOST RPLACD)) + (SASSOC 32767 SUBR (BEOWULF BOOTSTRAP SASSOC)) (SEARCH 32767 EXPR (LAMBDA (X P F U) (COND ((NULL X) (U X)) diff --git a/resources/sexpr/conc.lsp b/resources/sexpr/conc.lsp index 2738a45..ebd03b1 100644 --- a/resources/sexpr/conc.lsp +++ b/resources/sexpr/conc.lsp @@ -1 +1,7 @@ -;; TODO \ No newline at end of file +;; This isn't working but it's really not far off. + +(PUT 'CONC 'FEXPR + ;; possibly ARGS should be (ARGS)... + '(LABEL ARGS + (COND ((COND ((ONEP (LENGTH ARGS)) ARGS) + (T (ATTRIB (CAR ARGS) (APPLY CONC (CDR ARGS) NIL)))) ARGS)))) \ No newline at end of file diff --git a/resources/sexpr/fact.lsp b/resources/sexpr/fact.lsp new file mode 100644 index 0000000..86b2a97 --- /dev/null +++ b/resources/sexpr/fact.lsp @@ -0,0 +1,22 @@ +;; Common Lisp + +(defun range (max &key (min 0) (step 1)) + (loop for n from min below max by step + collect n)) + +(mapcar #'(lambda (x) (+ x 1)) (range 10)) + +(defun factoriali (n) + (reduce #'* (range (+ n 1) :min 1 :step 1))) + +(defun factorialr (n) + (cond ((= n 1) 1) + (t (* n (factorialr (- n 1)))))) + + +;; Clojure +(defn factorial [n] + (reduce *' (range 1 (+ n 1)))) + +(defn expt [n x] + (reduce *' (repeat x n))) diff --git a/resources/sexpr/select.lsp b/resources/sexpr/select.lsp new file mode 100644 index 0000000..4b09439 --- /dev/null +++ b/resources/sexpr/select.lsp @@ -0,0 +1,13 @@ +;; Bottom of page 66 + +(PUT 'SELECT 'FEXPR + '(LABEL FORM + (PROG (Q BODY) + (SETQ Q (EVAL (CAR FORM))) ;; not sure that Q should be evaled. + (SETQ BODY (CDR FORM)) + LOOP + (COND + ((EQ NIL (CDR BODY)) (RETURN (CAR BODY))) + ((EQ Q (EVAL (CAAR BODY))) (RETURN (CDAR BODY)))) + (SETQ BODY (CDR BODY)) + (GO LOOP)))) \ No newline at end of file diff --git a/src/beowulf/bootstrap.clj b/src/beowulf/bootstrap.clj index d530f62..7f4ed1a 100644 --- a/src/beowulf/bootstrap.clj +++ b/src/beowulf/bootstrap.clj @@ -11,9 +11,11 @@ objects." (:require [beowulf.cons-cell :refer [F make-beowulf-list make-cons-cell pretty-print T]] - [beowulf.host :refer [ASSOC ATOM CAAR CADAR CADDR CADR CAR CDR GET - LIST NUMBERP PAIRLIS traced?]] - [beowulf.oblist :refer [*options* NIL oblist]]) + [beowulf.host :refer [ASSOC ATOM CAAR CAADR CADAR CADDR CADR CAR CDR + CONS ERROR GET LIST NUMBERP PAIRLIS traced?]] + [beowulf.oblist :refer [*options* NIL]] + [clojure.string :as s] + [clojure.tools.trace :refer [deftrace]]) (:import [beowulf.cons_cell ConsCell] [clojure.lang Symbol])) @@ -37,10 +39,20 @@ ;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -(declare APPLY EVAL prog-eval) +(declare APPLY EVAL EVCON prog-eval) ;;;; The PROGram feature ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +(def ^:dynamic + *depth* + "Stack depth. Unfortunately we need to be able to pass round depth for + functions which call EVAL/APPLY but do not know about depth." + 0) + +(defn- trace-indent + ([] (trace-indent *depth*)) + ([d] (s/join (repeat d " ")))) + (def find-target (memoize (fn [target body] @@ -82,30 +94,45 @@ (cond (number? expr) expr (symbol? expr) (@vars expr) - (instance? ConsCell expr) (case (.getCar expr) - COND (prog-cond (.getCdr expr) + (instance? ConsCell expr) (case (CAR expr) + COND (prog-cond (CDR expr) vars env depth) - GO (make-cons-cell - '*PROGGO* (.getCar (.getCdr expr))) - RETURN (make-cons-cell - '*PROGRETURN* - (prog-eval (.getCar (.getCdr expr)) - vars env depth)) - SET (let [v (CADDR expr)] + GO (let [target (CADR expr)] + (when (traced? 'PROG) + (println " PROG:GO: Goto " target)) + (make-cons-cell + '*PROGGO* target)) + RETURN (let [val (prog-eval + (CADR expr) + vars env depth)] + (when (traced? 'PROG) + (println " PROG:RETURN: Returning " + val)) + (make-cons-cell + '*PROGRETURN* + val)) + SET (let [var (prog-eval (CADR expr) + vars env depth) + val (prog-eval (CADDR expr) + vars env depth)] + (when (traced? 'PROG) + (println " PROG:SET: Setting " + var " to " val)) (swap! vars assoc - (prog-eval (CADR expr) - vars env depth) - (prog-eval (CADDR expr) - vars env depth)) - v) - SETQ (let [v (CADDR expr)] + var + val) + val) + SETQ (let [var (CADDR expr) + val (prog-eval var + vars env depth)] + (when (traced? 'PROG) + (println " PROG:SETQ: Setting " var " to " val)) (swap! vars assoc (CADR expr) - (prog-eval v - vars env depth)) - v) + val) + val) ;; else (beowulf.bootstrap/EVAL expr (merge-vars vars env) @@ -173,7 +200,7 @@ (println "Program:") (pretty-print program))) ;; for debugging (loop [cursor body] - (let [step (.getCar cursor)] + (let [step (if (= NIL cursor) NIL (.getCar cursor))] (when trace (do (println "Executing step: " step) (println " with vars: " @vars))) (cond (= cursor NIL) NIL @@ -206,7 +233,7 @@ with these `args` at this depth." [function-symbol args depth] (when (traced? function-symbol) - (let [indent (apply str (repeat depth "-"))] + (let [indent (trace-indent depth)] (println (str indent "> " function-symbol " " args))))) (defn- trace-response @@ -214,11 +241,13 @@ `function-symbol` at this depth." [function-symbol response depth] (when (traced? function-symbol) - (let [indent (apply str (repeat depth "-"))] + (let [indent (apply str (trace-indent depth))] (println (str "<" indent " " function-symbol " " response)))) response) -(defn- value +;;;; Support functions for interpreter ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +(defn value "Seek a value for this symbol `s` by checking each of these indicators in turn." ([s] @@ -228,6 +257,21 @@ (first (remove #(= % NIL) (map #(GET s %) indicators)))))) +(defn SASSOC + "Like `ASSOC`, but with an action to take if no value is found. + + From the manual, page 60: + + 'The function `sassoc` searches `y`, which is a list of dotted pairs, for + a pair whose first element that is `x`. If such a pair is found, the value + of `sassoc` is this pair. Otherwise the function `u` of no arguments is + taken as the value of `sassoc`.'" + [x y u] + (let [v (ASSOC x y)] + (if-not (= v NIL) v + (APPLY u NIL NIL)))) + + ;;;; APPLY ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (defn try-resolve-subroutine @@ -248,7 +292,7 @@ return the result." [^Symbol function-symbol args ^ConsCell environment depth] (trace-call function-symbol args depth) - (let [lisp-fn (value function-symbol '(EXPR FEXPR)) + (let [lisp-fn (value function-symbol '(EXPR FEXPR)) ;; <-- should these be handled differently? I think so! args' (cond (= NIL args) args (empty? args) NIL (instance? ConsCell args) args @@ -275,6 +319,43 @@ (trace-response function-symbol result depth) result)) +;; (LABEL ARGS +;; (COND ((COND ((ONEP (LENGTH ARGS)) ARGS) +;; (T (ATTRIB (CAR ARGS) (APPLY CONC (CDR ARGS) NIL)))) +;; ARGS))) +;; ((1 2 3 4) (5 6 7 8) (9 10 11 12)) +;; NIL +;; (def function (make-beowulf-list '(LABEL ARGS (COND +;; ((COND ((ONEP (LENGTH ARGS)) ARGS) +;; (T (ATTRIB (CAR ARGS) +;; (APPLY CONC (CDR ARGS) NIL)))) +;; ARGS))))) +;; (def args (make-beowulf-list '((1 2 3 4) (5 6 7 8) (9 10 11 12)))) + +;; function +;; (CADR function) +;; (CADDR function) + +(defn apply-label + "Apply in the special case that the first element in the function is `LABEL`." + [function args environment depth] + (EVAL + (CADDR function) + (CONS + (CONS (CADR function) args) + environment) + depth)) + +;; (apply-label function args NIL 1) +;; (APPLY function args NIL 1) + +(defn- apply-lambda + "Apply in the special case that the first element in the function is `LAMBDA`." + [function args environment depth] + (EVAL + (CADDR function) + (PAIRLIS (CADR function) args environment) depth)) + (defn APPLY "Apply this `function` to these `arguments` in this `environment` and return the result. @@ -282,38 +363,34 @@ For bootstrapping, at least, a version of APPLY written in Clojure. All args are assumed to be symbols or `beowulf.cons-cell/ConsCell` objects. See page 13 of the Lisp 1.5 Programmers Manual." - [function args environment depth] - (trace-call 'APPLY (list function args environment) depth) - (let [result (cond - (= NIL function) (if (:strict *options*) - NIL - (throw (ex-info "NIL sí ne þegnung" - {:phase :apply - :function "NIL" - :args args - :type :beowulf}))) - (= (ATOM function) T) (apply-symbolic function args environment (inc depth)) - :else (case (first function) - LABEL (APPLY - (CADDR function) - args - (make-cons-cell - (make-cons-cell - (CADR function) - (CADDR function)) - environment) - depth) - FUNARG (APPLY (CADR function) args (CADDR function) depth) - LAMBDA (EVAL - (CADDR function) - (PAIRLIS (CADR function) args environment) depth) - (throw (ex-info "Ungecnáwen wyrþan sí þegnung-weard" - {:phase :apply - :function function - :args args - :type :beowulf}))))] - (trace-response 'APPLY result depth) - result)) + ([function args environment] + (APPLY function args environment *depth*)) + ([function args environment depth] + (binding [*depth* (inc depth)] + (trace-call 'APPLY (list function args environment) depth) + (let [result (cond + (= NIL function) (if (:strict *options*) + NIL + (throw (ex-info "NIL sí ne þegnung" + {:phase :apply + :function "NIL" + :args args + :type :beowulf}))) + (= (ATOM function) T) (apply-symbolic function args environment (inc depth)) + :else (case (first function) + LABEL (apply-label function args environment depth) + FUNARG (APPLY (CADR function) args (CADDR function) depth) + LAMBDA (apply-lambda function args environment depth) + ;; else + ;; OK, this is *not* what is says in the manual... + ;; COND (EVCON ???) + (throw (ex-info "Ungecnáwen wyrþan sí þegnung-weard" + {:phase :apply + :function function + :args args + :type :beowulf}))))] + (trace-response 'APPLY result depth) + result)))) ;;;; EVAL ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; @@ -361,12 +438,12 @@ (println (str indent ": EVAL: sceald bindele: " (or v "nil")))) (if (instance? ConsCell v) (.getCdr v) - (let [v' (value expr (list 'APVAL))] + (let [v' (value expr)] (when (traced? 'EVAL) (println (str indent ": EVAL: deóp bindele: (" expr " . " (or v' "nil") ")"))) (if v' v' - (throw (ex-info "Ne tácen-bindele āfand" + (throw (ex-info (format "Ne tácen-bindele āfand: `%s`" expr) {:phase :eval :function 'EVAL :args (list expr env depth) @@ -412,11 +489,10 @@ (EVLIS (CDR expr) env depth) env depth)) - :else (APPLY - (CAR expr) - (EVLIS (CDR expr) env depth) - env - depth))] + :else (EVAL (CONS (CDR (SASSOC (CAR expr) env (fn [] (ERROR 'A9)))) + (CDR expr)) + env + (inc depth)))] (trace-response 'EVAL result depth) result))) diff --git a/src/beowulf/core.clj b/src/beowulf/core.clj index d20339d..74131ff 100644 --- a/src/beowulf/core.clj +++ b/src/beowulf/core.clj @@ -53,7 +53,8 @@ (.canRead (io/file %))) "Could not find sysout file"]] ["-s" "--strict" "Strictly interpret the Lisp 1.5 language, without extensions."] - ["-t" "--time" "Time evaluations."]]) + ["-t" "--time" "Time evaluations."] + ["-x" "--testing" "Disable the jline reader - useful when piping input."]]) (defn- re "Like REPL, but it isn't a loop and doesn't print." @@ -63,11 +64,10 @@ (defn repl "Read/eval/print loop." [prompt] - (loop [] - (print prompt) + (loop [] (flush) (try - (if-let [input (trim (read-from-console))] + (if-let [input (trim (read-from-console prompt))] (if (= input stop-word) (throw (ex-info "\nFærwell!" {:cause :quit})) (println @@ -116,7 +116,7 @@ (catch Throwable any (println any)))) (try - (repl (str (:prompt (:options args)) " ")) + (repl (:prompt (:options args))) (catch Exception e diff --git a/src/beowulf/host.clj b/src/beowulf/host.clj index 48f622d..9c0bdb5 100644 --- a/src/beowulf/host.clj +++ b/src/beowulf/host.clj @@ -91,22 +91,21 @@ (cond (= l NIL) NIL (empty? path) l - :else - (try - (case (last path) - \a (uaf (.first l) (butlast path)) - \d (uaf (.getCdr l) (butlast path)) - (throw (ex-info (str "uaf: unexpected letter in path (only `a` and `d` permitted): " (last path)) - {:cause :uaf - :detail :unexpected-letter - :expr (last path)}))) - (catch ClassCastException e - (throw (ex-info - (str "uaf: Not a LISP list? " (type l)) - {:cause :uaf - :detail :not-a-lisp-list - :expr l} - e)))))) + (not (instance? ConsCell l)) (throw (ex-info (str "Ne liste: " + l "; " (type l)) + {:phase :eval + :function "universal access function" + :args [l path] + :type :beowulf})) + :else (case (last path) + \a (uaf (.first l) (butlast path)) + \d (uaf (.getCdr l) (butlast path)) + (throw (ex-info (str "uaf: unexpected letter in path (only `a` and `d` permitted): " + (last path)) + {:phase :eval + :function "universal access function" + :args [l path] + :type :beowulf}))))) (defmacro CAAR [x] `(uaf ~x '(\a \a))) (defmacro CADR [x] `(uaf ~x '(\a \d))) @@ -217,7 +216,7 @@ :phase :host :detail :rplacd :args (list cell value) - :type :beowulf}))));; PLUS + :type :beowulf})))) (defn LIST [& args] @@ -433,6 +432,41 @@ "The unexplained magic number which marks the start of a property list." (Integer/parseInt "77777" 8)) +(defn hit-or-miss-assoc + "Find the position of the binding of this `target` in a Lisp 1.5 + property list `plist`. + + Lisp 1.5 property lists are not assoc lists, but lists of the form + `(name value name value name value...)`. It's therefore necessary to + recurse down the list two entries at a time to avoid confusing names + with values." + [target plist] + (if (and (instance? ConsCell plist) (even? (count plist))) + (cond (= plist NIL) NIL + (= (first plist) target) plist + :else (hit-or-miss-assoc target (CDDR plist))) + NIL)) + +(defn ATTRIB + "Destructive append. From page 59 of the manual: + + The function `attrib` concatenates its two arguments by changing the last + element of its first argument to point to the second argument. Thus it + is commonly used to tack something onto the end of a property list. + The value of `attrib` is the second argument. + + For example + ``` + attrib[FF; (EXPR (LAMBDA (X) (COND ((ATOM X) X) (T (FF (CAR x))))))] + ``` + would put EXPR followed by the LAMBDA expression for FF onto the end of + the property list for FF." + [x e] + (loop [l x] + (cond + (instance? ConsCell (CDR l)) (recur (CDR l)) + :else (when (RPLACD l e) e)))) + (defn PUT "Put this `value` as the value of the property indicated by this `indicator` of this `symbol`. Return `value` on success. @@ -440,22 +474,27 @@ NOTE THAT there is no `PUT` defined in the manual, but it would have been easy to have defined it so I don't think this fully counts as an extension." [symbol indicator value] - (if-let [binding (ASSOC symbol @oblist)] - (if-let [prop (ASSOC indicator (CDDR binding))] - (RPLACD prop value) - (RPLACD binding - (make-cons-cell - magic-marker - (make-cons-cell - indicator - (make-cons-cell value (CDDR binding)))))) - (swap! - oblist - (fn [ob s p v] - (make-cons-cell - (make-beowulf-list (list s magic-marker p v)) - ob)) - symbol indicator value))) + (let [binding (ASSOC symbol @oblist)] + (if (instance? ConsCell binding) + (let [prop (hit-or-miss-assoc indicator (CDDR binding))] + (if (instance? ConsCell prop) + (RPLACA (CDR prop) value) + ;; The implication is ATTRIB was used here, but I have not made that + ;; work and this does work, so if it ain't broke don't fix it. + (RPLACD binding + (make-cons-cell + magic-marker + (make-cons-cell + indicator + (make-cons-cell value (CDDR binding))))))) + (swap! + oblist + (fn [ob s p v] + (make-cons-cell + (make-beowulf-list (list s magic-marker p v)) + ob)) + symbol indicator value))) + value) (defn GET "From the manual: @@ -477,13 +516,9 @@ val (cond (= binding NIL) NIL (= magic-marker - (CADR binding)) (loop [b binding] - ;; (println "GET loop, seeking " indicator ":") - ;; (pretty-print b) - (if (instance? ConsCell b) - (if (= (CAR b) indicator) - (CADR b) ;; <- this is what we should actually be returning - (recur (CDR b))) + (CADR binding)) (let [p (hit-or-miss-assoc indicator binding)] + (if-not (= NIL p) + (CADR p) NIL)) :else (throw (ex-info "Misformatted property list (missing magic marker)" @@ -499,9 +534,10 @@ `indicator` of the symbol which is the first element of the pair to the value which is the second element of the pair. See page 58 of the manual." [a-list indicator] - (map - #(PUT (CAR %) indicator (CDR %)) - a-list)) + (doall + (map + #(when (PUT (CAR %) indicator (CDR %)) (CAR %)) + a-list))) (defn DEFINE "Bootstrap-only version of `DEFINE` which, post boostrap, can be overwritten diff --git a/src/beowulf/io.clj b/src/beowulf/io.clj index 62ead4c..d798762 100644 --- a/src/beowulf/io.clj +++ b/src/beowulf/io.clj @@ -91,7 +91,8 @@ ([] (SYSOUT nil)) ([filepath] - (spit (full-path (str filepath)) + (let [destination (full-path (str filepath))] + (spit destination (with-out-str (println (apply str (repeat 79 ";"))) (println (format ";; Beowulf %s Sysout file generated at %s" @@ -103,7 +104,9 @@ (println) (let [output (safely-wrap-subrs @oblist)] (pretty-print output) - ))))) + ))) + (println "Saved sysout to " destination) + NIL))) (defn resolve-subr "If this oblist `entry` references a subroutine, attempt to fix up that diff --git a/src/beowulf/oblist.clj b/src/beowulf/oblist.clj index 38aa999..8769b7f 100644 --- a/src/beowulf/oblist.clj +++ b/src/beowulf/oblist.clj @@ -41,5 +41,5 @@ (def ^:dynamic *options* "Command line options from invocation." - {}) + {:testing true}) diff --git a/src/beowulf/read.clj b/src/beowulf/read.clj index 54fcfe4..8ed736a 100644 --- a/src/beowulf/read.clj +++ b/src/beowulf/read.clj @@ -13,13 +13,14 @@ Both these extensions can be disabled by using the `--strict` command line switch." - (:require ;; [beowulf.reader.char-reader :refer [read-chars]] + (:require [beowulf.oblist :refer [*options*]] + [beowulf.reader.char-reader :refer [read-chars]] [beowulf.reader.generate :refer [generate]] [beowulf.reader.parser :refer [parse]] [beowulf.reader.simplify :refer [simplify]] [clojure.string :refer [join split starts-with? trim]]) - (:import [java.io InputStream] - [instaparse.gll Failure])) + (:import [instaparse.gll Failure] + [java.io InputStream])) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; @@ -82,24 +83,35 @@ (throw (ex-info "Ne can forstande " (assoc parse-tree :source source)))) (generate (simplify parse-tree))))) -(defn read-from-console - "Attempt to read a complete lisp expression from the console. NOTE that this - will only really work for S-Expressions, not M-Expressions." - [] - (loop [r (read-line)] - (if (and (= (count (re-seq #"\(" r)) - (count (re-seq #"\)" r))) +(defn- dummy-read-chars [prompt] + (loop [r "" p prompt] + (if (and (seq r) + (= (count (re-seq #"\(" r)) + (count (re-seq #"\)" r))) (= (count (re-seq #"\[" r)) (count (re-seq #"\]" r)))) r - (recur (str r "\n" (read-line)))))) + (do + (print (str p " ")) + (flush) + (recur (str r "\n" (read-line)) "::"))))) + +(defn read-from-console + "Attempt to read a complete lisp expression from the console. + + There's a major problem here that the read-chars reader messes up testing. + We need to be able to disable it while testing!" + [prompt] + (if (:testing *options*) + (dummy-read-chars prompt) + (read-chars prompt))) (defn READ "An implementation of a Lisp reader sufficient for bootstrapping; not necessarily the final Lisp reader. `input` should be either a string representation of a LISP expression, or else an input stream. A single form will be read." ([] - (gsp (read-from-console))) + (gsp (read-from-console (:prompt *options*)))) ([input] (cond (empty? input) (READ) diff --git a/src/beowulf/reader/char_reader.clj b/src/beowulf/reader/char_reader.clj index 883f8fa..a38f301 100644 --- a/src/beowulf/reader/char_reader.clj +++ b/src/beowulf/reader/char_reader.clj @@ -20,9 +20,12 @@ TODO: There are multiple problems with JLine; a better solution might be to start from here: https://stackoverflow.com/questions/7931988/how-to-manipulate-control-characters" - ;; (:import [org.jline.reader LineReader LineReaderBuilder] - ;; [org.jline.terminal TerminalBuilder]) - ) + (:require [beowulf.oblist :refer [*options* oblist]]) + (:import [org.jline.reader.impl.completer StringsCompleter] + [org.jline.reader.impl DefaultParser DefaultParser$Bracket] + [org.jline.reader LineReaderBuilder] + [org.jline.terminal TerminalBuilder] + [org.jline.widget AutopairWidgets AutosuggestionWidgets])) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; @@ -49,27 +52,56 @@ ;; looks as though you'd need a DPhil in JLine to write it, and I don't have ;; the time. -;; (def get-reader -;; "Return a reader, first constructing it if necessary. +(defn build-completer + "Build a completer which takes tokens from the oblist. -;; **NOTE THAT** this is not settled API. The existence and call signature of -;; this function is not guaranteed in future versions." -;; (memoize (fn [] -;; (let [term (.build (.system (TerminalBuilder/builder) true))] -;; (.build (.terminal (LineReaderBuilder/builder) term)))))) + This is sort-of working, in as much as hitting on a blank line will + show a table of values from the oblist, but hitting after you've + started input does not show potential completions for tokens you've started." + [] + (StringsCompleter. (map #(str (first %)) @oblist))) -;; (defn read-chars -;; "A drop-in replacement for `clojure.core/read-line`, except that line editing -;; and history should be enabled. +;; This breaks; it is not correctly resolving the Enum, although I can't work out +;; why not. +;; (defn build-parser +;; [] +;; (println "Building parser") +;; (let [parser (DefaultParser.)] +;; (doall +;; (.setEofOnUnclosedBracket +;; parser DefaultParser$Bracket/ROUND)))) + +(def get-reader + "Return a reader, first constructing it if necessary. -;; **NOTE THAT** this does not work yet, but it is in the API because I hope -;; that it will work later!" -;; [] -;; (let [eddie (get-reader)] -;; (loop [s (.readLine eddie)] -;; (if (and (= (count (re-seq #"\(" s)) -;; (count (re-seq #"\)" s))) -;; (= (count (re-seq #"\[]" s)) -;; (count (re-seq #"\]" s)))) -;; s -;; (recur (str s " " (.readLine eddie))))))) \ No newline at end of file + **NOTE THAT** this is not settled API. The existence and call signature of + this function is not guaranteed in future versions." + (memoize (fn [] + (let [term (.build (.system (TerminalBuilder/builder) true)) + reader (-> (LineReaderBuilder/builder) + (.terminal term) + (.completer (build-completer)) + ;; #(.parser % (build-parser)) + (.build)) + ;; apw (AutopairWidgets. reader false) + ;; asw (AutosuggestionWidgets. reader) + ] + ;; (.enable apw) + ;; (.enable asw) + reader)))) + +(defn read-chars + "A drop-in replacement for `clojure.core/read-line`, except that line editing + and history should be enabled. + + **NOTE THAT** this does not fully work yet, but it is in the API because I + hope that it will work later!" + [prompt] + (let [eddie (get-reader)] + (loop [s (.readLine eddie (str prompt " "))] + (if (and (= (count (re-seq #"\(" s)) + (count (re-seq #"\)" s))) + (= (count (re-seq #"\[]" s)) + (count (re-seq #"\]" s)))) + s + (recur (str s " " (.readLine eddie ":: "))))))) diff --git a/test/beowulf/core_test.clj b/test/beowulf/core_test.clj index 81cb86b..9c2029f 100644 --- a/test/beowulf/core_test.clj +++ b/test/beowulf/core_test.clj @@ -1,8 +1,9 @@ (ns beowulf.core-test - (:require [clojure.java.io :refer [reader]] - [clojure.string :refer [split]] - [clojure.test :refer [deftest is testing]] - [beowulf.core :refer [-main repl stop-word]])) + (:require [beowulf.core :refer [-main repl stop-word]] + [beowulf.oblist :refer [*options*]] + [clojure.java.io :refer [reader]] + [clojure.string :refer [split starts-with?]] + [clojure.test :refer [deftest is testing]])) ;; (deftest a-test ;; (testing "FIXME, I fail." @@ -20,45 +21,43 @@ (deftest repl-tests (testing "quit functionality" (with-open [r (reader (string->stream stop-word))] - (binding [*in* r] + (binding [clojure.core/*in* r + *options* (assoc *options* :testing true)] (is (thrown-with-msg? Exception #"\nFærwell!" (repl ""))))) - (let [expected nil actual (with-open [r (reader (string->stream stop-word))] (binding [*in* r] - (-main)))] + (-main "--testing")))] (is (= actual expected))))) -;; TODO: not working because STOP is not being recognised, but I haven't -;; worked out why not yet. It *did* work. - +;; The new read-chars interface is really messing with this. Need to sort out! +;; OK, binding `:testing` doesn't work because `*options*` gets rebound in main. +;; Need to be able to pass in a testing flag as argument to -main (deftest flag-tests - (testing "No flags" + (testing "Only testing flag" (let [expected-greeting "Hider wilcuman. Béowulf is mín nama." expected-quit-message (str "Sprecan '" stop-word "' tó laéfan") expected-result #".*\(3 \. 4\)" expected-prompt "Sprecan:: " expected-signoff "Færwell!" ;; anticipated output (note blank lines): - - ; Hider wilcuman. Béowulf is mín nama. - - ; Sprecan 'STOP' tó laéfan - - ; Sprecan:: > (3 . 4) - ; Sprecan:: - ; Færwell! + + ;; Hider wilcuman. Béowulf is mín nama. + + ;; Sprecan 'STOP' tó laéfan + + ;; Sprecan:: > (3 . 4) + ;; Sprecan:: + ;; Færwell! [_ greeting _ _ quit-message _ result prompt signoff] (with-open [r (reader (string->stream (str "cons[3; 4]\n" stop-word)))] (binding [*in* r] - (split (with-out-str (-main)) #"\n")))] + (split (with-out-str (-main "--testing")) #"\n")))] (is (= greeting expected-greeting)) - ; (is (= error expected-error)) (is (re-matches expected-result result)) (is (= quit-message expected-quit-message)) (is (= prompt expected-prompt)) - (is (= signoff expected-signoff)) - )) + (is (= signoff expected-signoff)))) (testing "unknown flag" (let [expected-greeting "Hider wilcuman. Béowulf is mín nama." expected-quit-message (str "Sprecan '" stop-word "' tó laéfan") @@ -69,115 +68,63 @@ [_ greeting _ error quit-message _ result prompt signoff] (with-open [r (reader (string->stream (str "cons[5; 6]\n" stop-word)))] (binding [*in* r] - (split (with-out-str (-main "--unknown")) #"\n")))] + (split (with-out-str (-main "--unknown" "--testing")) #"\n")))] (is (= greeting expected-greeting)) (is (re-matches expected-error error)) (is (re-matches expected-result result)) (is (= quit-message expected-quit-message)) (is (= prompt expected-prompt)) - (is (= signoff expected-signoff)) - )) - ; (testing "help" - ; (let [expected-greeting "Hider wilcuman. Béowulf is mín nama." - ; expected-h1 " -h, --help" - ; expected-quit-message (str "Sprecan '" stop-word "' tó laéfan") - ; expected-result #".*\(A \. B\)" - ; expected-prompt "Sprecan:: " - ; expected-signoff "Færwell!" - ; [_ greeting _ h1 _ _ _ _ quit-message _ result prompt signoff] - ; (with-open [r (reader (string->stream (str "cons[A; B]\n" stop-word)))] - ; (binding [*in* r] - ; (split (with-out-str (-main "--help")) #"\n")))] - ; (is (= greeting expected-greeting)) - ; (is (= h1 expected-h1)) - ; (is (re-matches expected-result result)) - ; (is (= quit-message expected-quit-message)) - ; (is (= prompt expected-prompt)) - ; (is (= signoff expected-signoff)) - ; )) - ; (testing "prompt" - ; (let [expected-greeting "Hider wilcuman. Béowulf is mín nama." - ; expected-quit-message (str "Sprecan '" stop-word "' tó laéfan") - ; expected-error "" - ; expected-result #".*\(A \. B\).*" - ; expected-prompt "? " - ; expected-signoff "Færwell!" - ; [_ greeting _ error quit-message _ result prompt signoff] - ; (with-open [r (reader (string->stream (str stop-word)))] - ; (binding [*in* r] - ; (split (with-out-str (-main "--prompt" "?")) #"\n")))] - ; (is (= greeting expected-greeting)) - ; (is (= error expected-error)) - ; (is (re-matches expected-result result )) - ; (is (= quit-message expected-quit-message)) - ; (is (= prompt expected-prompt)) - ; (is (= signoff expected-signoff)) - ; )) - ; (testing "read - file not found" - ; (let [expected-greeting "Hider wilcuman. Béowulf is mín nama." - ; expected-quit-message (str "Sprecan '" stop-word "' tó laéfan") - ; expected-error #"Failed to validate.*" - ; expected-result #".*\(A \. B\)" - ; expected-prompt "Sprecan:: " - ; expected-signoff "Færwell!" - ; [_ greeting _ error quit-message _ result prompt signoff] - ; (with-open [r (reader (string->stream (str "cons[A; B]\n" stop-word)))] - ; (binding [*in* r] - ; (split (with-out-str (-main "--read" "froboz")) #"\n")))] - ; (is (= greeting expected-greeting)) - ; (is (re-matches expected-error error)) - ; (is (re-matches expected-result result)) - ; (is (= quit-message expected-quit-message)) - ; (is (= prompt expected-prompt)) - ; (is (= signoff expected-signoff)) - ; )) - ; (testing "read - file found" - ; ;; TODO: there's no feedback from this because the initfile - ; ;; is not yet read. This will change - ; (let [expected-greeting "Hider wilcuman. Béowulf is mín nama." - ; expected-quit-message (str "Sprecan '" stop-word "' tó laéfan") - ; expected-error "" - ; expected-result #".*\(A \. B\)" - ; expected-prompt "Sprecan:: " - ; expected-signoff "Færwell!" - ; [_ greeting error quit-message _ _ result prompt signoff] - ; (with-open [r (reader (string->stream (str "cons[A; B]\n" stop-word)))] - ; (binding [*in* r] - ; (split (with-out-str (-main "--read" "README.md")) #"\n")))] - ; (is (= greeting expected-greeting)) - ; (is (= error expected-error)) - ; (is (re-matches expected-result result)) - ; (is (= quit-message expected-quit-message)) - ; (is (= prompt expected-prompt)) - ; (is (= signoff expected-signoff)) - ; )) - ; (testing "strict" - ; (let [expected-greeting "Hider wilcuman. Béowulf is mín nama." - ; expected-quit-message (str "Sprecan '" stop-word "' tó laéfan") - ; expected-error "" - ; expected-result #".*Cannot parse meta expressions in strict mode.*" - ; expected-prompt "Sprecan:: " - ; expected-signoff "Færwell!" - ; [_ greeting _ error quit-message _ result prompt signoff] - ; (with-open [r (reader (string->stream (str "cons[A; B]\n" stop-word)))] - ; (binding [*in* r] - ; (split (with-out-str (-main "--strict")) #"\n")))] - ; (is (= greeting expected-greeting)) - ; (is (= error expected-error)) - ; (is (re-matches expected-result result )) - ; (is (= quit-message expected-quit-message)) - ; (is (= prompt expected-prompt)) - ; (is (= signoff expected-signoff)) - ; )) - ; ; (testing "trace" - ; (let [expected-greeting "Hider wilcuman. Béowulf is mín nama." - ; expected-error "" - ; expected-trace #".*traced-eval.*" - ; [_ greeting _ error _ _ trace & _] - ; (with-open [r (reader (string->stream (str "cons[A; B]\n" stop-word)))] - ; (binding [*in* r] - ; (split (with-out-str (-main "--trace")) #"\n")))] - ; (is (= greeting expected-greeting)) - ; (is (= error expected-error)) - ; (is (re-matches expected-trace trace)) -) \ No newline at end of file + (is (= signoff expected-signoff)))) +;; ;; TODO: not working because STOP is not being recognised, but I haven't +;; ;; worked out why not yet. It *did* work. + +;; Hider wilcuman. Béowulf is mín nama. +;; -f FILEPATH, --file-path FILEPATH Set the path to the directory for reading and writing Lisp files. +;; -h, --help +;; -p PROMPT, --prompt PROMPT Sprecan:: Set the REPL prompt to PROMPT +;; -r SYSOUTFILE, --read SYSOUTFILE lisp1.5.lsp Read Lisp system from file SYSOUTFILE +;; -s, --strict Strictly interpret the Lisp 1.5 language, without extensions. +;; -t, --time Time evaluations. +;; -x, --testing Disable the jline reader - useful when piping input. +;; Sprecan 'STOP' tó laéfan + +;; Sprecan:: + + (testing "help" + (let [expected-greeting "Hider wilcuman. Béowulf is mín nama." + expected-h1 " -h, --help" + expected-quit-message (str "Sprecan '" stop-word "' tó laéfan") + expected-result #".*\(A \. B\)" + expected-prompt "Sprecan:: " + expected-signoff "Færwell!" + [_ greeting _ _ h1 _ _ _ _ _ quit-message _ result prompt signoff] + (with-open [r (reader (string->stream (str "cons[A; B]\n" stop-word)))] + (binding [*in* r] + (split (with-out-str (-main "--help" "--testing")) #"\n")))] + (is (= greeting expected-greeting)) + (is (= h1 expected-h1)) + (is (re-matches expected-result result)) + (is (= quit-message expected-quit-message)) + (is (starts-with? prompt expected-prompt)) + (is (= signoff expected-signoff)))) + (testing "prompt" + (let [expected-prompt "? " + [_ _ _ _ _ _ prompt _] + (with-open [r (reader (string->stream stop-word))] + (binding [*in* r] + (split (with-out-str (-main "--prompt" "?" "--testing")) #"\n")))] + (is (= prompt expected-prompt)))) + (testing "read - file not found" + (let [expected-error #"Failed to validate.*" + [_ _ _ error _ _ _ _ _] + (with-open [r (reader (string->stream (str "cons[A; B]\n" stop-word)))] + (binding [*in* r] + (split (with-out-str (-main "--testing" "--read" "froboz")) #"\n")))] + (is (re-matches expected-error error)))) + (testing "strict" + (let [expected-result #".*Cannot parse meta expressions in strict mode.*" + [_ _ _ _ _ _ result _ _] + (with-open [r (reader (string->stream (str "cons[A; B]\n" stop-word)))] + (binding [*in* r] + (split (with-out-str (-main "--strict" "--testing")) #"\n")))] + (is (re-matches expected-result result ))))) diff --git a/test/beowulf/host_test.clj b/test/beowulf/host_test.clj index 7e5e1ff..4d43b1e 100644 --- a/test/beowulf/host_test.clj +++ b/test/beowulf/host_test.clj @@ -1,38 +1,66 @@ (ns beowulf.host-test - (:require [clojure.test :refer [deftest is testing]] - [beowulf.cons-cell :refer [F make-beowulf-list T]] - [beowulf.host :refer [CDR DIFFERENCE NUMBERP PLUS RPLACA RPLACD TIMES]] - [beowulf.oblist :refer [NIL]] - [beowulf.read :refer [gsp]])) + (:require [beowulf.cons-cell :refer [F make-beowulf-list make-cons-cell T]] + [beowulf.host :refer [ADD1 AND CADDDR CAR CDR DEFINE DIFFERENCE + ERROR FIXP GREATERP lax? LESSP NILP NULL + NUMBERP OR PLUS RPLACA RPLACD SUB1 TIMES uaf]] + [beowulf.io :refer [SYSIN]] + [beowulf.oblist :refer [*options* NIL]] + [beowulf.read :refer [gsp]] + [clojure.test :refer [deftest is testing use-fixtures]] + [expectations.clojure.test + :refer [defexpect expect more-> more-of]])) + +(use-fixtures :once (fn [f] + (try (when (SYSIN "resources/lisp1.5.lsp") + (f)) + (catch Throwable any + (throw (ex-info "Failed to load Lisp sysout" + {:phase test + :function 'SYSIN + :file "resources/lisp1.5.lsp"} + any)))))) (deftest destructive-change-test (testing "RPLACA" (let - [l (make-beowulf-list '(A B C D E)) - target (CDR l) - expected "(A F C D E)" - actual (do (RPLACA target 'F) (print-str l))] + [l (make-beowulf-list '(A B C D E)) + target (CDR l) + expected "(A F C D E)" + actual (do (RPLACA target 'F) (print-str l))] (is (= actual expected))) (is (thrown-with-msg? - Exception - #"Un-ġefōg þing in RPLACA.*" - (RPLACA (make-beowulf-list '(A B C D E)) "F")) + Exception + #"Un-ġefōg þing in RPLACA.*" + (RPLACA (make-beowulf-list '(A B C D E)) "F")) "You can't represent a string in Lisp 1.5") (is (thrown-with-msg? - Exception - #"Uncynlic miercels in RPLACA.*" - (RPLACA '(A B C D E) 'F)) - "You can't RPLACA into anything which isn't a MutableSequence.") - ) - (testing "RPLACA" + Exception + #"Uncynlic miercels in RPLACA.*" + (RPLACA '(A B C D E) 'F)) + "You can't RPLACA into anything which isn't a MutableSequence.")) + (testing "RPLACD" (let - [l (make-beowulf-list '(A B C D E)) - target (CDR l) - expected "(A B . F)" - actual (do (RPLACD target 'F) (print-str l))] + [l (make-beowulf-list '(A B C D E)) + target (CDR l) + expected "(A B . F)" + actual (do (RPLACD target 'F) (print-str l))] (is (= actual expected))) - ) - ) + (let + [l (make-beowulf-list '(A B C D E)) + target (CDR l) + expected "(A B)" + actual (do (RPLACD target NIL) (print-str l))] + (is (= actual expected))) + (is (thrown-with-msg? + Exception + #"Un-ġefōg þing in RPLACD.*" + (RPLACD (make-beowulf-list '(A B C D E)) :a)) + "You can't represent a keyword in Lisp 1.5") + (is (thrown-with-msg? + Exception + #"Uncynlic miercels in RPLACD.*" + (RPLACD "ABCDE" 'F)) + "You can't RPLACD into anything which isn't a MutableSequence."))) (deftest numberp-tests (testing "NUMBERP" @@ -59,12 +87,171 @@ (let [expected 3.5 actual (PLUS 1.25 9/4)] (is (= actual expected)) + (is (float? actual))) + (let [expected 3.5 + actual (PLUS -2.5 6)] + (is (= actual expected) "Negative numbers are cool.") (is (float? actual)))) (testing "TIMES" (let [expected 6 actual (TIMES 2 3)] + (is (= actual expected))) + (let [expected 2.5 + actual (TIMES 5 0.5)] (is (= actual expected)))) - (testing DIFFERENCE + (testing "DIFFERENCE" (let [expected -1 actual (DIFFERENCE 1 2)] + (is (= actual expected))) + (let [expected (float 0.1) + actual (DIFFERENCE -0.1 -0.2)] + (is (= actual expected)))) + (testing "ADD1" + (let [expected -1 + actual (ADD1 -2)] + (is (= actual expected))) + (let [expected (float 3.5) + actual (ADD1 2.5)] + (is (= actual expected)))) + (testing "SUB1" + (let [expected -3 + actual (SUB1 -2)] + (is (= actual expected))) + (let [expected (float 1.5) + actual (SUB1 2.5)] (is (= actual expected))))) + +(deftest laxness + (testing "lax" + (let [expected true + actual (lax? 'Test)] + (is (= actual expected) "Pass, the Queen's Cat, and all's well"))) + (testing "strict" + (binding [*options* (assoc *options* :strict true)] + (is (thrown-with-msg? Exception #".*ne āfand innan Lisp 1.5" (lax? 'Test)))))) + +(deftest access-tests + (testing "primitive access" + (let [cell (make-cons-cell 1 7)] + (let [expected 1 + actual (CAR cell)] + (is (= actual expected))) + (let [expected 7 + actual (CDR cell)] + (is (= actual expected)))) + (is (thrown-with-msg? Exception #".*Ne can tace CAR of.*" (CAR 7))) + (is (thrown-with-msg? Exception #".*Ne can tace CDR of.*" (CDR 'A))) + (is (thrown-with-msg? Exception #".*Ne liste.*" (CADDDR "Foo"))) + (is (thrown-with-msg? Exception #".*uaf: unexpected letter in path.*" + (uaf (make-beowulf-list '(A B C D)) + '(\d \a \z \e \d)))))) + +(deftest misc-predicate-tests + (testing "NULL" + (let [expected T + actual (NULL NIL)] + (is (= actual expected))) + (let [expected F + actual (NULL (make-beowulf-list '(A B C)))] + (is (= actual expected)))) + (testing "NILP" + (let [expected T + actual (NILP NIL)] + (is (= actual expected))) + (let [expected NIL + actual (NILP (make-beowulf-list '(A B C)))] + (is (= actual expected)))) + (testing "AND" + (let [expected T + actual (AND)] + (is (= actual expected))) + (let [expected T + actual (AND T T)] + (is (= actual expected))) + (let [expected T + actual (AND T T T)] + (is (= actual expected))) + (let [expected T + actual (AND 1 'A (make-beowulf-list '(A B C)))] + (is (= actual expected))) + (let [expected F + actual (AND NIL)] + (is (= actual expected))) + (let [expected F + actual (AND T T F T)] + (is (= actual expected)))) + (testing "OR" + (let [expected F + actual (OR)] + (is (= actual expected))) + (let [expected T + actual (OR NIL T)] + (is (= actual expected))) + (let [expected T + actual (OR T F T)] + (is (= actual expected))) + (let [expected T + actual (OR 1 F (make-beowulf-list '(A B C)))] + (is (= actual expected))) + (let [expected F + actual (OR NIL)] + (is (= actual expected))) + (let [expected F + actual (OR NIL F)] + (is (= actual expected)))) + (testing "FIXP" + (let [expected F + actual (FIXP NIL)] + (is (= actual expected))) + (let [expected F + actual (FIXP 'A)] + (is (= actual expected))) + (let [expected F + actual (FIXP 3.2)] + (is (= actual expected))) + (let [expected T + actual (FIXP 7)] + (is (= actual expected)))) + (testing "LESSP" + (let [expected F + actual (LESSP 7 3)] + (is (= actual expected))) + (let [expected T + actual (LESSP -7 3.5)] + (is (= actual expected))) + (let [expected F + actual (LESSP 3.14 3.14)] + (is (= actual expected)))) + (testing "GREATERP" + (let [expected T + actual (GREATERP 7 3)] + (is (= actual expected))) + (let [expected F + actual (GREATERP -7 3.5)] + (is (= actual expected))) + (let [expected F + actual (GREATERP 3.14 3.14)] + (is (= actual expected))))) + +;; Really tricky to get DEFINE set up for testing here. It works OK in the +;; REPL, but there's nonsense going on with lazy sequences. Better to +;; reimplement in Lisp. +;; (deftest define-tests +;; (testing "DEFINE" +;; (let [expected "(FF)" +;; actual (str (doall (DEFINE +;; (gsp "((FF LAMBDA (X) (COND ((ATOM X) X) (T (FF (CAR X))))))"))))] +;; (is (= actual expected))))) + +(defexpect error-without-code + (expect (more-> clojure.lang.ExceptionInfo type + (more-of {:keys [:phase :function :args :type :code]} + 'A1 code) ex-data) + (ERROR))) + +(defexpect error-with-code + (let [x 'X1] + (expect (more-> clojure.lang.ExceptionInfo type + (more-of {:keys [:phase :function :args :type :code]} + x code) ex-data) + (ERROR x)))) diff --git a/test/beowulf/lisp_test.clj b/test/beowulf/lisp_test.clj index 7d9fa64..98bcc39 100644 --- a/test/beowulf/lisp_test.clj +++ b/test/beowulf/lisp_test.clj @@ -1,13 +1,13 @@ (ns beowulf.lisp-test "The idea here is to test actual Lisp functions" - (:require [clojure.test :refer [deftest testing is use-fixtures]] - [beowulf.bootstrap :refer [EVAL]] + (:require [beowulf.bootstrap :refer [EVAL]] [beowulf.cons-cell :refer [make-beowulf-list]] - [beowulf.io :refer [SYSIN]] - ;; [beowulf.oblist :refer [NIL]] - [beowulf.read :refer [READ]])) + [beowulf.io :refer [SYSIN]] ;; [beowulf.oblist :refer [NIL]] + [beowulf.oblist :refer [NIL]] + [beowulf.read :refer [READ]] + [clojure.test :refer [deftest is testing use-fixtures]])) -(defn- reps +(defn reps "'Read eval print string', or 'read eval print single'. Reads and evaluates one input string, and returns the output string." @@ -130,7 +130,6 @@ actual (reps input)] (is (= actual expected)))))) - (deftest MEMBER-tests (testing "member" (let [expected "T" @@ -147,17 +146,18 @@ (is (= actual expected))))) ;; This is failing, and although yes, it does matter, I have not yet tracked the reason. -;; (deftest sublis-tests -;; (testing "sublis" -;; (let [expected "(SHAKESPEARE WROTE (THE TEMPEST))" -;; actual (reps -;; "(SUBLIS -;; '((X . SHAKESPEARE) (Y . (THE TEMPEST))) -;; '(X WROTE Y))")] -;; (is (= actual expected))))) +(deftest sublis-tests + (testing "sublis" + (let [expected "(SHAKESPEARE WROTE (THE TEMPEST))" + actual (reps + "(SUBLIS + '((X . SHAKESPEARE) (Y . (THE TEMPEST))) + '(X WROTE Y))")] + (is (= actual expected))))) (deftest prog-tests (testing "PROG" + ;; (reps "(TRACE 'PROG)") (let [expected "5" actual (reps "(PROG (X) (SETQ X 1) @@ -165,4 +165,61 @@ (SETQ X (ADD1 X)) (COND ((EQ X 5) (RETURN X)) (T (GO START))))")] + (is (= actual expected))))) + +(deftest put-get-tests + (let [symbol 'TESTSYMBOL + p1 'TESTPROPONE + p2 'TESTPROPTWO] + (testing "GET - property should be missing" + (let [expected "NIL" + actual (reps "(GET 'TESTSYMBOL 'TESTPROPONE)")] + (is (= actual expected)))) + (testing "PUT and GET: value of new property; change value of property" + (let [prop (reps "(GENSYM)") + val1 (reps "(GENSYM)") + val2 (reps "(GENSYM)") + expected1 val1 + actual1 (when (reps (str "(PUT '" symbol " '" prop " '" val1 ")")) + (reps (str "(GET '" symbol " '" prop ")"))) + expected2 val2 + actual2 (when (reps (str "(PUT '" symbol " '" prop " '" val2 ")")) + (reps (str "(GET '" symbol " '" prop ")")))] + (is (not= val1 val2)) + (is (= actual1 expected1) "The value set can be retrieved.") + (is (= actual2 expected2) "The value is changed."))) + (testing "PUT and GET: different properties have independent values" + (let [val1 (reps "(GENSYM)") + val2 (reps "(GENSYM)") + expected1 val1 + actual1 (when (reps (str "(PUT '" symbol " '" p1 " '" val1 ")")) + (reps (str "(GET '" symbol " '" p1 ")"))) + expected2 val2 + actual2 (when (reps (str "(PUT '" symbol " '" p2 " '" val2 ")")) + (reps (str "(GET '" symbol " '" p2 ")"))) + expected3 val1 + actual3 (reps (str "(GET '" symbol " '" p1 ")"))] + (is (not= val1 val2)) + (is (= actual1 expected1) "The value set can be retrieved.") + (is (= actual2 expected2) "Values are independent.") + (is (= actual3 expected3) "Setting a second property does not obliterate the first."))))) + +(deftest fsubr-tests + (testing "FSUBR/CONC" + (reps "(SETQ P (RANGE 1 4))") + (reps "(SETQ Q (RANGE 5 8))") + (reps "(SETQ R (RANGE 9 12))") + (let [expected "(1 2 3 4 5 6 7 8 9 10 11 12)" + actual (reps "(CONC P Q R)")] + (is (= actual expected))))) + +(deftest attrib-tests + (testing "ATTRIB" + (reps "(SETQ X '(A B C))") + (reps "(SETQ Y '(D E F))") + (let [expected "(D E F)" + actual (reps "(ATTRIB X Y)")] + (is (= actual expected))) + (let [expected "(A B C D E F)" + actual (reps "X")] (is (= actual expected))))) \ No newline at end of file