lib/sod-hosted.c (sod_makev): Use two statements rather than tricky expression.

Comes out shorter too.

lib/sod.h (sod_sublassp): Fix function description.

The corresponding comment in the implementation file is already correct.

src/parser/floc-proto.lisp: Use correct function for constructing conditions.

configure.ac: Complicate ASDF version-number generation.

I've started prefixing a future-version-~ to development version
numbers, rather than maintenance pre-releases.  Adjust the ASDF version
synthesis to cope with this.

debian/: Ship `symbols' file for better downstream dependency versioning.

debian/changelog: Prepare for next version.

debian/: Bump to Debhelper 10.

For some reason, the `compat' level and the `Build-Depends' bound were
inconsistent.  Oops.

Static instance support.

src/class-output.lisp: Leave `*instance-class*' unbound at top-level.

src/class-make-{proto,impl}.lisp: Don't always add initializers to classes.

Add a switch `:add-to-class' to inhibit adding the new initializer
object to its class.

(The class is still necessary because it's in control of initializer
construction: otherwise I'd do this by passing a `nil' class.)

src/method-impl.lisp, etc.: Add a `readonly' message property.

If you have a `const' instance, it's useful to be able to send it
messages, so add a facility for marking messages as not modifying their
receivers.

src/method-{proto,impl}.lisp: Abstract out the receiver type.

The code used to just assume that receiver (`me') arguments had type
`CLASS *'.  This is about to change...

c-types-proto.lisp (canonify-qualifiers): Delete `nil' entries.

Now you can decide whether to include a qualifier by saying `(and COND
:const)' or similar, and the `nil' if COND is false will be swept under
the rug.

doc/list-exports: Use `documentation' to find more categories.

doc/check-docs (scansyms): Stop trying to parse at `Leaked slot names'.

doc/output.tex: Add a missing member reference in vtable initializer.

doc/: Switch to a manually maintained bibliography database.

Actually, the database is maintained mostly by Emacs's BibTeX mode.  In
particular, I (mostly) allow it to choose the citation keys, rather than
using Beebe's somewhat annoying key format, so hack up the document to
match.

configure.ac, doc/Makefile.am: Ship the bibliography style.

Well, the machinery to generate one, anyway.

debian/: Fix build-dependencies for building the manual.

configure.ac, doc/Makefile.am: Overhaul LaTeX building.

Check to see whether all of the things we need are available: don't try
to build the manual unless we have them.

doc/sod.tex: Print the build version in the inside header.

doc/...: Fix `\textbar' properly, and use plain `|'.

The `\grammar' command wasn't the right place to hack this, since
`\syntax' also needs fixing.  Instead, patch `\syn@shorts' to do the
right thing.

Once this is done, use `|' rather than `@|' in syntax displays (not the
Lisp ones!).  Also, use text rather than maths spacing consistently, by
replacing `$| \cdots |$' with `| $\cdots$ |' throughout.

doc/sod.sty: Don't convert `_' to `-' in `\descref' text.

The conversion is necessary in the label, but not the text.

doc/output.tex: Replace the old output-item comments with big tables.

Now the output structure is actually documented (somewhat) properly.
All I have to do is keep the tables up-to-date somehow.

doc/output.tex: Fix synopsis for `sequence-output' macro.

doc/sod.sty: Reintroduce toplevel `\kill' into `prog' environment.

Annoyingly, `longtable' steals `\kill' for its own purposes.  Put it
back when we want it.

doc/sod.sty: Reformat `\@prog' so that we can add more stuff.

doc/sod.tex: Include `longtable'.

We're going to need it.

doc/sod.tex: Leave a space for an `\includeonly' directive.

doc/sod.tex: Cope if `\pkgversion' isn't defined.

src/method-proto.lisp: Reflow a docstring paragraph.

src/class-output.lisp: Add docstrings to the `hook-output' methods.

src/class-output.lisp: Split up `hook-output' on `sod-class' and `:h'.

Introduce five new generic functions to carry most of the load.  The
remaining `hook-output' functions all seem simple enough to be replaced
as necessary.

src/class-output.lisp: Replace `Classes' with a more helpful title.

src/output-proto.lisp, etc. (hook-output): Use standard combination.

This will let subclasses selectively override portions of the basic
output machinery.

The existing implicit traversal is now done via `:after' methods.
Existing hook methods which engaged custom traversal have been split out
into separate `:after' methods so that they don't get overridden by
accident.

The main output-class-to-header method (i.e., `hook-output' specialized
on `sod-class' and `(eql :h)') is huge and could usefully be split into
smaller pieces which can be overridden separately.

