dep: Major overhaul.

The previous implementation was just fundamentally incorrect.  The new
version is somewhat better organized (though fairly similar
superficially) and documented, and actually (I think) correct.

Changes include:

  * DELAY-RECOMPUTING-DEPS has been renamed to WITH-DEPS-FROZEN.  The
    new version is semantically slightly different: it's the only point
    which actually triggers recomputation.  It has also grown the
    ability to defer its body until after the current recomputation
    phase is complete.

  * It is now a (diagnosed) error to attempt to modify a dep during
    recomputation; modifications can be deferred explicitly, though
    doing this sort of thing automatically seems a bad idea.

queue: Allow stuff to be pushed on the front.

weak: Kill race condition in ECL weak pointer implementation.

dep: Use weak pointers for maintaining dependents.

weak: Uniform interface to weak pointers.

dep: Provide semantics for setting the value of a non-leaf dep.

The behaviour is that we recompute the rest of the system as usual, but
retain dependencies on the deps that the value-function examines.

We do more: it's now possible for cycles to occur in the dependency
graph, as long as a value is explicitly set somewhere in the cycle,
which effectively breaks it.  Cycles of purely computational deps are
still considered to be meaningless, and therefore forbidden.

Finally, we note that DELAY-RECOMPUTING-DEPS can be used to set
explicitly the values of a number of deps simultaneously, even if their
value functions would otherwise forbid it.

queue, dep: Dependent-value management.

Queues are useful data structures in their own right and a Lisp
implementation is handy.

Deps were inspired by Ken Tilton's Cells, but lack the latter's CLOS
trappings and probably its hairier features.  In particular, cyclic
dependencies are not permitted.

sys-base: Support for cl-launch.

runlisp is hereby deprecated.

optparse: Hack pretty-printing for CLisp.

CLisp's pretty printing is buggy, but we can get much closer by
doing some simple reordering of the existing code.

optparse: Prettify the error reporting.

Rather than have enormous strings in the source, use #.(concatenate ...)
to build them out of smaller bits.

Track changes to runlisp.

sys-base is now less dependent on runlisp for setting itself up.
It doesn't run as well as it does through runlisp but it does at
least work.  (The code in sys-base is a clone-and-hack job of
the guts of runlisp: try to keep them in sync.)

Runlisp renamed its command-line arguments variable, to avoid the
annoying conflict with CMU CL's ext:*command-line-strings*; track
this change.

Fix constant-resetting.

There's a new macro defconstant* which checks a predicate before
actually resetting.  But alas the only offender is in infix.lisp, for
which we have a policy of not requiring external dependencies, so I've
expanded the macro by hand.

Upgrade everything for SBCL.

optparse: Expose function for printing options.

Also don't fail if no help is defined, and make the test program output
a little more useful.

heap: Simple binary heaps for priority queues and so on.

aa-tree: Simple balanced binary tree.

I've implemented Andersson trees, which are a particularly simple kind
of balanced binary tree, with the usual performance guarantees for such
things.

mdw-base (functionify): Coerce function designator to function.

Kill trailing spaces.

Merge branch 'master' of /home/mdw/public-git/lisp

* 'master' of /home/mdw/public-git/lisp:
  base: with-parsed-body, different interface.
  collect: Provide functional interface for collectors.

base: with-parsed-body, different interface.

collect: Provide functional interface for collectors.

mdw-base (stringify): Use princ-to-string.

mdw-base (whitespace-char-p): Work out the whitespace characters.

This saves us needing a list of the whitespace characters known by
each individual implementation.

base: New macro setf-default.

I've thought about adding this for a while, and it just became worth it.
Deployed where sensible.

base: compile-time-defun should define in the interpreter.

Merge branch 'master' of git+ssh://metalzone.distorted.org.uk/~mdw/public-git/lisp

* 'master' of git+ssh://metalzone.distorted.org.uk/~mdw/public-git/lisp:
  sys-base: Portability fixes again.
  Porting stuff.

collect: New functions collect-append and collect-nconc.

sys-base: Portability fixes again.

  * Make sure *command-line-strings* is bound to something sane, even if
    runlisp isn't doing its thing.

  * As a result, use *lisp-interpreter* to decide whether runlisp is
    actually present.

Porting stuff.

  * Change to use new runlisp system (rather than the bizarre hackery of
    the same name which we had previously).

  * Support ECL, as much as is sensible.

Merge branch 'master' of /home/mdw/public-git/lisp

