HELP LISPNEWS

Prolog users    : also see HELP * PLOGNEWS
Pop-11 users    : also see HELP * NEWS
ML users        : also see HELP * PMLNEWS

Note:
News items relating to the Steele 1990 Common Lisp standard are flagged
with # instead of --.

------------------------------------------------------------------------

1997

Feb 20 (John Williams)
    -- The use of Pop-11 section pathnames in the names of symbols
    in the pop11 package is now supported, e.g.

        pop11:$-lisp$-make_stream

    creates a symbol named "$-LISP$-MAKE_STREAM" whose value cell is
    the same as that of the Pop-11 word "make_stream" in the section
    named "lisp".


1996

Sep 5 (John Williams)
    -- Compiler macros for plusp, minusp, oddp, and evenp implemented.


1995

Nov 30 (John Williams)
    # The pretty printing facilities described in Chapter 27 of Steele
    2nd Edition (1990) are now implemented. In particular, the following
    functions, macros and variables are now available:

        pprint-fill         pprint-linear       pprint-tabular
        pprint-newline      pprint-indent       pprint-tab
        pprint-logical-block
        pprint-pop          pprint-exit-if-list-exhausted
        pprint-dispatch     set-pprint-dispatch
        *print-lines*       *print-miser-width*

        formatter
        format directives: ~W, ~_, ~I, ~:T, ~<str~:>, and ~/name/

    See Steele 1990 Chapter 27 for full details.

Aug 25 (John Williams)
    -- Two long-standing bugs have been fixed: the format directive ~E
    is now sensitive to the value of *read-default-float-format*, and
    peek-char & unread-char operate correctly on echo streams (and
    composite streams that include an echo steam as a component).

*** Poplog 15.0 (Lisp 2.0) released for beta testing ***

July 6 (John Williams)
    -- New module SEQUENCE-COMPILER-MACROS added, which defines compiler
    macros for some sequence functions. The code generated by these
    compiler macros executes roughly twice as fast as the standard
    functions. See HELP * SEQUENCE-COMPILER-MACROS for details.

Jun 13 (John Williams)
    -- The optimisations previously performed only when setf was
    declared inline are now performed automatically by the setf macro.
    The same applies to psetf.

    -- The compiler now plants more efficient code for calls to
    concatenate when the result-type argument is known at compile time.

Jun 8 (John Williams)
    -- New Ved commands for macro expanding (<ENTER> mx) and compiler
    macro expanding (<ENTER> cmx) the Lisp form under the cursor have
    been added. See HELP * LISPVED.

Jun 6 (John Williams)
    # The function function-lambda-expression is now available. Function
    defining forms such as defun, defmacro and defsetf will save the
    lambda expression if the declaration (optimize (debug 3)) is in
    force. disassemble will make use of saved lambda expressions where
    possible.

    # load-time-value, make-load-form-saving-slots, and make-load-form
    are now implemented.

May 15 (John Williams)
    # The complete loop macro, as described in Steele 2nd Edition (1990)
    Chapter 26, is now available.

    Please note: The implementation of loop supplied with Poplog is a
    public-domain implementation produced by Symbolics Inc. obtained via
    ftp from the CMU Artificial Intelligence Repository
        (http://www.cs.cmu.edu:8001/Web/Groups/AI/html/repository.html).

    The Loop code is Copyright (c) 1986 by the Massachusetts Institute
    of Technology, and Copyright (c) 1989, 1990, 1991, 1992 by
    Symbolics, Inc.


Apr 20 (John Williams)
    # Poplog Common Lisp's handling of Streams, Pathnames, and
    Readtables has been upgraded to the Steele 2nd Edition (1990)
    standard. Please see Chapters 21, 22, and 23 of this book for full
    details of the changes.

    # Most of the errors signaled by Poplog Common Lisp are now
    specialised error conditions, e.g. program-error, control-error,
    type-error, etc.

Mar 15 (John Williams)
    # Some Poplog-specific condition types have been added:
      poplog:mishap, poplog:unbound-slot, poplog:missing-slot,
      poplog:redefine-error, poplog:bad-name-error, and
      poplog:warning-with-involving.

Mar 3 (John Williams)
    # New documentation file REF * CONDITIONS added. This briefly
    describes the functions, macros and variables that implement the
    Condition System.

Feb 28 (John Williams)
    -- REF * POPLOG_ONLY updated.

Feb 27 (John Williams)
    # The Condition System as discussed in Steele 2nd Edition,
    Chapter 29 is now implemented. All the new data-types, functions,
    macros and variables listed in this chapter are available. Please
    note, however, that currently only the purpose-built error checking
    macros ecase, etypecase, ccase, ctypecase, check-type, and assert
    signal `specialised' error conditions - the existing calls to error,
    cerror and warn in the system all just signal conditions of type
    simple-error or simple-warning. This will be rectified in future
    versions of Poplog Common Lisp.

    # Two new debugger commands have been added:

        :l      List available restarts
        :ic     Inspect the condition on which the debugger was invoked

    See HELP * DEBUG and HELP * BREAK for more details.

    # Two new variables have been added to the Poplog package:

      *debugger-condition*
        This is bound by INVOKE-DEBUGGER to the condition on which the
        debugger was invoked.

      *interrupt*
        When a keyboard interrupt occurs (usually as a result of typing
        CTRL-C), the value of this variable, which should be a function
        of zero arguments, is applied. The initial value of *interrupt*
        is a function that enters the Lisp debugger, with a continue
        restart available for resuming the interrupted computation.


Feb 10 (John Williams)
    -- CLX 5.02 is now available in the CLX module. See HELP * CLX
    for details.


1994
Dec 16 (John Williams)
    -- The #n= and #n# reader macros can now be used within the #S
    syntax for reading structures.

    -- Some long-standing (and extremely irritating) bugs in the format
    directives ~A, ~S, ~(, and ~< have now been fixed.

Aug 25 (John Williams)
    # Lisp version 1.6: Four more areas of Poplog Common Lisp have now
    been upgraded to the Steele 1990 standard: Program Structure,
    Control Structure, Macros, and Declarations (Steele 1990 chapters 5,
    7, 8, and 9 respectively). The principal changes are:

    Program Structure

      # Reading an unbound variable or function causes an error to be
        signaled if the declaration (optimize (safety 3)) was in force
        when the reference was compiled.

      # Defining forms like defun, defmacro, defsetf, etc. are now
        handled correctly if encountered not at top level.

      # defun now recognises generalised function names, e.g.
                (defun (setf cadr) ...)

      # eval-when now recognises the new situation specifiers
            :execute, :compile-toplevel, and :load-toplevel.

    Control Structure

      # setf, psetf, shiftf, and rotatef can now handle place forms
        whose setf method has more than one store variable.

      # A setf method for values is now implemented.

      # get-setf-method and get-setf-method-multiple-value now accept a
        second (optional) argument - a lexical environment object which
        defaults to nil (the null lexical environment).

      # The bodies of functions defined with flet, labels, and macrolet
        are now enclosed in a block whose name is the same as that of
        the function. Also, flet, labels, and macrolet now permit
        declarations before the main body of the construct.

    Macros

      # The function macro-function now accepts a second (optional)
        argument - a lexical environment object which defaults to nil
        (the null lexical environment).

      # The function macroexpand-1 will now expand symbol macros.

      # The macro destructuring-bind is now available (and defmacro has
        been re-implemented using it).

      # Compiler macros are now implemented, and the functions

            define-compiler-macro, compiler-macro-function,
            compiler-macroexpand-1, compiler-macroexpand,

        are now available. Some built-in Lisp functions and macros have
        compiler macro definitions - see HELP * INLINE.

    Declarations

      (see HELP * DECLARE for full details).

      # The macro declaim is now available. Also, locally is now
        implemented as a special-form (previously it was a macro).

      # The scope of `bound declarations' no longer includes the
        initialisation forms for the variables or function names being
        bound.

      # New interpretation for the function declaration - this now
        declares that the values of the variables named in the
        declaration must be of type function. Poplog will plant
        optimised code if a variable so declared is given as the
        function argument to funcall, apply, or multiple-value-call.

      # A new optimize context, debug, is now recognised. If set to 3
        (the maximum), lexical variable bindings are visible to the
        debugger.

      # The dynamic-extent declaration is now available (but only acted
        upon for &rest parameter names).

    For full details of these changes, see Steele 1990.


