* Rewrite the flonum lap-generation rules to perform register-reusing,
as is already the case for fixnum rules.  Generalize some tools so
that most code can be shared between fixnum and flonum rules.

* Implement assorted changes to conform to new R4RS arithmetic.

* Redesign closure-analysis/procedure-undrifting.  New design should
perform better than old, and I believe that this one is substantially
more correct.

* Add "variable indirections", which come into play when the a
variable is known to be bound to the value of another variable which
is bound in an ancestor frame of the first variable (i.e. the first
variable can be considered an alias for the second).

* Don't inline-code procedures with rest variables.

* New pass notices when two returns are equivalent, and merges them.
Another new pass notices when the tails of two basic blocks are
equivalent, and merges them.  These two work together to eliminate
multiple copies of suffixes in various cases (most notably
predicates).

* Introduce concept that certain procedures are "boolean-valued" and
can be treated specially if they appear in the predicate of a
disjunction.

* Disconnect registerizable-parameter code because it introduces
instability in the three-stage compilation test.  This code doesn't
seem to be doing much right now anyway.

* Fix bug in "remote links": must use another addressing-mode when the
offset is too large to fit in 16 bits.

* Add rule to permit static-links to be pushed in two instructions
instead of three on the 68020.

* Change RTL constructors to reduce the number of intermediate
registers generated for trivial expressions.  Improve definition of
"trivial expression" to include certain kinds of constants.

* Change open-coded combinations in the case where they appear in
reduction position, and where the open-coding of the combination will
include a close-coded call.  The new strategy is to setup the
arguments as if the combination was close-coded, then open-code
assuming the arguments are in those positions.  This has the advantage
of allowing the internal close-coded call to be transformed into a
jump with no clumsy argument manipulation required.

* Change RTL CSE to treat small (8-bit) numeric constants as cheaper
than registers.

Initial revision

* All-new arithmetic and number I/O conforms with R4RS.