* 'master' of /home/mdw/public-git/lisp:
  optparse: Process docstring and declarations correctly in defopthandler.
  gitignore: Ignore CLisp FASL files.
  Various: Try porting the code to CLisp.

Conflicts:

mdw-mop.lisp: Trivial conflict in the defpackage stanza.

optparse: Process docstring and declarations correctly in defopthandler.

Previously, the docstring got left inside the with-locatives form, which
is a shame.

gitignore: Ignore CLisp FASL files.

Various: Try porting the code to CLisp.

Not entirely successful, largely because the CLisp pretty-printer seems
quite badly broken.

mop: New macro with-slot-variables.

The docstring describes it pretty well: the idea is to cache slots in
correctly-typed lexical variables and then write them back after
processing the body forms.

mop: Rearrange a bit.

Put the miscellaneous stuff before the metaclass hacking.

Merge branch 'master' of git+ssh://metalzone.distorted.org.uk/~mdw/public-git/lisp

* 'master' of git+ssh://metalzone.distorted.org.uk/~mdw/public-git/lisp:
  asdf: Provide more package information and dependencies.
  sys-base: Only use the extensions package from CMUCL.
  base: Export unsigned-fixnum as a handy type to have.
  mop: Use CMUCL's `mop' package instead of `pcl'.
  base: New `until' macro does the obvious thing.

optparse: Make enum opthandler take an evaluated list.

... rather than an unevaluated &rest argument.  This makes it rather
more suitable for dynamic lists of things.

asdf: Provide more package information and dependencies.

sys-base: Only use the extensions package from CMUCL.

We'll have to do something special for other Lisp systems.

base: Export unsigned-fixnum as a handy type to have.

Merge branch 'master' of git+ssh://guvnor.distorted.org.uk/~mdw/src/lisp

base: New `until' macro does the obvious thing.

infix: Overhaul the readtable installer.

Let it cope properly with different start and end characters (including
marking the end character as a terminating macro), and be willing to
install as a dispatching macro character if requested.  Also changed
the defaults to {...}, since these are explicitly reserved, and look
appropriate.

infix: Replace multiple-value constructs with a single bind.

This lets you do several layers of binding in one swoop, which is quite
shiny, really.  This covers multiple-value-bind and let (both the
single and multiple variable cases, if you're willing to use `values')
and multiple-value-setq is unnecessary since values is setf-able.

infix: Remove redundant progn in loop expander

infix: Make delim's requiredp argument optional rather than keyword.

This makes the code rather less messy, I think.

mop: Use CMUCL's `mop' package instead of `pcl'.

I must have gotten that name from an old source of information.

safely: Temporary file name changes.

  * Use CL pathname magic to mess only with the name component of paths
    rather than putting extensions on the end, which seems to confuse
    CMU CL.

  * Use a Scsh-like fresh-name generator where it matters, rather than
    hoping (in the case of move-aside names).  This means generating old
    names later on in the process, but that seems OK.

  * Do the file copy in plain Lisp using read/write-sequence rather than
    Unix hacking.  There's a hack here for CMU CL to use link(2) for
    efficiency's sake, but it's not strictly necessary.

This means that the whole package is, in fact, standard Common Lisp.
Yay.

mop: New metaclass for singleton classes: ensures only one instance.

show: Handle multiple values correctly.

While we're at it, make sure the output is pretty-printed in an
attractive way, and print semicolons down the left hand side to protect
any weird characters which appear from messing up the REPL state.

mop: Handy function for making modified copies of instances.

mop: In print-object-with-slots, use write for the slot values.

Also print unbound slots as `#<unbound>'.  This is what the SLIME
inspector does and it makes sense.

mop: Use mdw.base, because it contains useful debugging stuff.

Not that there are any bugs which need fixing, of course.

mop: Remove &allow-other-keys from methods.

A more careful reading of the CLOS method congruence rules suggests that
these mess up the keyword validity checking.  Which is a shame.

collect: Declare results as having type list.

It seems that CMU CL can't work this out on its own.  I suppose that's
not completely surprising.

base: Provide fixnump function.

CMU CL already implements fixnump in the extensions package  Provide it
explicitly here anyway, for other implementations.

Quite why this function isn't in the Common Lisp spec anyway is still a
mystery.

mop: Implement a class which automatically defines a predicate.

I've found myself typing

  (defgeneric foop (thing)
    (:method (((thing foo)) t))
    (:method (((thing t)) nil)))

too many times.  Now I just put `(:predicate foop)' in the class
definition and forget about it.

mop: Don't pass filter functions the target object.

Firstly,  it's now what the docstring for `filtered-slot-class-mixin'
says, and it seems to be less useful.