src/module-parse.lisp (code): Allow setting constraints without a fragment.

Add new syntax for adding constraints to the output sequencer without
actually producing any output at all.

src/module-parse.lisp (code): Prepare for an additional variant.

Some more minor refactoring: pull NAME [CONSTRAINTS] `{' FRAGMENT
`}' into an `or' subitem.

src/module-parse.lisp (code): Hoist complex sub-items out of main parser.

doc/syntax.tex: Give the REASON in a `code' definition a name.

debian/control: Replace ancient `${Source-Version}' substitution.

Makefile.am, test/Makefile.am: Add missing cleaning.

test/Makefile.am: Make the stanzas more consistent.

We now have

  * TESTS
  * check_PROGRAMS
  * EXTRA_DIST
  * nodist_mumble_SOURCES
  * BUILT_SOURCES
  * mumble.out
  * check-local
  * -include
  * CLEANFILES

in that order.

test/Makefile.am: Disentangle `test' from `bad', and `rat' from `kwbench'.

Ugh!

test/Makefile.am: Distribute `bad.sod' and `bad.ref'.

Oops.

Reorganize some of the more random files.

  * Move `sod.m4' and `sod.pc' into `lib/', because they're concerned
    with the C library.

  * Move `asdf-hack.lisp' and `emacs-hacks.el' into `src/', because
    they're concerned with Lisp.

sod.m4: The ACTION-IF-LIBRARY-FOUND should replace the default.

This is the behaviour I documented, but I failed to update the code to
match.

sod.m4: Provide an Autoconf snippet for dependent packages.

vars.am: Add missing `-M' in suffix-rules command.

src/parser/parser-proto.lisp: Fix bogus indentation.

src/lexer-{proto,impl}.lisp, src/pset-parse.lisp: Other C operators.

Add almost all of the familiar C operators.  Some of these need their
own tokens added.  There's a lexical gotcha now, since `x << y' and
`x < < y ...' mean different things: the former parses as `x shift-
left-by y', while the latter parses as `x is-less-than some-type-
beginning-with-y'.

doc/syntax.tex: Reformat the various grammar fragments.

  * Move the prose descriptions to the final case (e.g., for
    <string-literal-char> and <char-literal-char>).

  * Present alternatives on a single line where possible.

  * Use centre-level dots consistently to denote elisions of
    alternatives.

  * Space alternatives consistently.

doc/refintro.tex: Explain what parentheses mean in production rules.

They're used in the actual grammar, so this is probably a good idea.

doc/refintro.tex: Split the syntax notation into subsections.

I'd be happier if these were subsubsections, honestly.

doc/refintro.tex: Fix indexed-nonterminal argument abbreviation.

The thing with the unfinished ellipsis causes a very unpleasant effect
where dots at different heights are separated only by a comma.
Reluctantly, I fix this by replacing the nearly approachable `\$alpha |
\beta | ...' notation with numeric superscripts.

doc/refintro.tex: Hoist $\epsilon$ to the top of the metasyntax section.

It's important, and liable to be lost otherwise.

doc/Makefile.am: Add missing entry for `refintro.tex'.

src/pset-parse.lisp: Replace `dispatch' by some more elementary functions.

This turns out to be an overall saving in terms of lines of code, as
well as being more versatile.  The price is that we've lost the specific
per-operator type mismatch error, but I think that's worth paying.

Somewhat sneakily, I've also fiddled with the operator precedence
numbers, so as to leave more space for other operators, though the
relative precedences are unchanged.

src/pset-parse.lisp: Add a little vertical space and commentary.

src/pset-parse.lisp: Parse and evaluate expressions in two separate steps.

Previously, we'd parse and evaluate expressions in an interleaved
fashion: the items on the parser's value stack were (TYPE . VALUE)
pairs, fully evaluated.

This causes a couple of problems.

  * Firstly, and most obviously, it means that we can't have operators
    which perform short-circuit evaluation -- sometimes failing to
    evaluate their operands.  This doesn't seem like such a big deal:
    after all, we don't have any assignment operators.  But we /do/ have
    an escape to Lisp's `eval' function via the `?' SEXP primary, and
    evaluating Lisp can have arbitrary side-effects.

  * Secondly, it makes error handling more annoying.  There's logic
    throughout for reporting continuable errors and then returning a
    `:invalid' marker.  This logic is currently concentrated in the
    internal `dispatch' function, but continuing to maintain this
    convention if and when we crack open `dispatch' to implement more
    complex operators would be messy.  (I know: I've tried it.)

Deferring evaluation to a second pass solves both problems.  Control-
flow operators can just decide not to evaluate operands they're not
interested in.  And errors can be caught and turned into an immediate
return from the `parse-expression' toplevel.  (The `:invalid' convention
is still part of the external interface, for good reason, but it we can
just use Lisp's non-local control flow forms inside.)