Jul 26 (John Williams)
    # In accordance with Steele 1990, p189-92, the special form throw
    now `abandons' catchers intervening between the call to throw and
    the target call to catch. This means that an error will be signaled
    if, during a call to throw, another call to throw occurs which
    refers to a more recently established catcher than the one specified
    by the first call to throw.

    Here is an example of a procedure that calls throw on its argument
    whilst already executing a throw to a catcher named beta:

        (defun test (x)
            (catch 'alpha
                (catch 'beta
                    (catch 'gamma
                        (unwind-protect
                            (throw 'beta nil)   ; protected form
                            (throw x t))))))    ; clean-up form

    The following calls to test are legal:

        (test 'alpha)
        (test 'beta)

    because it's ok to throw a second time to the same catcher (beta) or
    to throw to an earlier catcher (alpha). However, the call:

        (test 'gamma)

    will produce an error. The rationale for this is that it should not
    be possible for a call to throw, once started, to be `hi-jacked' by
    an unwind-protect clean-up form that does a throw to an intervening
    catcher.

    # The restriction on throw described in the previous news item also
    applies to return-from, i.e. the compiler will signal an error if it
    encounters a recursive call to return-from that refers to a block
    intervening between the outer call to return-from and its target
    block. See Steele 1990 p189-92 for full details.


Jun 10 (John Williams)
    # Poplog Common Lisp's implementation of defstruct has been upgraded
    to the Steele 1990 standard. In particular, the following changes
    have been made:

        # It is now possible to define structures with no slots.

        # An error will be signaled if two slots in the same structure
        have equal print names.

        # Slot init forms are now evaluated each time they are needed,
        in the lexical context in which the defstruct form appeared.

        # &key parameters and the lambda-list keyword &allow-other-keys
        are now permitted in BOA constructor function lambda-lists.

        # The print function for structures defined with the :include
        option is now inherited from the included structure type, unless
        the option (:print-function) is specified, in which case the
        default structure printing routine will be used.


Apr 28 (John Williams)
    # Poplog Common Lisp now includes an almost complete implementation
    of CLOS (the Common Lisp Object System) as discussed in Steele 1990,
    Chapter 28. The main omission is that currently only standard method
    combination is supported.

    # Generalised function names (symbols or lists starting with setf)
    are now recogised by the functions documentation, funcall, apply,
    fboundp, fmakunbound and fdefinition; the macros trace and untrace;
    the special-form function; and the declarations inline and
    notinline. They are not yet recognised by defun or ed.

    # Symbol macros (as discussed in Steele 1990 p155-6) are now
    implemented, via the special form symbol-macrolet. The special-form
    compiler-let, which is obsoleted in Steele 1990, has been withdrawn.

    # The macro nth-value (Steele 1990, p184) is now available.

    # Poplog's handling of predicates (as discussed in Steele Chapter 6)
    has been upgraded to the 1990 standard. Functions affected are
    typep, subtypep, functionp, realp (added), and commonp (deleted).
    Also, equalp can now be used to compare hash tables, and equal no
    longer recursively descends structures created via defstruct.

    # The new character and string type specifiers defined in Chapter 4
    of Steele 1990 are now supported. These are:

        base-character
        extended-character
        base-string
        simple-base-string

    Also, the type specifiers real and eql are now available, and the
    type common has been removed. The type string-char has been retained
    (as a synonym for character) for the benefit of existing programs.

    In anticipation of ANSI Common Lisp, the types base-char and
    extended-char, and the compound form of the cons type specifier, are
    also available.

    # Added upgraded-array-element-type and upgraded-complex-part-type
    (Steele 1990 p68).


Apr 27 (John Williams)

    -- Some improvements to programming and debugging tools:

        # It is now possible to include a documentation string in a
        lambda expression. This can be retrieved by applying
        documentation to the function object produced from the lambda
        expression.

        # The function ed can now be used to locate the source code for
        classes defined with declass, type specifiers defined with
        deftype, global special variables defined with defvar or
        defparameter, generic functions defined with defgeneric, and
        methods defined with defmethod.

    -- Some bug fixes:

        # defstruct now copes properly when the name of an accessor
        function (as specified by the :conc-name option) is identical to
        the name of an accessor function of an included type. Previously
        the later more specific accessor function would overwrite the
        earlier more general one.

        # The reader macros #+ and #- now behave correctly if nested (or
        called when *read-suppress* is true).

        # (eval-when (load) forms) now operates correctly (i.e. the
        forms are evaluated by Poplog's incremental compiler).

        # Spurious "Undefined variable" messages produced when a symbol
        is declared special with declare (not proclaim) are no longer
        produced.

        # make-array now correctly interprets the element type specifier
        float as meaning "make an array that can contain any kind of
        float". Previously it took float as a synonym for single-float.

        # A bug in typep's handling of the or type specifier has been
        fixed. (The first type specifier after the or was being
        ignored).

        # subtypep now handles not type specifiers correctly.

        # Obscure bug in decode-universal-time fixed (with help from
        Steve Knight).