anaphora: Rename package to just `anaphora'.

I think that, for once, nothing else needs to be updated for this
renaming. ;-)

parse-body: Allow docstring to be mixed in among the declarations.

Ooops.  I've just re-read CLtL, and found that the top of most forms
allows the docstring to be mixed in among the declarations in any old
order, rather than docstring-first, declarations-after.  And I've also
just read Hyperspec 3.4.11, which explains that a final string isn't a
docstring, so handle that correctly too.

So rewrite the code to handle this case.  It means that macros will
probably reorder the forms in their output, but that's all right.

While we're here, glue all the declarations into a single `declare'
form, which makes it easier to put the declarations into some other kind
of form such as `declaim'.  And provide a keyword argument
:allow-docstring-p (defaulting true) to disallow docstrings.

Add some MOP hacking.

  * Abstract classes.

  * Filtered slots -- i.e., all slot writes can be passed through a
    canonifying filter.

collect: Reduce consing.

The old collection system made a pair of cons cells: the metadata and a
random `head'.

        ,--------------------------.
        |                          |
  meta  |     head                 v  tail
  +---+-|-+   +---+---+          +---+---+
  | * | * |   |nil| *-----...--->|   |nil|
  +-|-+---+   +---+---+          +---+---+
    |           ^
    |           |
    `-----------'

But we can do better: we can squidge the head and metadata nodes
together.  If we start out at

      head tail
      +---+---+
  ,-->| * |nil|
  |   +-|-+---+
  |     |
  `-----'

we can just insert more items by updating (cdar head)...

  head                               tail
  +---+---+   +---+---+         +---+---+
  | * | *---->|   | *----...--->|   |nil|
  +-|-+---+   +---+---+         +---+---+
    |                             ^
    |                             |
    `-----------------------------'

base, optparse: Various option-parsing enhancements.

  * `case2' clauses can optionally bind a variable to its scrutinee.

  * New function `option-parse-return' to return a value from
    `option-parse-next'.

  * Enhance `options' parse-option-form' to understand disambiguating
    keywords arguments for all option slots.  This also means that these
    things can be set from expressions rather than constants.

  * Default the `define-program' variables sensibly.

  * Make `do-options' use `let*/gensyms'.

  * Make the optparse test use the convenience macros.

  * Rename `help-opts' to `help-options'.  Just because.  And tidy up
    the code a bunch.

Reformat all the docstrings.

Indent subsequent lines.  Makes the code look prettier, and makes diff
function headers more useful.

collect: Oops, forgot to export `collect-tail'.

collect: Whitespace rearrangement.

base: New macro for parsing function bodies.

collect, unix: Rename `mdw.collect' package to just `collect'.

base, optparse: Introduce `case2' macros.

  * base: Add new `case2' macro, for fetching two values, switching on
    one and binding the other.  Also add `ecase2' to do the obvious
    thing.

  * optparse: Rewrite `do-options' to use `ecase2' (or `case2').

base: Fix bug in `while'.

Did I ever use this?

base: Reorder a bit.

Nothing significant actually changed.

base: Export `nlet' and `while'.

Should have done this a while ago.

unix: Fix crap typo in header comment.

optparse: Various enhancements.

  * General cleaning up.

  * Removal of redundant handling of option docstrings in both options
    macro and parse-option-form.

  * New feature: option macros can insert several options.

  * New suite of standard option-handling things for usual command-line
    programs.  Should be sufficient for most purposes.  I'll probably
    invent a subcommand system later when I get a feel for what's
    wanted.

infix: Reader macros for infix expressions.

safely, optparse: Rename packages.

General tidying and prettifying.

Ignore boring files.

mdw-base: Update-in-place macros.

These are largely here because the infix reader stuff wants them, but
it's handy enough, probably.

optparse: Use parse-integer in parse-c-integer.

CMU CL's parse-integer has cleverness for parsing bignums relatively
quickly.  It's not as scary as Catacomb, but not bad.  Use it instead of
the grotty hack we had previously.

syscall: Don't require (function ...) for the name argument.

In fact, don't allow it.

safely: For -without-moaning functions, just do it and catch errors.

... rather than probing first and hoping for the best.

Kill the unix-try macro.

Instead, export sys-* functions which do the right thing.  Fix safely to
match.

safely: Blank lines make code easier to read.

Merge branch 'svn'

anaphora: Add anaphoric macros.

sys-base: Expand hard-exit a bit.

base: Implement named-let and while.

Extract Subversion ignore data.

Initial checkin.