Start development on 386BSD 0.0

[unix-history] / .ref-BSD-4_3_Net_2 / usr / src / usr.bin / lisp / pearl / ChangeLog

    Changes to PEARL since the User's Manual.

6/26/83 -- Version 3.9: Misc. bug fixes -- distributed with 4.2.
-- Fixed a(n embarassingly) large number of bugs in the functions
relating to blocks and freezing and thawing variables.  User visible
changes are that freezeblock and thawblock are now fexprs expecting
the name of the block to be frozen.  Blocks without names cannot be
frozen or thawed individually.  A prominent bug was also found in
freezebindings which did not work correctly when the structure being
frozen had no non-frozen variables of its own.

6/21/83
-- Changed the name of the "selectq" in ucisubset.l to "selectq*" to
avoid the new Franz function "selectq" which requires the default case
to be labeled with "t" or "otherwise".  Changed all PEARL code to use
the new Franz selectq.

5/14/83 -- Version 3.8: Unification added.
-- Added unification pattern matching as an option, using code written
by Dave Chin.  To turn on unification, call the function "useunification".
There is currently no way to turn it off since the code as written
cannot handle old unification results if it doesn't think unification
is taking place (controlled by special variable *unifyunbounds*).
It is not as expensive as expected so this may be changed.
-- Also fixed serious bugs in "setv".

5/12/83
-- Fixed bug in create which caused the mechanism of changing the type
of create being done in nested structures to fail.

5/6/83
-- Fixed bug in printing of global adjunct variables.

5/1/83
-- Fixed various major bugs in varreplace.

4/26/83 -- Version 3.7: Two part compilation and minor bug fixes
	    in scopy and hooks.
-- Created a way to do a "make" which compiles in two pieces for small
machines.  Simply define "make pearl" as either "big" or "small"
depending on memory size (Less than about 2.5 Mb of memory requires
"small").
-- Changed "scopy" and related functions so that the abbreviation on the
copy is just gensym'ed from the old abbreviation, without adding ":copy".
-- Fixed a bug in the hook functions which caused all slots after the ones
with hooks to execute the result (*done*, etc) of the first one.

3/28/83 -- Version 3.6: Inherit all slot hooks and predicates and unbind
	    incorrectly bound global variables after failed match.
--- Slot hooks are now always inherited and added to, rather than
replaced.  If the hooks and predicates of a slot are preceded by "instead"
then inheriting doesn't happen and hooks and predicates are replaced.
--- Fixed match so that if an unbound global variable is set during a match
that later fails, the value is restored to *pearlunbound*.  The names of
variables that are set are saved in the special variable *globalsavestack*.

3/18/83 -- Version 3.5: New print functions.
--- Rewrote all the print functions.  Externally, the three old
pairs of functions: "valprint"/"valform", "fullprint"/"fullform",
and "abbrevprint"/"abbrevform" behave the same.  However, there is now
a function called "allform" which all of these use which adjusts its
treatment of a structure based on several special atoms:
    1. *abbrevprint* -- non-nil value causes abbreviations to be used
whenever possible.  "abbrevform" (and thus "abbrevprint") lambda-binds
this to t and calls "allform".  "fullform" binds this to nil.
    2. *fullprint* -- non-nil value causes complete information
including hooks and predicates to be given when present.  "fullform"
(and thus "fullprint") lambda-binds this to t and calls "allform".
"abbrevform" binds this to nil.
    3. *uniqueprint* -- described below.
    4. *quiet* -- described below.
"valform" lambda-binds both to nil which is their default values.
Thus, the default action of "allform" used by itself will be like "valform".
--- All the default print functions which used to use "valprint"
automatically now use "allprint" so that they can all be changed by
changes to the default values of *abbrevprint* and *fullprint*.
--- The third atom which affects the behavior of all the print functions
is *uniqueprint*.  If it is given a non-nil value then if a structure
is encountered more than once during the same top-level call to a
print function, it will be translated into exactly the same cons-cells.
This saves on cons-cells and also makes it possible for the "*form"
functions to handle circular structures, although "sprint" and thus
the "*print" functions can't handle the result.  Since most people
seldom have duplications within a structure, the default is OFF (nil).
The assoc list is stored in the special atom *uniqueprintlist*.
--- "form" and "print" functions were added to handle structures,
streams and symbols specially.  They are called
"structureform", "structureprint" "symbolform", "symbolprint",
"streamform" and "streamprint" and do not ensure that you give them
the right type of value.
--- The fourth atom which affects the behavior of all the print
functions is *quiet* which, if non-nil, keeps them from running
either sprint or the *form function.   This is helpful for when you
wish to turn off ALL printing in one fell swoop.  A function called
"quiet" was also added which behaves like progn, except that it
lambda-binds *quiet* to t during the evaluation of its arguments,
provided a local island of "quiet".