* The variable

  (access flonum-unparser-hook (->environment '(runtime number)))

accepts two arguments (the flonum and the radix), and returns either
the string representation or #f.

* `*unparser-radix*' is recognized only when it is one of (2 8 10 16),
and it affects only exact rationals.  Inexact numbers and non-rational
complex numbers are always printed in base 10.  The radix prefix is
suppressed in base 10, or in the other bases when the number's
absolute value is less than the radix.

* Written representation of compiled entries changed to show the
"block number".

* `pp' no longer accepts hash numbers as arguments; use #@ if you want
that effect (you will need to type '#@ for scode objects).

* `trace'/`break' output changed to show arguments more clearly.

Initial revision

A variety of changes to complement the installation of the R4RS
arithmetic system in the runtime system.  Most of these changes add
new expansions for arithmetic operations.

Minor reorganization.

Write the initialization code.
Add the SCHEME_UTILITY table and define the TRAMPOLINE_K_ numbers.

More cleaning of the trampoline code so that the assembly language
is easier to write.

Some cleanup of the trampoline code.

Update to use new microcode types and macros.

Add missing SCHEME_UTILITYs.
Fix a bug in comutil_link, and make the restart block match the 68k
and vax versions.
Reorganize and reformat slightly.

Change the way that SCHEME_UTILITYs are invoked, and add all of the
utilities currently being used by the compiler.

Add proc_type for the IBM RT.

Initial revision

Remove static keyword from the declaration of memory_base.  GCC does
not like something to be declared both extern and static, and it is
declared extern in object.h, included here.

Fix syntax/cond so that:
a: (cond) is legal.
b: (cond 3) gives a reasonable error message.

Fix a bug in the error exits for &> .

Add a global call/cc .

`stack-frame/ref' needs to be able to address elements in subsequent
stack frames as well as the given one.

`environment-parent' wasn't skipping over intermediate static-links
correctly.

Add new integer and flonum primitives.  Delete arithmetic ops that
will no longer be primitives.

*** empty log message ***

Fix bug which prevented correct recognition of debugging info for the
root block of a multiple-block compilation.

Add handling for dbg-variables with type `indirect'.

Change order of source directories to match order in which files are
compiled by "comp.cbf".

Add global definitions for selected flonum and integer-generic
primitives.

Add primitives `fixnum-quotient' and `fixnum-remainder'.

Add missing rule.

Add new primitive `flonum-denormalize'.

Fix bug in `grow_data_buffer': forgot to update the pointers into the
reallocated structure.

Add new primitive `flonum-denormalize'.

Fix definition of `flonum_normalize'.

Export `microcode-id/floating-epsilon'.

Eliminate hand-coded flonum parameters in favor of those in "float.h".
These new parameters can be generated by hard-params, or if the system
has <float.h> we can use that instead.

Eliminate hand-coded flonum parameters in favor of those in "float.h".
These new parameters can be generated by hard-params, or if the system
has <float.h> we can use that instead.

fixed-objects-vector now contains flonum-epsilon instead of
flonum-exponent-bits.

fixed-objects-vector now contains flonum-epsilon instead of
flonum-exponent-bits.

Microcode's fixed-objects-vector now contains flonum-epsilon instead
of flonum-exponent-bits; change microcode table code to accomodate.

Add primitives to normalize flonums, and to produce the key flonum
parameters: number of bits in significand, and smallest number which
can be added to one and still produce different result.

*** empty log message ***

Don't set `*info-output-filename*' or `*rtl-output-pathname*' in
`compiler:reset!'; they are fluid-bound instead.

Change criterion used to decide whether or not to close procedures.
New criterion is to examine `procedure-closure-context', which will be
set to #t by the closure analysis iff it decides that the procedure
needs to be closed.

Change code back to clobber the procedure-block's parent when a
procedure is undrifted.  If this is not done the operations
`block-ancestor-or-self?' and `block-nearest-common-ancestor' return
the wrong answers, and consequently must be replaced with new
operations that take the undrifting into account (yet another set of
nearly-identical operations!).

Rather than do this, I attacked the problem of why clobbering the
parent causes problems.  The losing scenario seems to be as follows:
procedure A is a child of procedure B; procedure B and procedure C are
siblings; procedure A is a free-caller of procedure C (and so is
procedure B by transitivity); procedure B has drifted up one or more
blocks, while A and C have not drifted at all.

The problem occurs when A is examined before B for undrifting: because
C is not accessible from A (due to B's drifting), it is undrifted.
Later, B is also undrifted (because it is also a free-caller of C);
note that had B been undrifted before we looked at A there would have
been no reason to undrift A.  Finally, `setup-block-types!' closes
both A and B because they have been undrifted, which allows them both
to reference their free variables; this reference is possible
-because- the original parent was not changed when the undrifting
occurred.  Had the original parent been changed at that time, the
closing would have failed.

Now many times the only reason that A and B are being closed is
because of the undrifting -- there is really no reason for them to be
closed at all (in these cases, we would have been better off never
having tried to drift procedure A in the first place).  Furthermore,
because this closing is bypassing the normal closing mechanism, some
other inconsistencies are introduced, in particular the
`virtual-closure?' bit is not cleared (it was the bug caused by this
inconsistency which forced me to reexamine this code in the first
place).

OK, so let's try this again.  Suppose we -don't- close undrifted
procedures unless there's some other reason to do so (which we can
detect by looking at the `closure-context' or `closure-reasons').
Then the way to avoid the losing scenario above is to guarantee that
we undrift B before considering A for undrifting.  This is easily
accomplished by performing a topological sort on the `free-callers'.
This sorting is sufficient because the decision to undrift A can only
depend on ancestors who are also members of the `free-callers' set.

So that's the story: I've added a topological sort of
`procedure-free-callers', changed `undrift-procedure!' to immediately
update the `procedure-closing-block', and changed `setup-block-types!'
to base the closing decision on `procedure-closure-context' rather
than (the now inaptly named) `close-procedure?'.

Fix a few random bugs.

Add new switch `HAS_MODF', and conditionalize "missing.c" to use it.
Change makefile to include "missing.o".

Add new switch `HAS_MODF', and conditionalize "missing.c" to use it.
Change makefile to include "missing.o".

Work around bug in portable representation of flonums: the flonum 0.0
is written as "06 + 0".  But this program always reads two numbers
after the sign, and furthermore treats the first one as the exponent,
and the -second- as the size in bits.  This caused it to gobble up the
type code of the next word by accident.

Fix typo which caused segmentation violation on disk-restore.

*** empty log message ***

Upgrade to handle split compiled-code files.  Improve constants
comparison.

*** empty log message ***

Initial revision

Massive rewrite of microcode.  All new object macros and organization.
New number primitives to support R4RS-compatible number system.
This microcode requires runtime version 14.58 or later.

Fix another bug in first class environment code when combined with
compile-by-procedures.

Microcode version 11 requires this runtime version.

Change algorithm used to compute prime numbers to make it more
efficient.

Eliminate dependency on return value of modifier.

Add Harris HCX type.

Initial revision

Fix bug in 1d-table/alist, and add 1d-table/for-each.

Fix bug in 1d-table/alist, and add 1d-table/for-each.

Patch remaining bug in interaction between compile-by-procedures? and
first class environment decomposition.

For the time being, compile-by-procedures? is disabled within non top
level first class blocks (ie. in-package and make-environment).
This should ultimately be fixed.

Fix bugs in fggen/{canon,fggen}.scm introduced when
compiler:compile-by-procedure? was added.

Create switch COMPILER:OPEN-CODE-FLOATING-POINT-ARITHMETIC? in order to ensure
Bobcat floating-point open-coding is only attempted for Bobcats.

Fix bug in last change.

Setup error-handling when re-evaluating arguments (as in
repeat-complex-command), and also when reading expressions from the
keyboard.

* Add Jinx's changes to support 6 bit type codes.

* Add Jinx's changes to support 6 bit type codes.  Make these the
default for HP 9000 series 300.

* Update Ppband to handle compiled code.

* Significant rewrite of parts of the bignum code.  This is the
beginning of a redesign of this code.

* Regularize some of the object selector macros.

*** empty log message ***

Change the compiler so that each top-level procedure in the input
expression is compiled separately, producing a different compiled-code
block for each.  The load-time linking is removed from the sub-blocks
to be performed in the code for the top-level expression, thus
allowing it to be discarded after the expression is evaluated; only
the code needed by the procedures is retained.

The old behavior of the compiler can be obtained by setting the switch
`compiler:compile-by-procedures?' to #f.

Change the cold-load to do purification differently -- this is needed
to guarantee that as much as possible gets purified, without purifying
storage that is temporary for the cold-load.  This is done by leaving
everything in the heap until the cold-load is essentially finished,
then purifying everything at once.

Abstract out the operation that decides how to purify compiled code,
call it `load/purification'.  This is used by the cold-loader.

(fasload/update-debugging-info): Change this so that it makes a single
copy of the new filename which is shared among all of the
compiled-code blocks in the file.  For per-top-level-procedure
compilation, this makes a big difference.

Make `load-debugging-info-on-demand?' affect only
`compiled-procedure/name'.

Fix classic bug: incorrect interaction between stream and side-effect.

(sf-conditionally): Don't echo "up to date" message unless
specifically requested to.

(sf-conditionally): Don't echo "up to date" message unless
specifically requested to.

* Compiler now knows how to emit a different form of
`dbg-info-vector', which contains not only the compiled-code blocks
(as before), but also a pointer which is the root to be used if the
code is to be purified.  The runtime system needed to be changed to
accomodate this.

* Change default for `load-debugging-info-on-demand?' back to false.

* Fix `scode-constant?' to handle compiled-code-entry objects
correctly.

Change "FASDumping" message to "Dumping", to match change to
"FASLoading" message.

Must replicate export from `(package)' here.

Recode procedures that use `caar', `cadr', etc. to use sequences of
`car' and `cdr'.  This produces more efficient code since `sf' won't
inline-code these procedures in this file because they are defined
here.

Optionally allow comments to appear with bogus syntax.

For #@<n> -- if the object referred to is SCode, quote it so that
evaluating the result of the parse produces the object.

Fix stupid typo.

* Implement `entity' data abstraction to manipulate the microcode's
data type of that name.  Change everything to use it.

* Implement new procedure `gc-clean' that interleaves `gc-flip' and
`trigger-secondary-gc-daemons!' until everything is reclaimed.  Change
`disk-save' to use it.  Cause this operation to be invoked when
running out of memory.

* Add secondary GC daemons to clean up debugging info, and to reset
`prime-number-stream'.

* Extend the procedures `procedure-lambda' and `procedure-environment'
to handle compiled procedures by using debugging information if it is
available.

* Extend all the procedure operations to handle entities.

* Change `pp', `pa', and `->environment' to accept any procedure as an
argument; previously these only accepted compound procedures.

* Change the unsyntaxer to handle compiled expressions by using their
debugging source code if it is available.

* Change name of `*compiler-info/load-on-demand?*' to
`load-debugging-info-on-demand?', and make it be #T by default.

* Change `load' to print "loading..." message for source files as well
as binary files.  These messages are controlled by
`load/suppress-loading-message?'.

* Change `environment-bound-names' to ignore the binding which is used
to hold an environment's package.

* Fix bug in `make-null-interpreter-environment' which prevented it
from being called more than once.

Canonicalization of expressions causes certain expressions to be
rewritten in a form that is unsuitable for use as the debugging source
code.  Change the canonicalization code to save the original code.
Change the fg-generator to use the original code as the debugging
source instead of the code that it is compiling.

Special case: don't bother generating a new environment when
evaluating a constant.

Bug report from Jinx: `prealloc' may change the file pointer, so the
hp-ux code that uses it must check.

*** empty log message ***

Move some of the window-control variables to the files in which they
are used.  Rename `cursor-centering-threshold' to `scroll-step' for
compatibility with Emacs.  Delete the disfunctional command
`toggle-screen-video'.

Suppress redisplay of minibuffer messages during keyboard-macro
execution.

Export variable `completion-auto-help' to (edwin) package.

Sort list of key bindings before printing it.

* Rewrite core group operations, image operations, window operations,
and the regular-expression compiler to use fixnum arithmetic.  This
has a pronounced performance effect.

* Change "decls" to pass integrable-procedure definitions between a
few crucial files.

* New variable `enable-emacs-key-names' controls whether keys are
displayed using Emacs-style names or Scheme-style names.  The default
is Emacs-style.

* C-h C-b now runs `describe-bindings' as in Emacs.

Change file-loading prompts to use trailing dots.

When subtracting register A from register B, where register B is not
dead, must always allocate a new alias.  Stupid trick that was being
pulled involving `exg' instruction could never have worked.

Initial revision

* Change internal names of various user procedures to correspond to
the external names:

edwin edit
edwin-discard-state! reset-editor
edwin-reset create-editor
edwin-reset-args create-editor-args
edwin-set-display! set-editor-display-type!

The external interface to Edwin now consists of the following
procedures:

(EDIT)
(RESET-EDITOR)
(RESET-EDITOR-WINDOWS)
As before.

(EDITOR-DISPLAY-TYPE)
Returns the display-type of the current editor.  This is
either a symbol or #F.

(EDITOR-DISPLAY-TYPES)
Returns the names of all the known display types, in a list.

(CREATE-EDITOR DISPLAY-TYPE . ARGS)
Initializes a display of the given type, passing the args to
the screen-construction code.

CREATE-EDITOR-ARGS
This variable is a list of arguments to be passed to
`create-editor' if it is necessary for `edit' to call it.

* Add new command `define-command', which is solely a placeholder for
the documentation string it possesses.

* Implement editor variable `inhibit-startup-message' -- see the
documentation string.

* `enable-transcript-buffer' is now #F by default -- it is normally
enabled in Scheme-Interaction mode only.

* Change the definitions of the commands `set-environment' and
`set-syntax-table' to set the editor variables `scheme-environment'
and `scheme-syntax-table'.  The old behavior of these commands is
available via the new commands `set-repl-environment' and
`set-repl-syntax-table'.  Other new commands are
`set-default-environment' and `set-default-syntax-table'.

* Change definition of `scheme-syntax-table', allowing it to be a
symbol which is regarded as a variable to be evaluated relative to the
evaluation environment.

* Add init files, which are found in "~/.edwin".  The new global
variable `inhibit-editor-init-file?' (defined in the system global
environment), prevents your init file from being loaded if it is true.

* Add new "find-file initialization" hack: this is invoked whenever
`find-file' or `revert-buffer' is done.  The reason for this hack is
to allow a database file to contain evaluation environment and
syntax-table information for the editor.

When a `find-file' (or `revert-buffer') is done, the editor looks in
the directory of the file for one of two files:

1. If the file's name is "foo.scm", the editor looks for a
file "foo.ffi" (-only- if the type is ".scm").  Otherwise,

2. The editor looks for the file ".edwin-ffi".

If one of these files are found, it is loaded into the editor (if the
first file is found, the second is ignored).  The loading is performed
in the (edwin) package with `edwin-syntax-table'.  The result of
loading the file must be a Scheme procedure which accepts no
arguments; this procedure will be added to the buffer's
initializations, to be performed the next time the buffer is selected.

The procedure `standard-scheme-find-file-initialization' is useful in
this regard.

It should be straightforward to automatically generate these files
from the package-modeller.

* The binding for `describe-command' has been changed from `C-h d' to
`C-h f' for compatibility with Emacs.

* Under some circumstances, files in the user's home directory tree
will be displayed using the "~/" notation.

* Implement overlooked command `x-set-position'.

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

* Change definition of `load-edwin-file' procedure to make it more
generally useful for loading files into the editor.  Similar changes
to the `load-file' and `load-library' commands.

* Bullet-proof the evaluation environment and syntax-table code so
that they signal an editor-error if unable to be resolved to the
appropriate kind of object.

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

* Cause a modeline-event to occur whenever a buffer's clipping is
changed.

* Change handling of `edwin-initialization' so that the code is run
inside the command-reader loop -- thus making sure that all of the
editor's dynamic-state is bound.

* Fix bug in command-reader: undo boundaries were not being marked
when they should have been.

* Change `kill-buffer' to pick a different replacement buffer for each
of its windows, if possible.

* Change `environment-link-name' to call `->environment' on its two
environment arguments.

* Move `vector-binary-search' to the global environment.  Fix a bug in
it -- a confusion between the < used for comparing integers, and that
for comparing keys.

* New variable `load/suppress-loading-message?' prevents the file
loader from printing the "loading -- done" messages.

* Implement `pathname-relative?' which accepts two pathnames; if the
second has a directory part which is a "prefix" of the first, this
returns a copy of the first pathname with the "prefix" removed.
Example:

    (pathname-relative? (->pathname "/usr/bin")
(->pathname "/usr/"))
   ==> #[pathname 5 "bin"]

* Change `environment-link-name' to call `->environment' on its two
environment arguments.

* Move `vector-binary-search' to the global environment.  Fix a bug in
it -- a confusion between the < used for comparing integers, and that
for comparing keys.

* New variable `load/suppress-loading-message?' prevents the file
loader from printing the "loading -- done" messages.

* Implement `pathname-relative?' which accepts two pathnames; if the
second has a directory part which is a "prefix" of the first, this
returns a copy of the first pathname with the "prefix" removed.
Example:

    (pathname-relative? (->pathname "/usr/bin")
(->pathname "/usr/"))
   ==> #[pathname 5 "bin"]