diff --git a/README.md b/README.md index 364cfe3..01ccc85 100644 --- a/README.md +++ b/README.md @@ -338,7 +338,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/docs/codox/beowulf.bootstrap.html b/docs/codox/beowulf.bootstrap.html index eaa1806..ffcf6bb 100644 --- a/docs/codox/beowulf.bootstrap.html +++ b/docs/codox/beowulf.bootstrap.html @@ -1,13 +1,15 @@ -beowulf.bootstrap documentation

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..

+beowulf.bootstrap documentation

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.

+

*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.

+

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.

-

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.

+

apply-label

(apply-label function args environment depth)

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

+

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.

-

find-target

TODO: write docs

-

PROG

(PROG program env depth)

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

+

find-target

TODO: write docs

+

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.

@@ -19,6 +21,10 @@

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.

-

prog-eval

(prog-eval expr vars env depth)

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

-

try-resolve-subroutine

(try-resolve-subroutine subr args)

Attempt to resolve this subr with these args.

-
\ No newline at end of file +

prog-eval

(prog-eval expr vars env depth)

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

+

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.’

+

try-resolve-subroutine

(try-resolve-subroutine subr args)

Attempt to resolve this subr with these args.

+

value

(value s)(value s indicators)

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

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

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.

+beowulf.cons-cell documentation

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?

F

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

make-beowulf-list

(make-beowulf-list x)

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

diff --git a/docs/codox/beowulf.core.html b/docs/codox/beowulf.core.html index f796bb3..fe738c1 100644 --- a/docs/codox/beowulf.core.html +++ b/docs/codox/beowulf.core.html @@ -1,6 +1,6 @@ -beowulf.core documentation

beowulf.core

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

+beowulf.core documentation

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.

cli-options

TODO: write docs

repl

(repl prompt)

Read/eval/print loop.

diff --git a/docs/codox/beowulf.gendoc.html b/docs/codox/beowulf.gendoc.html index c40564c..2414d81 100644 --- a/docs/codox/beowulf.gendoc.html +++ b/docs/codox/beowulf.gendoc.html @@ -1,6 +1,6 @@ -beowulf.gendoc documentation

beowulf.gendoc

Generate table of documentation of Lisp symbols and functions.

+beowulf.gendoc documentation

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.

gen-doc-table

(gen-doc-table)

TODO: write docs

diff --git a/docs/codox/beowulf.host.html b/docs/codox/beowulf.host.html index 0a9aadc..1b803cc 100644 --- a/docs/codox/beowulf.host.html +++ b/docs/codox/beowulf.host.html @@ -1,6 +1,6 @@ -beowulf.host documentation

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.

+beowulf.host documentation

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

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.

@@ -9,7 +9,13 @@

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

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.

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.

-

CAAAAR

macro

(CAAAAR x)

TODO: write docs

+

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.

+

CAAAAR

macro

(CAAAAR x)

TODO: write docs

CAAADR

macro

(CAAADR x)

TODO: write docs

CAAAR

macro

(CAAAR x)

TODO: write docs

CAADAR

macro

(CAADAR x)

TODO: write docs

@@ -42,13 +48,13 @@

CONS

(CONS car cdr)

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

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.

-

DEFINE

(DEFINE a-list)

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

+

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.

-

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.

-

DIFFERENCE

(DIFFERENCE x y)

TODO: write docs

+

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.

+

DIFFERENCE

(DIFFERENCE x y)

TODO: write docs

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.

-

EQ

(EQ x y)

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

+

EQ

(EQ x y)

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

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

ERROR

(ERROR & args)

Throw an error

@@ -58,7 +64,7 @@

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

(GREATERP x y)

TODO: write docs

+

GREATERP

(GREATERP x y)

TODO: write docs

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.

lax?

(lax? symbol)

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

@@ -79,16 +85,16 @@

PLUS

(PLUS & args)

TODO: write docs

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.

-

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.

+

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.

REMAINDER

(REMAINDER x y)

TODO: write docs

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)

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)

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!

-

SUB1

(SUB1 x)

TODO: write docs

+

SUB1

(SUB1 x)

TODO: write docs

TIMES

(TIMES & args)

TODO: write docs

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.

-

traced-symbols

Symbols currently being traced.

-

traced?

(traced? s)

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

-

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

+

traced-symbols

Symbols currently being traced.

+

traced?

(traced? s)

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

+

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

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.

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

beowulf.interop

TODO: write docs