3/8/83 -- Version 3.4: Type tags added.
--- Added a field to definitions, structures, symbols, and databases to
indicate what they were to speed up type checking.  All relevant
functions related to structures and databases were changed.
--- Fixed some bugs in releasedb.
--- Many lowlevel functions in PEARL were changed, but none in ways that would
affect most people (because they shouldn't be using the changed functions).

3/4/83 -- Version 3.3: New faster hashing.
--- Changed internal code to do the hashing so that it only gets the value
out of a slot once instead of as many as 4 times as before.  Resulted
in about a 5% speedup for structures only hashed a couple of ways.
Should be more for multiply hashed items.  Should also make new
hashing methods easier to add.

2/25/83 -- Version 3.2: Slot encoding applied to speeded-up match.
--- Rewrote match functions to use the new slot encoding.  Provided
about a 10% speedup.
--- There are now two different kinds of match function: "standardmatch"
and "basicmatch" will only match two structures of the same type.
"standardexpandedmatch" and "basicexpandedmatch" will match two
structures which are related hierarchically (one above the other)
on the slots they have in common.  "standardfetch" uses the regular
versions and "expandedfetch" uses the expanded versions.

2/21/83
--- Changed all special variables in PEARL to be defined with defvar so
that fasl'ing in pearl.o at compile time will automatically declare them
special again.

2/17/83 -- Version 3.1: Slot encoding for speed.
--- Added major and minor version numbers to PEARL, stored in
"pearlmajorversion" and "pearlminorversion" respectively.
Started at 3.1 for this version.
--- Added new method of storing in slots to speed up some things.
--- Putpath, delsetpath, addsetpath and clearpath now will work on a
slot with any kind of value or variable in it but result in a constant
value.  This may cause problems, and if it does it will be "fixed" to
worry about what was there and decide what to do to it.
--- Scopy no longer throws away bound adjunct variables.
--- Many functions listed in the manual as being "proprietary" to PEARL
(i.e., not safe to use) have gone away.  There are too many to list here.

1/23/83
--- Fixed a bug which made slots inherit hashing when redescribed in an
expanded structure unless new hashing was specifically included.
--- Added a new "hashing mark" "+", for redescribed slots of expanded
structures only, which says copy the old info and add the following
new hashing too.  It must come first to be effective.
    Thus, the following should work:
	(cb x (* a int))
	(ce x y (a ^))
	(ce x z (+ : a ^))
	(ce x w (: + a ^)) ;; anomalous use of +
resulting in:
	* hashing in x,
	no hashing in y,
	both * and : hashing in z,
    and only * hashing in w (because of misplacement of +).

1/19/83
--- Merged the file sprint.l into ucisubset.l.

1/18/83
--- Miscellaneous changes to functions length and others in ucisubset.l
to improve efficiency.

1/7/83
--- Changed ,@ to ., in most cases (i.e., whenever equivalent) to
avoid an unneeded append generated by the backquote macro.

12/24/82
--- Made change in the definitions of de, df, dm, drm and dsm so that
if the special variable *savedefs* is nil then old definitions of functions
are not saved.  This is especially useful in compiling (and hence assembly
and loading) since it will speed it up quite a bit.  The saving of the file
the definition was in is also disabled.  The variable *savedefs* is
normally t which causes these macros to act as before, saving the
definition, etc.  If *savedefs* is nil, then they simply expand into the
appropriate defun or setsyntax.  The following lines should be
included in the file to have this effect only at compile time:
    (eval-when (compile)
	       (declare (special *savedefs*))
	       (setq *savedefs* nil))
If you want to permanently disable the saving in your lisp,
simply put a
    (setq *savedefs* nil)
in your .lisprc file AFTER the loading of ucisubset.l.

11/12/82
--- Removed association of "remove" with Franz's "delete" so that
Franz's remove could be used and fixed all references to "remove" and
"dremove", changing many to "delq"s.
--- Deleted "powercopy" and redefinition of "copy" now that Franz has
correct meaning (doesn't attempt to copy hunks) for copy.

10/30/82
--- All the exprs whose names were of the form XXXX1 where XXXX was the
name of a lexpr which was a principle function of PEARL were eliminated
(i.e., absorbed by the other form).
--- Many small changes to speed up PEARL, including:
    1. Changed many progs to lets.
    2. Inserted progn's around (or (non-error)
				   (not (msg t .....))
				   (pearlbreak))
    thus eliminating the not and clarifying the meaning.
    3. Changed many pops to (setq x (cdr x)) (where popped item not wanted).
    4. Changed plus, difference, times and remainder to +&, -&, * and \\.
    5. Changed greaterp and lessp to >& and <&.
    6. Changed minusp to (<& ..  0)
    7. Changed (neq 0 ..) to (not (=& 0 ..)).
    8. Eliminated the intermediate exprs insertdb1, fetch1, etc.
    by converting the basic functions insertdb, fetch to use the
    &optional syntax.
PRELIMINARY RESULTS:
    25-33% speedup of various test programs.

10/20/82
--- Added abbreviation "pdb" for "printdb".
--- Changed usage of nth, push and pop to use Franz Opus 38.32's new
definitions of them, removing them from ucisubset.l.

9/17/82
--- Changed scopy, patternize and varreplace to exprs from macros
so that they will compile without complaints of special variables.

9/16/82
--- Added new hashing mechanism using label && and called "hash
focusing".  If this is found when inserting into the database
then the item is hashed as if it were the item in the slot so
labelled.  This is designed for people using a data base all of
whose entries are of the same type (not required, just common
for this application) and enables the contents of a slot to be
more usefully used to discriminate them (e.g., planfors, inference
rules, or almost any such extremely-common binary predicates.)
At fetching time, && is considered less useful than *** or ** and more
useful than * or nothing (subject to debate and change).  (This
necessitated the addition of an additional entry in the header of
structure definitions, moving everything else down a slot in the hunk.)
This differs from & (hash aliasing) in that && hash focussing affects
how a structure itself is inserted and fetched, while & simply
affects how structures containing this type of structure are
treated.  For example, suppose the unique numbers of A, B, and C
respectively are 1, 2, and 3.  C is a symbol.  A has one slot X with
* and && hashing.  B has one slot Y of type symbol with * hashing.
Then a structure like (A (X (B (Y C)))) will be indexed the
following ways and fetcheverywhere will find it in the following
order:
    && which uses the 2 and 3 from B and its C, (ignoring the 1 of A),
	    and also simply 2 from B.
    * on A uses type of B thus using 1 and 2.
    also put under 1 of A without using 2 or 3.
If B had an & in its slot then the
    * on A is affected by & on B thus using 1 and 3 (ignoring the 2 of B).

Thus, if you consider A, B, and C to be three levels of information
in the structure, an item can be hashed under any combination of two
of those levels.  The normal * method uses levels 1 and 2, the
aliasing & method ignores level 2 and uses levels 1 and 3, and the
new focussing && method ignores level 1 and uses levels 2 and 3.
In addition, the item can be put under 1, 2 or 3 individually by
various combinations of marks (1 = none, 2 = :, 3 = :+&).  The only
unavailable combination of the 3 is all three.

(Added internal-use-only functions are insertbyfocus, removebyfocus,
puthashfocus, gethashfocus, recursetoinsidestandardfetch.

9/15/82
--- Added two functions "memmatch" and "memstrequal" which are like
"memq" except that they use "match" and "strequal" respectively
instead of "eq".
--- Added fixes to "scopy" and "patternize" from Dave Chin which allow
them to handle circularly linked structures AND to use the same copy
of the same structure wherever it appears.  This required the addition
of a special variable *scopieditems*.  This also included a bug fix
which added code to store pointers to the new copies in the
abbreviation atoms stored in them.
--- Added a function called "varreplace" similar to "patternize" which
replaces all bound variables in an item with their values, in effect
permanently freezing them.
--- Added a function called "(intscopy item outeritem)" where intscopy
stands for "internal scopy" exactly the same as "(scopy item)" except
it does the copying as if the item were internal to outeritem, thus
sharing its local and block variables.
--- Split create.l into create.l and scopy.l.

9/14/82
--- Moved much of the initialization stuff out of pearl-top-level-init
to be done at load time instead.  This cut the minimum startup cost
for PEARL from 4 seconds to 0.8 seconds CPU.
--- Changed setdbsize to remove all current databases before changing
the size, warn if *warn* is set and recreate *maindb* with *db*
pointing to it.  Also fixed a bug when removing the last database.
--- Changed the init-files processing to parallel the new Franz method,
looking in the current directory, and then the home directory, and
looking for .init.prl followed by .o, .l or nothing, and then init.prl
followed by .o, .l or nothing.  Similarly for start.prl.
--- Fixed cleardb so that it doesn't make new cons-cells for the buckets
and so that it uses connectdb if the database has a parent.  Thus,
cleardb is a local database clearer and its effects do not extend up
the DB hierarchy.

6/6/82
Added new hashing method.  If slots are labelled with *** and all
slots so marked are filled with useful values, then the item is hashed
under the type of structure plus the values of all these slots.
New functions are gethashmulti and puthashmulti.  *multiproducts* is a
new special atom containing the numbers to multiply the various values
with to produce the index (currently powers of 16).

6/3/82
Fixed a bug in fetcheverywhere which caused it to only find the
bucket for the first *-ed slot, instead of all of them.  (Added
to npearl also).

5/28/82
Tried replacing the sequential search method of finding slot numbers
for particular slot names with evaluating a concat'ed atom made out
of <typename ":" slotname> but timings found it slower so it was
removed.

5/27/82
Fixed a problem with storage of variables.  Instead of two spots in
the hunk, one for the alist (unfrozen variables) and one for the
alistcp (frozen variables), there is a special cons cell with these
in its car and cdr.  This cons cell is pointed to by all substructures
so that they can be used in fetches and matches and will be able to
unbind or freeze or thaw their variables.  Additional special variable
is *toplevelalists* (or some such).

5/6/82
--- When an individual (including default instance) structure is created,
an abbreviation atom is stored in it.  This abbreviation is chosen as
follows:
    1.  If the option of having a structure stored in an atom is used,
    then that atom is the one used as an abbreviation.  Thus
	(create individual x Pete)
    will have Pete as a abbreviation.
    2.  If that option isn't used, then default instances will be
    given the abbreviation i:x (where x is the structure type name)
    and individuals at the top level will be given a name newsym-ed
    from the name of their type.  Thus
	(create base x)  will make a default instance abbreviated i:x and
	(create individual x) will be abbreviated x0 or x1 or whatever.
--- New printing and "form-type" functions were added called "abbrevprint"
and "abbrevform" which print the abbreviation (if there is one) for
any structure below the top level.
--- The base name of the type of a slot (i.e., the last word, after
setof's are stripped off) is stored for each slot (a more general
application of the "ppset" information always stored for integer slots
with ordinal types before).  This is in preparation for two things:
    1. Enforcing such type descriptions.
    2. Generating knowledge about the slots of a structure so that the
    user need not know whether to use fetch or path.

5/5/82
The name of an old slot in a new expanded may be changed by following
the new name by the old slotname preceded with an equal sign.  Thus
for example:
pearl> (create base X
	       (A struct))
(X (A (nilstruct)))
pearl> (create expanded X Y
	       (B =A)
	       (C .....))
(Y (B (nilstruct)) (C .....)))

NOTE that there MAY NOT be a space between the equal sign and the A
since = is the read macro which expands =A into (*slot* A) but leaves
a single space-surrounded = alone.

4/28/82
--- Adapted PEARL to fit Franz Opus 38.13 so that the atoms
showstack-printer and trace-printer are bound to the functions
pearlshowstackprintfn and pearltraceprintfn. (Note the addition of
"pearl" to the beginning of these).  Also changed the name of
breakprintfn to pearlbreakprintfn but it is not currently
lambda-bindable.
--- Adapted the reading of .init.prl and .start.prl files to disable
the printing of "[load .init.prl]" by lambda-binding $ldprint to nil
first (Franz Opus 38.14).

2/22/82
--- Fixed a bug in the hook disablers.   The atoms for path hooks
were misnamed in such a way that you couldn't use hidden and
visible.   Instead of *rungethooks*, and other *run...hooks*
forms, they are now *rungetpathhooks* and other *run...pathhooks*.
Note that they must be called as (XXXpath ...) and not (path XXX ...)
when used with hidden and visible.

2/21/82
--- Added ability to evaluate an atom when expecting a value of a
different type (besides integers which already worked this way).
For symbols, this is done if the atom isn't a symbol name.
For structures, it must evaluate to a structure.
For Lisp slots, it may not evaluate to an atom.
For setof slots, its value is checked for being of the appropriate
type, including depth of nesting.
--- Added the fetching function "fetcheverywhere" which gathers
ALL the buckets the object could have been hashed into and builds
a stream out of all of them (potentially five buckets).  Will wait
to build an "expandedfetcheverywhere" with its potential of
returning 5 times the-depth-of-the-hierarchy buckets.

vi: set lisp: