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.