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"]

environment-link-name is no longer a primitive.

Cause `edwin-initialization' to be executed inside the command loop so
that all of the editor's dynamic-state is bound.

* Arrange for local bindings of current buffer to be undone when
leaving the editor; this prevents the local bindings from becoming
global when (reset-editor) is done.  Perhaps it might be useful to
remember the original global binding, and reset each variable to that?

* Change the commands `list-buffers' and `buffer-menu' to accept a
prefix arg which limits their listings to buffers that are visiting
files.  Perhaps buffer-menu mode should define the g key as Dired
does?

* Change mouse button events to invoke commands in the normal way,
binding a `current-button-event' to tell the commands where the mouse
was when they occurred; this event defaults to the location of point
so that these commands make sense when invoked by other means.  Cause
the editor to beep and do nothing if a mouse button is not bound to
any command, and if the button is located in the "decoration" of some
editor window (i.e. the modeline or vertical border).

* Change `define-key' to accept command-names (or commands) as
arguments when defining mouse buttons.  Change `define-key',
`define-prefix-key', and `define-default-key' to accept mode objects
as well as mode-names.

* Add new commands:
debug-clean-marks
debug-show-standard-marks

* Change the buffer redisplay code so that buffer-cursor-y is set only
when a buffer is disconnected from a window.  Further, save point's
index with the coordinate, and ignore the information if point changes
before the information is used.

* Implement new operation `mark-temporary!', which removes a permanent
mark from the marks list.  Use this operation to get rid of the marks
used by buffer-windows when they are no longer in use.  In order for
this to work, change the buffer-window code so that it never passes
one of these marks to anyone.  The only user-visible change is to
replace the operations `window-start-mark' and `window-end-mark' with
`window-start-index' and `window-end-index'.

* Add new procedure `clean-group-marks!' to delete GC'ed marks from
the marks list.

Undo recent change which tried to replicate Emacs' algorithm for
deciding when to use inverse-video in the modeline.  The attempt
failed, and I don't see an obvious way to make it work.

Use new procedure `integer-round' when computing the buffer position
percentage for the modeline.

Formatting.

Formatting.

Formatting.

Implement `(flush-purification-queue!)', which tries to purify
anything that is in the purification queue.  When this procedure
returns, the queue should be empty.  Call this procedure after the
cold load, and after the "system-loader", to guarantee that the items
loaded are purified before being used.

*** empty log message ***

(disassembler/write-compiled-code-block): don't require debugging info.
The disassembler can run without it.

Fix bug in previous changes.

Fix longstanding bug in compilation of predicates.  Expressions like
this

  (if (if (bar numerator)
  (foo denominator)
  (not (foo denominator)))
      numerator
      denominator)

would compile incorrectly by making both calls to `foo' have the same
continuation.  This should have been noticed as an error because the
continuation entry hooks for that continuation were attached to both
expressions: when they were combined with the call to `bar' the hooks
were used to attach the continuation to the enclosing expression --
but each side of the test was attached twice.  Error checking in the
node-attachment code would have caught this one at compile time.

The new code generates a new continuation for the call to `foo' whose
result is inverted, and then codes the `not' using a PCFG and two
constants -- all of which gets folded out later, resulting in the
desired code.