The way this works is unsurprising.  The `value' stack now holds thunks
which will calculate and return their values when invoked.  Operators
close over the thunks for their operands and produce a new thunk which
will call the operand thunks as required to calculate their result.  The
handling of `:invalid' in `dispatch' can be eliminated in favour of a
`restart-case' form around invoking the final value thunk.

The only remaining clever footwork is in `?' SEXP: if there's a read-
time error then we yields a thunk which immediately escapes and returns
`:invalid' from the toplevel.  (We do this using `continue' on the
grounds that the read error has already been reported -- along,
probably, with a lot of knock-on parse errors while we try to
resynchronize with the source.)

src/pset-parse.lisp: Remove the pointless `flet' function.

It's only used once and doesn't achieve very much of use.

src/pset-parse.lisp: Bring `dispatch' within `parse-expression'.

There's nothing to be gained from keeping it outside: the `expr' parser
caching works on entry to the parser, rather than once only.

src/parser/parser-expr-proto.lisp: Get `expr' to cache operators.

Add a new feature to `expr': if you write the operator parsers in a
special way, it will cache the operator objects around the whole
parser.  Use this in the property-set expression parser.  (Admittedly,
it previously cached the operators at load time, but there's an upcoming
change which will prevent this anyway.)

src/pset-proto.lisp: Print type names in lowercase in error messages.

src/pset-impl.lisp: Accept `yup' and `nope' as booleans.

I may draw the line at `yarp' and `narp'.

src/pset-impl.lisp: Convert strings to booleans using a hash-table.

src/: Use gender-neutral language in commentary.

src/frontend.lisp: Remove unnecessary `:shadowing-import-from'.

When I unified the two `int' symbols, I forgot that this would have been
necessary.

doc/syntax.tex: Clarify the term `root class'.

doc/syntax.tex: Fix source formatting.

doc/clang.tex: Remove redundant `\textbf{...}' inside `\thd'.

I noticed that I have a rather unpleasantly clone-and-hacked `\thd'
macro which already sets its argument in boldface; so there's no point
in emboldening it further.

Recognize the <stdint.h> integer types.

There's a lot of these, and writing the whole lot out by hand is really
much less rewarding than writing a variety of Cartesian-product-
expanding programs.  The really fun part was the TeX version...

doc/clang.tex: Squish the `\desclabel' mess for simple C types.

No idea why I tolerated all of the `c-type-MUMBLE' repetition the first
time.

test/kwbench.c, etc.: Tidy up and publish the keyword benchmark I used.

src/module-impl.lisp, src/module-parse.lisp: Set module environment better.

Previously, `read-module' halfheartedly set `*package*' and
`*readtable*'.  Do better, by setting lots of influential variables as
module variables with appropriate initial values.

src/utilities.lisp, doc/misc.tex: Fix up `find-duplicates'.

  * Fix the inconsistent ordering behaviour which was the cause of a
    recent bug.  The implementation for lists is rather ugly, but it
    works without consing, which is a bonus.

  * Document the ordering behaviour.  And warn users away from non-
    hash-table-friendly `:test' functions more firmly, especially on
    lists.

src/class-finalize-impl.lisp: Check for duplicates with the right `:test'.

I noticed that Sod failed to diagnose a class containing duplicate slot
names.  Thinking that this was a stupid omission, I kludged a check into
`make-sod-slot' (and a matching check into `make-sod-message'), thinking
that it seemed rather difficult to provide a proper location of the
existing definition.  Then I tripped over this code, and wondered why it
wasn't working.  Of course, the problem was that it tries to compare
strings using `eql'.  Fix this.

Use `equal' here rather than the more specific `string=' because (a)
`find-duplicates' uses a hashtable if the :test function is suitable,
and (b) it reports the duplicates in the right order in that
codepath.  (That the other codepaths don't work the same way is, of
course, a bug which should be fixed.)

src/parser/parser-proto.lisp: Muffle a `&optional ... &key ...' warning.

Somehow I missed this one.

src/package.lisp, etc.: Muffle warnings about exported symbols etc.