Jan 18 (John Williams)
    # Bug in gensym fixed: it now always increments *gensym-counter*
    unless given an integer as argument.


1993

Dec 23 (John Williams)
    # Poplog Common Lisp's treatment of hash tables (as discussed in
    Steele Chapter 15) has been upgraded to the 1990 standard. In
    particular, it is now possible to construct equalp hash tables; and
    the accessor functions hash-table-size, hash-table-rehash-size,
    hash-table-rehash-threshold and hash-table-test are now available.

Dec 9 (John Williams)
    # The macros with-package-iterator and with-hashtable-iterator
    are now implemented (as described in Steele 1990 p275 and 439
    respectively).

Dec 1  (John Williams)
    -- Poplog 14.5 ready for testing.

Nov 30 (John Williams)
    # The DEFPACKAGE macro (as described in Steele 1990 p270) is now
    implemented.

    # GET-SETF-METHOD (and hence SETF, PSETF, etc) can now deal with
    forward references to SETF methods (as discussed in Steele 1990,
    p128).

    -- The backquote reader macro now copies the list it reads in
    (previously it modified the list destructively).

    -- Compiler bug fix: references to functions that have been declared
    notinline but not yet defined (via DEFUN, LABELS, FLET, etc) are now
    treated correctly.

    -- The :b debugger option can now be given an integer argument which
    specifies how many call stack frames should be displayed. This is
    particularly useful if a BREAK occurs deep inside recursion.

Nov 2  (John Williams)
    -- The special variable *PACKAGE* now checks, when assigned to, that
    its new value is indeed a package object. If a package name is
    supplied, it is translated to a package object using FIND-PACKAGE.

    (Note: type check on assignment is implemented via the Poplog active
    variable facilty, documented in HELP * ACTIVE_VARIABLES).

Oct 25 (John Williams)
    # The function SHADOW now accepts strings as well as symbols (as per
    Steele 1990 p269).

Sep 1  (John Williams)
    -- Calls to the functions +, -, <, /, LOGAND, LOGEQV, LOGIOR,
    LOGXOR, LIST, LIST*, APPEND, and NCONC will no longer be expanded
    inline if the declaration (DECLARE (OPTIMIZE SPACE)) is in force.

    -- The function SORT now runs between 6 and 8 times faster for
    a few commonly used predicates. These are:

        <, <=, >, >=
            (for any type of sequence)

        CHAR<, CHAR<=, CHAR>, CHAR>=
            (if the sequence to be sorted is a string)

    Note that this optimisation is only possible if the :KEY argument to
    SORT is unspecified).

    -- STABLE-SORT also optimises if the predicate is either <= or >=
    (for any type of sequence), or one of CHAR<= and CHAR>= (if the
    sequence to be sorted is a string).

Aug 31 (John Williams)
    # Poplog Common Lisp's handling of strings (as discussed in Steele
    Chapter 18) has been upgraded to the 1990 standard. As a result, it
    is no longer possible to pass a symbol or character to the functions
    NSTRING-UPCASE, NSTRING-DOWNCASE, and NSTRING-CAPITALIZE.

Aug 27 (John Williams)
    # Poplog Common Lisp's handling of sequences (as discussed in Steele
    Chapter 14) has been upgraded to the 1990 standard. The following
    specific changes have been made:

    # New functions MAP-INTO and COMPLEMENT added.

    # The function REDUCE can now be passed a :KEY keyword argument.

    # The function MAKE-SEQUENCE now signals an error if the type
    specifier for the result sequence includes an explicit size
    specification which is not equal to the size of the sequence being
    built.

    # The treatment of the :COUNT and :END parameters to sequence
    functions has been standardised. Negative values for :COUNT are now
    considered equivalent to 0 (in which case no processing of the
    sequence takes place). Also, it is now possible to supply the value
    NIL explicitly for the :END parameter, in which case the length of
    the sequence to be processed is used instead.

Aug 27 (John Williams)
    # Poplog Common Lisp's handling of lists (as discussed in Steele
    Chapter 15) has been upgraded to the 1990 standard. In particular,
    the functions

        ASSOC-IF, ASSOC-IF-NOT, RASSOC-IF, RASSOC-IF-NOT

    can now be passed a :KEY keyword argument, and the function LAST now
    takes a second (optional) argument. See REF * LISTS for details.

Aug 27 (John Williams)
    # Poplog Common Lisp's handling of character objects (as discussed
    in Steele Chapter 13) has been upgraded to the 1990 standard. In
    particular, the variables

        CHAR-BITS-LIMIT, CHAR-FONT-LIMIT,
        CHAR-CONTROL-BIT, CHAR-HYPER-BIT, CHAR-META-BIT, CHAR-SUPER-BIT

    and functions

        CHAR-BIT, CHAR-BITS, CHAR-FONT, INT-CHAR, MAKE-CHAR,
        SET-CHAR-BIT

    have been withdrawn. Also, the function CODE-CHAR now takes just one
    argument (a character code), and the function DIGIT-CHAR can no
    longer be passed an optional <font> argument.

Aug 27 (John Williams)
    Various performance enhancements:

    -- The functions listed below no longer construct a list containing
    their arguments:

        *, +, -, /, <, <=, =, >, >=, MAX, MIN,
        CHAR<, CHAR<=, CHAR=, CHAR>, CHAR-EQUAL,
        CHAR-GREATERP, CHAR-LESSP, CHAR-NOT-GREATERP, CHAR-NOT-LESSP,
        APPEND, NCONC.

    Timings suggest that these functions now run between 3 and 5 times
    quicker. In addition, of course, they no longer create unnecessary
    garbage.

    -- The functions COPY-LIST and COPY-ALIST now use iterative
    algorithms, and run approx. 30% quicker.

    -- The function RASSOC is now compiled inline (by default) if called
    with two arguments.

    -- The functions CHAR<, CHAR<=, CHAR=, CHAR>, and CHAR>= can now
    be compiled inline. See HELP * INLINE.

Aug 23 (John Williams)
    -- A serious bug in the enhanced version of the TIME macro provided
    by the STOREUTILS module has been fixed. (It used to generate an
    "Applying undefined function SYSTEM::TIME" error).