+beowulf.interop documentation

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. diff --git a/docs/codox/beowulf.io.html b/docs/codox/beowulf.io.html index c87c07b..b0aa1ea 100644 --- a/docs/codox/beowulf.io.html +++ b/docs/codox/beowulf.io.html @@ -1,19 +1,19 @@ -beowulf.io documentation

    beowulf.io

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

    +beowulf.io documentation

    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.

    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

    resolve-subr

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

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

    -

    safely-wrap-subr

    (safely-wrap-subr entry)

    TODO: write docs

    +

    safely-wrap-subr

    (safely-wrap-subr entry)

    TODO: write docs

    safely-wrap-subrs

    (safely-wrap-subrs objects)

    TODO: write docs

    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.

    -

    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.

    +

    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.

    \ No newline at end of file diff --git a/docs/codox/beowulf.manual.html b/docs/codox/beowulf.manual.html index 3631591..b38f14c 100644 --- a/docs/codox/beowulf.manual.html +++ b/docs/codox/beowulf.manual.html @@ -1,6 +1,6 @@ -beowulf.manual documentation

    beowulf.manual

    Experimental code for accessing the manual online.

    +beowulf.manual documentation

    beowulf.manual

    Experimental code for accessing the manual online.

    *manual-url*

    dynamic

    TODO: write docs

    format-page-references

    (format-page-references fn-symbol)

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

    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.

    diff --git a/docs/codox/beowulf.oblist.html b/docs/codox/beowulf.oblist.html index 155a64b..a468d75 100644 --- a/docs/codox/beowulf.oblist.html +++ b/docs/codox/beowulf.oblist.html @@ -1,6 +1,6 @@ -beowulf.oblist documentation

    beowulf.oblist

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

    +beowulf.oblist documentation

    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.

    NIL

    The canonical empty list symbol.

    diff --git a/docs/codox/beowulf.read.html b/docs/codox/beowulf.read.html index bd83a97..0e9c56b 100644 --- a/docs/codox/beowulf.read.html +++ b/docs/codox/beowulf.read.html @@ -1,6 +1,6 @@ -beowulf.read documentation

    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

    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. diff --git a/docs/codox/beowulf.reader.char-reader.html b/docs/codox/beowulf.reader.char-reader.html index 9ef00d6..d5a0f22 100644 --- a/docs/codox/beowulf.reader.char-reader.html +++ b/docs/codox/beowulf.reader.char-reader.html @@ -1,6 +1,6 @@ -beowulf.reader.char-reader documentation

      beowulf.reader.char-reader

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

      +beowulf.reader.char-reader documentation

      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)

        diff --git a/docs/codox/beowulf.reader.generate.html b/docs/codox/beowulf.reader.generate.html index 417a91e..0325184 100644 --- a/docs/codox/beowulf.reader.generate.html +++ b/docs/codox/beowulf.reader.generate.html @@ -1,6 +1,6 @@ -beowulf.reader.generate documentation

        beowulf.reader.generate

        Generating S-Expressions from parse trees.

        +beowulf.reader.generate documentation

        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:

        diff --git a/docs/codox/beowulf.reader.macros.html b/docs/codox/beowulf.reader.macros.html index 5c9d10c..4cd6085 100644 --- a/docs/codox/beowulf.reader.macros.html +++ b/docs/codox/beowulf.reader.macros.html @@ -1,6 +1,6 @@ -beowulf.reader.macros documentation

        beowulf.reader.macros

        Can I implement reader macros? let’s see!

        +beowulf.reader.macros documentation

        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

        diff --git a/docs/codox/beowulf.reader.parser.html b/docs/codox/beowulf.reader.parser.html index c4a43f0..128d2ee 100644 --- a/docs/codox/beowulf.reader.parser.html +++ b/docs/codox/beowulf.reader.parser.html @@ -1,5 +1,5 @@ -beowulf.reader.parser documentation

        beowulf.reader.parser

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

        +beowulf.reader.parser documentation

        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.

        \ No newline at end of file diff --git a/docs/codox/beowulf.reader.simplify.html b/docs/codox/beowulf.reader.simplify.html index 2b3f8ba..f2176ef 100644 --- a/docs/codox/beowulf.reader.simplify.html +++ b/docs/codox/beowulf.reader.simplify.html @@ -1,6 +1,6 @@ -beowulf.reader.simplify documentation

        beowulf.reader.simplify

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

        +beowulf.reader.simplify documentation

        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

        remove-optional-space

        (remove-optional-space tree)

        TODO: write docs

        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.

        diff --git a/docs/codox/further_reading.html b/docs/codox/further_reading.html index d2d3a62..236e98a 100644 --- a/docs/codox/further_reading.html +++ b/docs/codox/further_reading.html @@ -1,6 +1,6 @@ -Further Reading

        Further Reading

        +Further Reading

        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. 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. diff --git a/docs/codox/index.html b/docs/codox/index.html index f1b6eac..bd07442 100644 --- a/docs/codox/index.html +++ b/docs/codox/index.html @@ -1,11 +1,11 @@ -Beowulf 0.3.1-SNAPSHOT

          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.

          +Beowulf 0.3.1-SNAPSHOT

          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..

          +

          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.

          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.

          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.

          -

          beowulf.io

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

          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.

          @@ -15,5 +15,4 @@

          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.

          -

          beowulf.scratch

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

          -

          Public variables and functions:

          \ No newline at end of file +
          \ No newline at end of file diff --git a/docs/codox/intro.html b/docs/codox/intro.html index 5aea87d..e520149 100644 --- a/docs/codox/intro.html +++ b/docs/codox/intro.html @@ -1,6 +1,6 @@ -beowulf

          beowulf

          +beowulf

          beowulf

          Þý liste cræfte spræc

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

          Beowulf logo

          @@ -236,7 +236,7 @@

          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.

          +

          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 16334dd..376a85c 100644 --- a/docs/codox/mexpr.html +++ b/docs/codox/mexpr.html @@ -1,6 +1,6 @@ -Interpreting M-Expressions

          Interpreting M-Expressions

          +Interpreting M-Expressions

          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.

          diff --git a/docs/codox/values.html b/docs/codox/values.html index d156cd7..70fc1ef 100644 --- a/docs/codox/values.html +++ b/docs/codox/values.html @@ -1,6 +1,6 @@ -The properties of the system, and their values

          The properties of the system, and their values

          +The properties of the system, and their values

          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?