SBCL gives big warnings if you re-evaluate a `defpackage' form and it
doesn't cover all of the exports and package uses.  I simply don't care.

src/method-proto.lisp: Maybe ignore the layout pointer in trampolines.

If the last trampoline is meant to invoke the delegation kernel, and the
kernel is for an aggregating message with no methods, then it probably
won't care about the layout pointer when it synthesizes its behaviour.
This results in an annoying compiler warning, which we can placate.

I originally considered doing this in `invoke-delegation-chain',
precisely in the case where the kernel is being included, but it's not
like we're being especially precise about other uses of `SOD__IGNORE',
so I've done the simpler thing instead.

src/method-proto.lisp: Collect arguments in vanilla delegation trampolines.

In the keyword-arguments overhaul, somehow the case in `make-trampoline'
for trivially `augmenting' the argument list for a vanilla message, as
opposed to hairy varargs or keyword messages, got lost, with the result
that they ended up with no arguments at all.  Needless to say, the C
compiler is unhappy about this.

test/bad.sod: Test error reporting and recovery.

Huh, what do you know?  That `demo' item has come back again.

src/module-parse.lisp: Eliminate the old `demo' module item.

It was only there for early testing, and we don't need it any more.

test/test.sod: Add a test for the class-pointer type bug.

src/class-layout-impl.lisp: Fix class pointers in secondary chains.

Consider:

[link = SodClass] class MyClass: SodClass { }
[metaclass = MyClass] class Foo: SodObject { }

GCC reports:

/tmp/mdw/t.c:258:33: warning: initialization from incompatible pointer type [-Wincompatible-pointer-types]
   /*                _class = */ &Foo__classobj.obj.myclass,
                                 ^
/tmp/mdw/t.c:258:33: note: (near initialization for ‘Foo__vtable_obj.obj._class’)

What's going on here is that it's writing the wrong metaclass pointer
into the `_class' pointer on `Foo''s secondary `obj' chain.

Fix this by choosing, for each class pointer, the most specific
superclass of the overall metaclass that is (a) on the correct chain of
the metaclass, and (b) is a superclass of the metaclass of the most
specific class in the chain whose vtable we're writing.  Whew!

src/class-finalize-impl.lisp: Fix bungled format string.

src/optparse.lisp: Muffle warnings about `&optional ... &key ...'.

doc/check-docs: Return nonzero if discrepancies are found.

src/: Write dependency-tracking Makefile fragments.

And deploy them in the Makefile!

src/module-output.lisp: Introduce `module-output-file'.

This is the code from `frontend.lisp', which has been modified to use
it.

src/parser/parse-expr-{proto,impl}.lisp: Fully hide the parser state.

We didn't publish the ability to pop things, so external implementers
are rather limited in their options.  Withdraw this entirely.

The `push-operator' and `apply-operator' generic functions are now
internal.  The `push-value' function is gone entirely: the only caller
was `parse-expression', and that now simply pushes the value onto the
stack directly.

vars.am: Add GNU Make pattern rules for Sod output files.

Additional dependencies in suffix rules don't work, apparently.  Non-GNU
make(1) should just see bizarre filenames which nobody cares about, so
this is a safe thing to do.

doc/list-exports: Use the same output directory as the main `Makefile'.

This way we (a) don't have to rebuild the project separately for
analysing the symbols, and (b) we won't clobber the ordinary ASDF-
maintained FASLs, which I typically build with different optimization
settings (turning on debugging, specifically).

src/module-impl.lisp: Indent the first line of a C fragment on output.

If we make the text appear in the right column, then GCC (at least) will
print out the correct line of the original Sod module and underline the
right pieces of it in error messages.  Which is pretty awesome,
actually.

doc/concepts.tex, src/optparse.lisp: Rephrasing respectively.

doc/concepts.tex, doc/syntax.tex: Replace `\textsf{...}' by `@|...|'.

Also, replace an enterprising combination of the `quote' environment
with `\textsf' by `prog'.

These were all very old.

doc/*.tex: Add stubs for `file-location' reader methods.

doc/check-docs: Add a program to check that the right things are documented.

How do you think I managed to find all of the problems I just fixed? ;-)

doc/*.tex: Add, remove, and/or fix stubs to match reality.

Many stubs were missing.  A few were wrongly spelled, or had the wrong
category.  Some were spurious.  Fixfixfix.

doc/meta.tex: Rearrange the initargs stubs.

Gather the classes and accessors; gather `make-sod-slot-initarg' and
`make-sod-slot-initarg-using-slot'.  Gently reorder things.

doc/meta.tex: Add missing return values for `make-sod-MUMBLE-initarg'.