Aug 11 (John Williams)
    # Lisp version number increased from 1.4 to 1.5.

    # The #+ and #- read macros now bind *PACKAGE* to the keyword
    package when reading a feature specification. Also, the members of
    the *FEATURES* list are now all keywords, and include several new
    symbols describing the kind of machine Poplog is running on. See
    HELP * FEATURES for details.

    # The #p reader syntax for pathnames is now implemented. This
    notation is also used for printing pathnames.

    # The #. read macro is now sensitive to the value of *READ-EVAL*.
    The #, read macro has been withdrawn.

    # New variable *GENSYM-COUNTER* introduced. Also, the behaviour
    of GENSYM upgraded to the Steele 1990 standard.

July 29 (John Williams)
    -- Fixed bug in STABLE-SORT.

July 27 (John Williams)
    -- Fixed a serious bug in the SETF method for ELT, which stopped it
    working for adjustable, displaced or fill-pointed array sequences.

Jun 21 (John Williams)
    -- The Poplog-specific print control variables, namely

        *ERROR-PRINT-LENGTH*
        *ERROR-PRINT-LEVEL*
        *TRACE-PRINT-LENGTH*
        *TRACE-PRINT-LEVEL*
        *INSPECT-PRINT-LENGTH*
        *INSPECT-PRINT-LEVEL*

    can now be "disabled" by being given the value :IGNORE. See
    REF * POPLOG_ONLY.

Jun 17 (John Williams)
    -- New variables *ERROR-PRINT-LENGTH* and *ERROR-PRINT-LEVEL*
    introduced. They are assigned to *PRINT-LENGTH* and *PRINT-LEVEL*
    respectively by ERROR, CERROR, and WARN. (Previously, specific
    values for *PRINT-LENGTH* and *PRINT-LEVEL* were hard-coded into
    ERROR). See REF * POPLOG_ONLY.

Jan 7 (John Williams)
    -- Documentation for *LISPFILETYPES* added to REF * POPLOG_ONLY and
    HELP * LISPVED.


1992
Jul 31 (John Williams/Stephen Silver)
    -- New accurate version of ISQRT. The previous version made some
    intermediate floating point calculations.

Jul  3 (John Williams)
    -- Poplog Version 14.2 ready for testing.

Jun 30 (John Williams)
    -- FORMAT bug fix: the ~E, ~F, ~G, and ~$ directives no longer
    go into infinite recursion if a line-break occurs within the
    printed representation of a number.

Apr 22 (John Williams)
    -- Changes in names of Lisp documentation indexes:
        HELP INDEX renamed HELP * HELPFILES
        New file HELP * LISPINDEX gives alphabetical list of HELP files
        REF INDEX renamed REF * REFFILES
        New file REF * LISPINDEX gives alphabetical list of REF files

Apr 15 (John Williams)
    -- Bug in DECODE-UNIVERSAL-TIME fixed: it used to produce dates like
    March 32nd, April 31st, etc.

Apr  9 (John Williams)
    -- New VED key binding: the key sequence <ESC> ) closes off all
    outstanding opening brackets at the end of a Lisp expression.
    See HELP * LISPVED.

    -- The VED key binding of <ESC> . to the "wiggle matching
    parenthesis" function has been removed. This is because it clashes
    with the new default set of VED key mappings described in HELP *
    VEDNEWKEYS. To retain this key binding, add the following Pop-11
    code to your 'vedinit.p' file:

        define vedinit();
            vedsetkey('\e.', ved_wmp)
        enddefine;

    The file HELP * INITIAL explains the role of a 'vedinit.p' file,
    and other Poplog initialisation files.

Mar 19 (John Williams)
    -- New module PROFILE added. This provides a Lisp interface to the
    Poplog profiling tool.  See HELP * PROFILE for details.

Mar  3 (John Williams)
    -- The Lisp compiler now recognises (but does not yet act upon)
    (OPTIMISE COMPILATION-SPEED) declarations.

Feb 24 (John Williams)
    -- The #b, #o, and #x reader macros now interpret signed numbers
    correctly.

    -- HELP POPLOG_ONLY renamed REF * POPLOG_ONLY


1991
Nov 5 (John Williams)
    -- New module MIT-LOOP added to the Lisp CONTRIB directory. It
    provides an enhanced version of the LOOP iteration macro. This
    software was produced by MIT, and is copyrighted by them. See HELP
    MIT-LOOP for more details.


1990
Nov 19 (John Williams)
    --  New module, CONTRIB, added. This makes the "contributed" (and
    unsupported!) software in $popcontrib/lisp/modules available.

    This software includes: PCL (Portable Common Loops), and CLX (Common
    Lisp X windows interface).

    PLEASE NOTE:
        PCL is Copyright (c) Xerox Corporation 1989, 1990.
        CLX is Copyright (C) 1987 Texas Instruments Incorporated.

    See HELP * MODULES, HELP * CLX, HELP * PCL.

Nov  1 (John Williams)
    -- Minor bug fix to the functions STRING-TRIM, STRING-LEFT-TRIM, and
    STRING-RIGHT-TRIM.  They now cope properly with strings that are
    entirely composed of characters to be trimmed.

Oct  8 (John Williams)
    -- The procedure used to translate symbols in the POP11 package to
    POP11 words has changed. Previously, the print-name was converted to
    lowercase under all circumstances. Now, only symbols that DON'T
    contain lowercase characters are translated to uppercase. This makes
    it possible to reference mixed-case POP11 identifiers (provided, of
    course, that the symbol is notated using the | syntax). It is still
    not possible to reference all-uppercase POP11 identifiers, however.

Sep 12 (John Williams)
    -- The functionality of SAVELISP has been considerably enhanced.
    Also, two new functions, INITLISP and RESTORELISP, added.
    See HELP * SAVELISP for details.

Aug 20 (John Williams)
    -- The optional <eof-error-p> argument to the functions READ,
    READ-CHAR, READ-LINE and READ-BYTE now defaults to T (as specified
    in Steele).

Jul 19 (John Williams)
    -- Two new magic-words added: LOAD and LIB. LOAD simply loads the
    specified file - like using the function LOAD, except that it saves
    typing a pair of brackets and a pair of quotes. LIB is is similar to
    REQUIRE: it searches for and loads a library file. Examples:

        == load myfile.lsp
        == lib mymodule

    -- The function PROLOG, and the associated magic-word PROLOG, are
    now only defined if the library module "prolog" has been loaded.
    Previously they were present in the basic Lisp image.

    -- Prolog terms are now printed sensibly (in the standard POPLOG
    format).

Jun 1  (John Williams)
    -- The function PROLOG (for switching from Lisp top-level to Prolog)
    now decides whether to invoke Prolog in assert mode or query mode.
    It chooses query mode if called interactively; assert mode
    otherwise (e.g. during file compilation).

Apr 23 (John Williams)
    -- The &ALLOW-OTHER-KEYS lambda-list keyword is now implemented as
    described in Steele, p61-3. Continuable errors are signaled if
    keyword arguments are used improperly.

    -- Minor enhancement to APROPOS: it now sorts the list of matching
    symbols before printing them.

    -- Bug in #+ and #- read macros fixed. They used to misbehave if
    nested.

Mar 30 (John Williams)
    -- New module, "run-unix-program", added, for running Unix programs
    from Lisp. See HELP * RUN-UNIX-PROGRAM for details. Obviously, this
    module is only available in Unix POPLOG.

Mar 23 (John Williams)
    Version 1.4 introduces the following features:

    -- <ENTER> ? and <ENTER> ?? now work in Lisp. Try <ENTER> ?? SORT


    -- The system used for mapping Lisp functions to source file names
    (used by ED) has been improved so that it is no longer necessary to
    rebuild Lisp if Poplog is moved.

    -- Setting or resetting the :BREAK option to TRACE for a given
    function during a call of that function now has an immediate effect.
    This means it is now possible to switch "trace breaking" on/off
    during a BREAK.

    -- A warning is now issued if an attempt is made to trace a
    special-form or undefined function.

    -- New variable *LISPFILETYPES* added. This contains the list of
    file extensions that Poplog will interpret as denoting a Lisp source
    file. See HELP * LISPVED and HELP * POPLOG_ONLY.

    -- Lambda-list keywords are now permitted in VALUES result-type
    specifiers in FTYPE and FUNCTION declarations.

    -- Inconsistencies between the number of arguments/results specified
    in declarations and in definitions now only generate warnings,
    instead of errors.


1989
Nov 22 (John Williams)
    -- The file extension '.cl' is now recognised as denoting a
    Lisp source file.

Nov 9  (John Williams)
    -- New magic words BYE, CD, PWD, and STOP added. (The latter is
    only available under Unix). See HELP * POPLOG_ONLY for details.

Aug 23 (John Williams)
    -- New documentation: HELP * FEATURES, which lists the symbols that
    Poplog puts in the *FEATURES* list.

Aug 22 (John Williams)
    -- The top-level loop reader now gobbles spurious newlines. This
    means that top-level calls to functions like READ-CHAR and READ-LINE
    now behave in a more user-friendly fashion (i.e. they actually wait
    for input instead of always returning the newline typed at the end
    of the line containing the call to READ-CHAR).

    -- The VALUES type specifier is now handled properly by the FTYPE
    and FUNCTION declarations.

    -- A warning (instead of an error) is now signaled if an FTYPE or
    FUNCTION declaration is inconsistent with the actual defined
    function.

Aug 3  (John Williams)
    -- A serious bug in the inline version of GET has been fixed.
    It used to behave incorrectly if used inside a conditional
    when the value of the association in the property list was NIL.

Jun 22 (John Williams)
    -- The debugger now displays stackframes in a more concise format.

    -- Improvements to the low-level routines for simple-string
    handling and character/integer conversion have been made. As a
    result, fast non-checking inline versions of the functions
        CHAR-CODE, CODE-CHAR, CHAR-INT, INT-CHAR
    are now available.

Jun 20 (John Williams)
    -- A serious bug in the "prolog" module has been fixed. Previously
    Prolog variables (as notated by the ?x read macro) were constructed
    at read-time. The ?x read macro now returns code that constructs
    Prolog variables at run-time.

Jun 16 (John Williams)
    -- Change to the way functions are printed: if *PRINT-ESCAPE* is
    not NIL, information about its numbers of arguments and results
    is displayed. E.g.

        #<FUNCTION INTERN 1 2 2>

    The first number, 1, is the minimum number of arguments. The second,
    2, is the the maximum number of arguments. The last number, 2, is
    the number of results produced by the function. NIL is printed
    whenever one of these quantities is variable, e.g.

        #<FUNCTION FUNCALL 1 NIL NIL>

    If *PRINT-ESCAPE* is NIL, just the functions "name" is displayed.

May 24 (John Williams)
    -- Bug fix: giving a lambda expression to the DEFSTRUCT
    :PRINT-FUNCTION option now works.

May 8  (John Williams)
    -- LET and LET* should now generally compile into more efficient
    code (that does not include a hidden sub-routine call). This
    optimisation is only possible if the LET form does not bind any
    special variables.

    -- The interface between the editor and *DEFAULT-PATHNAME-DEFAULTS*
    has been improved; e.g. (ED) or VED with no argument should now
    edit the pathname specified by *DEFAULT-PATHNAME-DEFAULTS*, rather
    than "temp.lsp".

Apr 19  (John Williams & Paddy Toal)
    -- New debugger command :M for re-displaying the error that caused
    the current BREAK. See HELP * BREAK

    -- The debugger command :B (backtrace) now asks whether more than a
    screenful should be displayed. See HELP * BREAK

Feb 17  (John Williams)
    -- New magic word IM for entering the editor in immediate mode.
    See HELP * IM.

Feb 16  (John Williams)
    -- GET-SETF-METHOD now only macro-expands its argument if the form
    doesn't have a setf method - previously it fully macro-expanded its
    argument before looking for the setf method, making it impossible to
    define a setf method for a macro.

Feb  9  (John Williams)
    -- INSPECT now ignores colons in command input (for consistency
    with the command conventions of BREAK).

Jan 19  (John Williams)
    -- The inline versions of <=, <, =, >, >= have been re-written,
    fixing two serious bugs. These were:
        1. Arguments were not evaluated in left-to-right order
        2. Argument forms consisting of calls to user-defined functions
            returning more than 1 result were not evaluated correctly.


1988
[All entries by John Williams]

*** Version 13.6 released for beta-testing ***

Oct 27
    -- Last call (tail recursion) optimisation is now possible. It is
    selected via a new option, TAIL-RECURSION, to the OPTIMIZE
    declaration. See HELP * OPTIMISE for more details.

Oct 25
    -- The *PRINT-CIRCLE* facility is available (at last!).

Oct 24
    -- Some new VED commands for moving around and marking lists have
    been added. See the section 'More Facilities for Manipulating Lists'
    in HELP *LISPVED.

Oct 17
    -- The warning messages issued when a forward reference to a
    function or special variable remains unresolved have been improved.
    They are now printed using the standard WARN format, which includes
    source file name and line number. Also, if a set of files is
    compiled, only forward references that remain unresolved at the end
    of compiling the entire set are notified.

    -- Printing of streams improved. They now print in the form

        #<STREAM :INPUT <input-spec> :OUTPUT <output-spec>>

    where <input-spec> and <output-spec> describe the stream's
    input source and output destination respectively.

Sep 7
    -- MAKE-HASH-TABLE now takes a new keyword argument :TEMPORARY.
    If given a non-NIL value, table entries whose keys are only
    accessible via the table are subject to garbage collection. This
    flag only affects EQ hash tables.

Aug 30
    -- Additional character name recognised: #\Null (code = 0)

Jul 16
    -- Version 1.2 introduces the following new features:

        New variable *CONSTANT-FUNCTIONS*.
        See HELP * POPLOG_ONLY

        The compiler is now able to deduce the number of results
        produced by some functions. This enables it to plant more
        efficient code for function calls. It will only use such
        information if the function was defined while the variable
        *CONSTANT-FUNCTIONS* was set true. If the compiler can not
        deduce the number of results, it will print a message saying
        so. In such cases, the FUNCTION declaration provides an
        explicit means for declaring the number of results.

        FTYPE and FUNCTION declarations implemented.
        See HELP * FTYPE

        The INLINE/NOTINLINE declarations now affect user functions.
        See HELP * INLINE

        New variable *LOAD-LOCK*, which if true ensures that the heap
        is 'locked' after every load operation. May be set via the
        :LOCK keyword argument to LOAD (ala :VERBOSE/*LOAD-VERBOSE*).
        See HELP * POPLOG_ONLY.

        REQUIRE is now sensitive to *LOAD-VERBOSE*.

        The following functions now have special 'inline' versions:
            APPEND, NCONC, LOGAND, LOGEQV, LOGIOR, LOGXOR
        which save &rest arglist consing.

        Minor improvements to:
            FUNCALL, APPLY, MULTIPLE-VALUE-CALL, GCD, LCM

        GET-SETF-METHOD now takes local function bindings into account.

        The errors signaled when constants, system functions, or system
        type specifiers are re-defined are now correctable.

        Change in circumstances in which symbols in the POP11 package
        are treated as referring to POP11 quantities. See HELP * POPLISP

        SPECIAL-FORM-P only returns T for 'real' special forms

        New documentation:
            HELP * DECLARE
            HELP * FTYPE
            HELP * INLINE


June 8
    -- Bug in FORMAT ~T directive fixed. It used to hang if the second
    parameter was 0.

    -- VALUES-LIST now checks that its argument is a list.

May 17
    -- Bug in CHECK-TYPE fixed; it now accepts a third optional argument
    as described in Steele.

May 13
    -- New module, "magic-words" added. This enables users to define
    their own special top-level keywords, like VED and HELP. See
    HELP * MAGIC-WORDS for more details.

Apr  7
    -- Bug in PARSE-INTEGER fixed: it couldn't cope with lowercase
    characters when the :RADIX argument is > 10

Mar 28
    -- DEFMACRO no longer objects to &ALLOW-OTHER-KEYS

Mar 16
    -- SPECIAL-FORM-P now only returns true for 'proper' special forms
    (i.e. those defined in Steele). It used to also classify functions
    that optimised into inline code as special forms.

Mar 14
    -- New module, "storeutils", added. This provides a Lisp interface
    to POPLOG Storeage Management facilities. See HELP * STOREUTILS.
    Note: the variable *GC-TIME* is now part of the "storeutils" module;
    it is only defined if this module has been loaded. Also, the macro
    TIME will only print GC time statistics if "storeutils" is loaded.

    -- Byte specifiers are now printed using #. syntax. For example:

        == (byte 3 4)
        #.(byte 3 4)

    This (a) distinguishes them from lists (b) means that they display
    print/read consistency.

Mar  4
    -- A new top-level command, SHOWLIB, for examining library modules,
    is available. Try SHOWLIB HISTORY, for example. Note for POP11
    users: the default file extension is '.lsp', so don't forget to add
    '.p' when specifying POP11 library files.

Mar  1
    -- The function POP11-VAL no longer modifies the execution
    environment in which the POP11 text is compiled and run.

    -- The file extension '.l', like '.lsp', is now considered to
    specify a Lisp file. However, the system still expects Lisp 'init'
    files to have a '.lsp' extension.

    -- The special-form THE has been changed so that it only plants
    type-checking code if Safety > Speed (as opposed to Safety >= Speed)

Feb 26
    -- The functions WRITE-STRING and WRITE-LINE have been optimised
    for outputting entire simple-strings.

    -- The variables *PRINT-BASE* and *READ-BASE* are now 'typed': an
    error is signaled if they are assigned an illegal value.

    -- Zero dimensional arrays now print properly.

Feb 23
    -- The <ENTER> F command no longer uses the Lisp reader when
    searching for the specified function name. This should make it
    more robust, and also able to cope with package qualifiers.

Feb 16
    -- &ALLOW-OTHER-KEYS may now be used in function lambda-lists. It
    does not affect the function, however - all functions are compiled
    as if &ALLOW-OTHER-KEYS were true.

    -- #\Linefeed is now recognised as a synonym for #\Newline

    -- DO and DO* can now cope with a <var/init/step> specifier of the
    form (var).

Feb 15
    -- A new module, "HISTORY", is available, which provides a Unix-like
    history mechanism for the Lisp top-level loop. See HELP * HISTORY.

Feb 8
    -- BREAK now sets *READ-SUPPRESS* nil (useful if BREAK was invoked
    after reading an invalid feature expression!)

    -- Symbols containing \ are now printed properly

Feb 1
    -- Clisp no longer autoloads - all functions defined in Steele
    are built into the 'clisp.psv' saved image. This makes the system
    more robust, and only 5% bigger.

Jan 12
    -- The "PROCESS" module has been improved. Processes are now
    given unique integer labels. See HELP * PROCESS.


1987
Dec  4
    -- The functions SECOND, THIRD ... TENTH can now be compiled inline
    (but are not done so by default).

    -- RPLACA and RPLACD have been speeded up.

Nov  6
    -- Bug fix: the macros that map over packages (DO-SYMBOLS etc) are
    no longer confused by NIL and T.

    -- Zero dimensional arrays now work properly.

Oct 28
    -- There is now an inline version of BOOLE.

*** Version 13 released ***

Nov 24
    -- Bug in FORMAT ~T directive fixed - it previously only worked
    correctly the first time it was used!

Nov 16
    -- The Lisp command (POP11) and the POP11 command -lisp- no longer
    alter *STANDARD-INPUT* and -cucharin-.

Nov 12
    -- FIRST and REST should now be indistinguishable from CAR and CDR
    (except in name). Also, they can be declared inline.

Oct 20
    -- Bug fix: the INLINE declaration now acts pervasively.

Sep 14
    -- BREAK now prints a terser message when the Debugger starts up.

Sep 7
    -- (SETF var val) now expands into (SETQ var val)

Sep 3
    -- New function MAKE-POP11-PROCEDURE added. This converts a Lisp
    function into a procedure that POP11 can apply directly. Useful
    for defining PWM event handlers in Lisp. See HELP * POPLISP and
    HELP * POPLOG_ONLY for more details.

Aug 19
    -- DEFSTRUCT bug fix: the names created for the slot update
    functions are now unique; there was previously the possibility of
    confusion if structure types with the same (print) name were defined
    in different packages.

    -- MAKE-HASH-TABLE now handles the :REHASH-SIZE and
    :REHASH-THRESHOLD arguments correctly.

    -- LOGTEST now returns NIL instead of POP11::FALSE when appropriate

Jul 22
    -- New HELP file, HELP * OPTIMISE writte

    -- The functions GETHASH and REMHASH have been speeded up by about
    30%. However, mixed language programmers beware: they will no longer
    cope properly with "active" POP11 properties.

    -- Calls to MEMBER and ASSOC with no keyword arguments will now
    be specially optimised by the compiler, resulting in substantial
    performance improvements. If these functions are declared
    NOTINLINE, this optimisation will not occur.

Jul  7
    -- Bug fixes: UNREAD-CHAR works properly with string input
    streams that are exhausted, and LISTEN now treats concatenated input
    streams correctly.

May 29
    -- Note for PWM users: the function READ-LINE, like READ, will
    now handle mouse events correctly. YES-OR-NO-P and Y-OR-NO-P have
    been recoded to use READ-LINE.

May 25
    -- The function ROOM now provides more information

May 20
    -- Bug in SLEEP fixed: it now returns NIL, not zero values

May 1
    -- New module, PROLOG, added. This provides a Lisp interface to the
    POPLOG Prolog subsystem. See HELP * PROLOG for details.

April 29
    -- POPLOG Common Lisp now includes a 'debugger'. This is
    automatically invoked via errors, interrupts, and calls to BREAK.
    See HELP * BREAK for details of the debugger. HELP * DEBUG overviews
    debugging tools in general. The function CONTINUE (only available
    from POPLOG 12.2) has been withdrawn.

    -- The interactive top-level loop now responds specially to certain
    top-level forms, such as 'ved', 'help', and 'ref' (for accessing
    program and documentation files via VED).

April 27
    -- AREF can now be declared inline (to get faster but non-checking
        array accesses)

April 6
    -- Bug fixes:

        DO-SYMBOLS, DO-EXTERNAL-SYMBOLS, and DO-ALL-SYMBOLS now all
        permit RETURN statements.

        LOGBITP now returns NIL, not #<FALSE> when the specified bit is
        not set

        BYTE-SIZE and BYTE-POSITION fixed

Mar  3
    -- Some obscure compiler bug fixes:

        PROGV now restores variable values correctly even if an exit
        occurs during the binding process

        LET now processes declarations *before* compiling the values
        of its variables

        COMPILER-LET and EVAL-WHEN handle compile-time evaluation
        better - previously they were confused by lexical variables

    -- The inline versions of DOTIMES and DOLIST no longer exist;
    new compiler optimisations mean that the macro versions generate
    equally efficient code.

    -- The macro POP now generates special inline code if its argument
    is an atom (as opposed to a 'place').

Feb 20
    -- Bug fix: FORMAT can now write to adjustable strings.

    -- Macros that expand into declarations are now recognised and dealt
    with appropriately.

    -- Directory specifications in *module-directory-list* can now be
    pathname objects.

    -- The function SAVELISP will now accept a pathname object to
    specify the saved image file. If the pathname does not include a
    'type' component, 'psv' is used as the default.

    -- The function GET can now be declared 'inline'. It is 'notinline'
    by default. The inline version assumes the property list contains
    an even number of items.

Feb 10
    -- Clisp Version 1.0 released internally. This includes the
    following new features and bug fixes:

      The functions DEFTYPE and SUBTYPEP have been implemented. Also,
      TYPEP now handles list type specifiers better.

      Dummy versions of COMPILE-FILE, EVALHOOK, APPLYHOOK, and STEP
      (which simply signal a warning if used) are provided. Since POPLOG
      Common Lisp has no interpreter, it is currently unclear both what
      these functions should do, and when they might be implemented.

      Bug fix: VECTOR-PUSH-EXTEND now copes with empty vectors properly.

      Bug detected but not fixed: MAKE-STRING-INPUT-STREAM does not
      'notice' if the string it is reading from is adjusted (via
      ADJUST-ARRAY or VECTOR-PUSH-EXTEND).

      Calls to undefined functions now signal a continuable error.

      Errors signaled because the wrong number of arguments are
      passed to a function are now continuable. During the 'break',
      a list of the erroneous arguments is assigned to the variable
      *TRACE-ARGS*; on continuing, the function is reapplied to
      the arguments in *TRACE-ARGS*.


1986
Dec 13 (John Williams)
    -- CATCH and THROW have been made *much* more efficient. To
    illustrate: the standard CTAK benchmark (see 'Performance and
    Evaluation of Lisp Systems', by Richard Gabriel) now runs five times
    faster.

Dec  1 (John Williams)
    -- Lisp now has REF files. These provide brief descriptions of all
    the functions, macros, variables etc. defined in Steele. See the
    section 'Online documentation' in HELP * CLISP, and REF * INDEX,
    for more details. Thanks are due to Alexandra Le Bek, who produced
    most of the text, and Rob Duncan, who arranged the material.

Nov 24 (John Williams)
    -- A new module, PROCESS, has been added. This enables Lisp users to
    use the POPLOG 'process' facility. See HELP * PROCESS for more
    details

Nov 20 (John Williams)
    Clisp Version 0.99 released internally. This includes the following
    main new features:

    -- The pathname related functions (i.e. those described in Steele,
    Chapter 23) are now implemented. Functions that previously would not
    accept pathnames or streams as arguments (eg LOAD) now do so. A HELP
    file will be provided soon that explains the file name parsing
    rules.

    -- SXHASH has been implemented

    -- Some basic data-structure access/update functions now have inline
    versions. These are: CAR, CDR, C..R, RPLACA, RPLACD, SVREF, and
    SCHAR. Note that calls to these functions are not compiled inline by
    default - one has to PROCLAIM or DECLARE them inline explicitly. The
    inline versions do not do any type checking; strange things may
    happen if they are used incorrectly.


Oct 17 (John Williams)
    -- Bug fix: MAP now accepts NIL as a 'result' type specifier

    -- UNWIND-PROTECT now works properly

    -- New, *much* better version of PROGV (binding/unbinding speed
        improved by a factor of 200 !)

Oct  3 (John Williams)
    -- The function ED should now work if invoked from inside VED

Oct  1 (John Williams)
    -- Bug in 'end-of-file' handling fixed: if an 'eof-value' of NIL
    is supplied to functions such as READ and READ-CHAR it will be
    returned when appropriate (previously <termin> would have been
    returned)

Sep 22 (John Williams)
    -- Bug in BOTH-CASE-P fixed: it now returns true of lowercase
    characters as well as uppercase characters.

Sep 15 (John Williams)
    -- Serious bug detected and fixed: the inline version of LIST*
    'lost' arguments if they were the results of user-defined function
    calls.

Sep  4 (John Williams)
    -- Bug fixed: the form (TYPEP X 'STANDARD-CHAR) no longer signals an
    error if X is not a character.

Sep  3 (John Williams)
    -- Version 0.95-A released internally, containing *full* DEFSTRUCT
    facilities.

Sep  2 (John Williams)
    -- Bug in SET-SYNTAX-FROM-CHAR detected and fixed. It was expecting
    its <to-char> and <from-char> arguments the wrong way round.

Aug 19 (John Williams)
    -- A new module, EXTERNAL, has been added, which provides a Common
    Lisp interface to the POPLOG 'external load' facility. See the file
    HELP *EXTERNAL for more details.

Aug 12 (John Williams)
    -- POPLOG Version 12.2 includes a number of minor Lisp bug fixes.
    The :INITIAL-CONTENTS option to MAKE-ARRAY and ADJUST-ARRAY now
    works, and the #nA read macro is also now implemented. The bug
    concerning creating arrays displaced to simple-strings is fixed.
    Also, some functions specified in Steele are now available. These
    are:
        GET-DECODED-TIME
        ENCODE-UNIVERSAL-TIME
        DECODE-UNIVERSAL-TIME
        PROGV

Aug  4 (John Williams)
    -- The old Lisp system provided by LIB LISP has now been withdrawn.
    This does NOT affect Common Lisp users.

Jul 31 (John Williams)
    -- Format ~C directive implemented (at long last!)

Jul 27 (John Williams)
    -- Bug in handling of multiple values by CATCH and THROW fixed.

Jul 16 (John Williams)
    -- The CLASS_PRINT of symbol records has been changed so that POP11
       prints them in the same format as they can be read in, using the
       "@" read macro.

Jul  8 (John Williams)
    -- Common Lisp 0.94 includes a number of new features and bug fixes:

    GET-SETF-METHOD now expands macros.

    An incomplete (see HELP * BUGS) version of ADJUST-ARRAY has been
    added.

    The basic DEFSTRUCT :INCLUDE option has been implemented; but not
    the (:INCLUDE slot-name slot-description) variant.

    The DEFSTRUCT :PRINT-FUNCTION option has been added.

    The @ read-macro has been changed to non-terminating status.

    The characters ! $ and % no longer pass a line of input to the
    operating system command interpreter if used at the beginning of a
    line.

    Handling of *PRINT-ESCAPE* has been improved; the system is now more
    likely to output escape characters in the right places. However, it
    still does not take account of user defined macro characters.

    Incomplete versions of PROBE-FILE and DELETE-FILE have been added
    (ones that only accept strings and symbols as arguments).

    The TIME macro now subtracts garbage collection time from total CPU
    time, and reports it separately. The new variable *GC-TIME* holds
    the total CPU time spent garbage collecting.

    A bug in GET-UNIVERSAL-TIME has been fixed - it used to return a
    number that was one day's worth of seconds too small.

    The following error handling functions are now available:

        ASSERT CERROR CCASE CTYPECASE WARN

    The TRACE facility has been extended: it is now possible to specify
    that a break should occur whenever the traced function is entered
    and returned from.


Mar 27 (John Williams)
    -- POPLOG Version 12 includes a substantially improved Common Lisp
    system. 93% of the features specified in Steele have been
    implemented.

    The main additions are:
        complete implementation of packages
        complete implementation of SETF
        full range of numeric types
        hash tables
        lexical scoping for functions (FLET and LABELS)
        full lexical scoping of GO and RETURN statements
        new, correct (!), implementation of backquote

    The main omissions are:
        pathnames
        DEFSTRUCT :include  :type  :constructor  options
        some debugging utilities (STEP, CERROR, EVALHOOK etc)

    See HELP *BUGS for more details.


1985
Sep 16 (John Williams)
    -- New version of Common Lisp
        Includes infinite precision integers (bignums).
        Minor bugs in the functions ARRAY-IN-BOUNDS-P, CODE-CHAR,
        MAKE-CHAR and DIGIT-CHAR-P have been fixed.

Aug 19 (John Williams)
    -- New version of Common Lisp
        Includes the function FIND-ALL-SYMBOLS
        Some functions moved to auto-loadable directory to reduce
        initial saved-image size.

    -- Four new HELP files added:
        *CONSTANTS      lists built-in constants (and values)
        *FUNCTIONS      lists built-in functions
        *LISPVED        describes LISP-specific VED facilities
        *VARIABLES      lists built-in variables (and initial values)

    -- HELP *BUGS no longer mentions unimplemented functions. These are
    listed in HELP *FUNCTIONS.

Jul 31 (John Williams)
    -- HELP *BUGS added. This lists known bugs and omissions in the
    current Common Lisp system.

Jul 29 (John Williams)
    -- POPLOG now includes a Common Lisp subsystem. See HELP *CLISP for
    more details.


--- C.all/lisp/help/lispnews
--- Copyright University of Sussex 1992. All rights reserved.
