src/module-parse.lisp: Improve error recovery for `load' and `import' items.

src/module-parse.lisp: Improve error recovery for `test' items.

src/module-parse.lisp: Improve error recovery for `code' items.

src/module-parse.lisp: Improve error recovery for `typename' items.

src/module-parse.lisp (`set'): Parse at least one property if no pset.

Allow

[foo = "thing"] set;

and

set foo = "thing";

but not plain

set;

src/module-parse.lisp (read-module): Use requested pathname for location.

The default behaviour for `charbuf-scanner' is to use the pathname from
its underlying stream; but (at least on some implementations) this is an
absolute pathname which is actually rather annoying in error messages.

Instead, arrange for `read-module' to attach the namestring of the
pathname it was given directly to the scanner.  This will be the correct
possibly-relative pathname to the module file, because `find-file' has
already done that part of the work, but it will be relative if that's
how it was specified on the command line, if it was found by merging
with a relative pathname in the `*module-dirs*' list, or if it was
imported by a name relative to a module with a relative pathname.

src/module-parse.lisp (read-module): Provide sensible default error-recovery.

By default, if there's an error parsing a module item, skip and consume
until the next `;' or `}'.  This actually seems to work quite well.

src/module-parse.lisp: Don't explicitly ask for default behaviour.

  * Reporting the scanner position as the error location.

  * Setting at-least-one when parsing delimitered lists.

  * Keeping the terminator when skipping to one of several terminator
    tokens.

src/module-parse.lisp: Use newer syntax notation in the commentary.

src/module-parse.lisp: Some minor reformattings.

src/lexer-{proto,impl}.lisp: Add explicit recovery action to `error'.

This ends up being an `:action' keyword argument to
`parse-error-recover', and a macro body to the `error' parser macro.

src/lexer-{proto,impl}.lisp: Enhance `skip-until' to match token values.

src/lexer-impl.lisp: Set default `:keep-end' in `%skip-until' function.

The parser-macro set this correctly, but the function didn't.

src/lexer-impl.lisp: Rename internal `skip-until' function.

This shouldn't have leaked.

src/class-make-impl.lisp: Forbid slots with function types.

Pointer-to-function type is fine, of course.

src/{c-types-impl,method-{proto,impl}}.lisp: Improve `merge-keyword-lists'.

  * Make the overall description of the merging site be a function (a)
    to report a file location and (b) to avoid formatting the thing if
    there isn't actually a problem.

  * Make the per-argument-list descriptions be functions so that they
    can report more than one message each.

  * Change `method-keyword-argument-lists' to report the inheritance
    path for methods involved in keyword argument conflicts.  Add an
    argument to thread through an `inheritance-path-reporter-state'
    object to make this work.

src/c-types-impl.lisp: Reorder `merge-keyword-lists' input lists.

Prepend the `what' argument to the front of each argument list, rather
than having a (LIST . WHAT) pair.  Also, internally to
`merge-keyword-lists', keep the entries in the hash table as
(WHAT . ARG) rather than the other way around.

src/method-impl.lisp (method-keyword-argument-lists): Check message type.

Check keyword arguments defined in the message as well as all of the
applicable methods.

src/method-impl.lisp (method-keyword-argument-lists): Zap pointless `let'.

src/method-impl.lisp (method-keyword-argument-lists): Fix indentation.

src/{lexer-{proto,impl},parser/floc-proto}.lisp: Conditionify parse errors.

  * Introduce condition classes for parse errors.

  * Introduce `classify-condition' to describe the different reportable
    conditions to the user, and change `count-and-report-errors*' to use
    this rather than having special knowledge.  Now it pretty much just
    counts and prints.

  * Move the complicated error-message printing machinery from the
    `syntax-error' and `lexer-error' functions into the condition
    reporting functions.  (Now they don't actually need to be formatted
    until they're just about to be presented to a user.)

src/**/*.lisp: Use convenience functions to invoke restarts.

Introduce a new function `noted' to invoke the `noted' restart.  Fiddle
other code to do the right thing.

src/utilities.lisp: New function `invoke-associated-restart'.

Does what it says on the tin.  Not really sure why this isn't part of
Common Lisp.

src/class-finalize-impl.lisp: Overhaul `check-sod-class', `compute-chains'.

Signal continuable errors so that we can get more useful diagnostics.
Use the `finalization-error' machinery to limit redundant error
reporting.  Report portions of inheritance structure where appropriate.
Improve checking that the things defined by the class don't conflict
with each other.

src/class-finalize-*.lisp: Improve finalization error reporting.

Change the finalization protocol: now, `finalize-sod-class' and its
helpers (notably `check-sod-class') can signal continuable errors and
still have the overall finalization report failure.

Actually make use of the return value in the two callers:
`parse-class-body' and `bootstrap-classes'.

src/method-{impl,proto}.lisp: Add `sod-method-description'.

Now we can report on kinds of methods.

src/class-*.lisp: Improve metaclass selection.

Replace the slightly wobbly (and poorly named) `maximum' function (in
`class-finalize-impl.lisp') with the much more capable
`select-minimal-class-property' (in `class-utilities.lisp').

Use this new function as appropriate.

src/builtin.lisp (method-keyword-argument-lists): Don't `delete-duplicates'.

No idea why this was here.  The `merge-keyword-lists' function copes
fine with duplicate names.  And the `:key' argument was hopelessly
wrong, so the code could never have worked.

src/class-finalize-{proto,impl}.lisp (finalize-sod-class): Add `:around'.

The `around' method handles the recursiveness and state tracking (and
will accumulate further functionality later).  The primary method
actually does the calculation and checking needed to make a class work.

src/class-finalize-proto.lisp (check-sod-class): Fix docstring.

Describe the actual, rather unsatisfactory, state of the world.
Fortunately, this will be fixed soon.

src/{class-,}utilities.lisp: Add machinery for showing inheritance paths.

To the general utilities collection, we add an implementation of
Dijkstra's distinguished-point shortest-path algorithm.

To the class utilities, we add a new type and function for reporting
inheritance paths, with the notion that this will be useful when
debugging problems where classes turn out to be incompatible with each
other for various reasons.

src/class-{finalize,layout}-*.lisp: Relocate layout interface code.

Establishing the layout is now the responsibility of the layout code.
Not sure what made me put it anywhere else.

src/final.lisp (test-parser): Set error location after making the scanner.

Oops.

src/final.lisp (test-module): By default, just report and count up errors.

This makes the whole return value thing more useful.  You can still get
a backtrace (or enter the debugger or whatever) by setting the new
BACKTRACE argument.

src/final.lisp (test-module): Optionally clear the decks before parsing.

src/final.lisp (test-module): Don't try output if parsing failed.

src/final.lisp (test-module): Make REASON be a keyword argument.

It's not always wanted, and we'll want to add more keywords soon.

src/final.lisp (test-module): Fix egregiously wrong docstring.

Make the doc stub match too.

src/utilities: (add partial-order-minima)

src/utilities.lisp: Fix docstring formatting.

lib/keyword.3: Fix some minor formatting errors.

src/c-types-class-impl.lisp (find-sod-class): Improve error reporting.

The built-in simple type names are now properly baked in, in the
`*simple-type-map*' hash table, rather than being exported by the
`builtin' module, so check there before reporting a type as `unknown'.

src/c-types-class-impl.lisp (find-class-type): Don't repeat type name.

It turns out that if some type name isn't a class, then it doesn't
usually have a very interesting description which is different from its
name.

src/final.lisp (test-module): Make it useful for testing error reporting.

src/lexer-proto.lisp: New parser `must'.

This is a simple wrapper around `error' for mandatory delimiters.  If it
doesn't find the delimiter, it reports the error and continues, possibly
producing a default value.

src/method-proto.lisp: Don't bind `*keyword-struct-disposition*' initially.

Abolish the `:unset' state, which was an acknowledged hack for the
absence of `defvar-unbound' which we now have.

src/: Disentangle some pieces of module-parsing preparation.

Have `*module-map*' initialized in strictly one place, rather than a
`defparameter' and sneakily in `test-module'.  This is now a
`clear-the-decks' operation.  Use `defvar-unbound' to leave a trap for
the incautious who try to use it before the decks are cleared.

src/utilities.lisp (defvar-unbound): Make a variable with docs and no value.

src/final.lisp: Slightly tweak `clear-the-decks' usage.

  * Force a clear after loading the file.  This is now safe, because
    we've arranged for us to be loaded after everything relevant.

  * Don't bother clearing /before/ `exercise' now that we know we've
    been cleared once.

  * Don't clear in `test-module'.

src/sod.asd.in: Make sure `final.lisp' is processed last.

Or at least after anything which hooks `clear-the-decks'.

src/fragment-parse.lisp, src/lexer-{impl,proto}.lisp: Better errors.

Improve error reporting for comments, string and character literals, and
C fragments.  Most significantly, if we encounter end-of-file while
trying to read one of these, then also report where the construct
started.  For C fragments, if we encounter a mismatching closing
bracket, then report where the opening bracket was; and if we hit end-
of-file while brackets are still open, then report where they were.

Also, deal with a subtlety in the initialization procedure for
`sod-token-scanner': the first token is read to `prime the pump' as part
of the behaviour of `token-scanner', which is done before `sod-token-
scanner' itself has had a chance to initialize its own slots -- such as
the filename to report to `file-location'.  There are several ways I
could have dealt with this -- e.g., introducing some deliberately-less-
specific superclass to initialize the filename for me -- but the path of
least resistance seems to be to cope with this problem carefully in
`scanner-token'.  This is anyway an improvement because the function no
longer depends on a sensible ambient error-location object being set.

src/lexer-proto.lisp (lexer-error): Use Oxford comma for expected tokens.

src/lexer-proto.lisp (lexer-error): Improve error reporting.

Now EXPECTED can be `nil' to produce a simple `unexpected THING'
message.

src/lexer-impl.lisp: Don't always skip a token.

It's usually, or at least often, the wrong thing to do.  Consider, for
example, how to recover from trying to parse

( list[x] )

when presented with

( )

Instead, add a `:force-progress' argument to the `error' parser.  The
default is /not/ to consume a token; I think this is right.

src/parser/floc-proto.lisp, src/utilities.lisp: New `information' condition.

For reporting extra information about errors.

src/parser/floc-proto.lisp: Add `enclosing-condition-with-location-type'.

Split out the piece of `make-condition-with-location' which figures out
the appropriate subclass of `condition-with-location' to use to wrap a
given condition so that it can be extended more easily.

src/parser/floc-proto.lisp (make-condition-with-location): Error checking.

Check for errors rather than just mentioning them in the docstring.

src/module-parse.lisp (parse-class-body): Recover from `unknown class' error.

Dig up `SodObject' as a suitable default, and don't actually add the
class to the module.

src/utilities.lisp, src/class-finalize-impl.lisp: Improve error reports.

  * Arrange for `inconsistent-merge-error' to present the list of
    candidates more pleasantly for human reading.

  * Give `merge-lists' a new argument to turn items into presentable
    names.

  * Make a wrapper function for merging lists of classes to apply the
    right kind of presentation.

src/: Error message cleanup.

  * Remove trailing `.'s from messages, to fit in with Unix conventions
    when they're output.  They'll look a little strange inside Lisp, but
    that's the right error to make.

  * Fix a `~a' to `~A' for consistency with everything else.

src/lexer-proto.lisp (syntax-error, lexer-error): Improve location handling.

The functions now provide a `:location' keyword argument, and use their
scanner argument as a default location if the keyword is omitted.

Nothing is currently using the optional arguments, but it might happen
later.

src/lexer-proto.lisp, ...: Kill `lexer-error' pointless CONSUMEDP flag.

Not sure what the idea was.  It seems to control printing the location
as part of the message, but the error printing machinery takes care of
doing that anyway; and even so, it seems to hang off this flag.

Kill it, and the redundant printing of the location.

src/module-parse.lisp: The direct-superclasses list is mandatory.

src/module-parse.lisp: Report an error if the top-level parse fails.

src/c-types-impl.lisp: Provide both names for `_Bool'.

Now the machinery can cope.

src/c-types-parse.lisp: Use the new `find-simple-c-type' function.

New simple types added using `define-simple-c-type' won't be present in
the `*declspec-map*', or the `*module-type-map*', so they won't be found
at all using the previous search.  Now, look use `find-simple-c-type' if
the other two lookups don't work.

Now that this works, we don't need `void' or `bool' in the `*declspec-
map*', because they don't accept any modifiers.

src/c-types-parse.lisp (scan-simple-declspec): Prefer primitive types.

Look types up in `*declspec-map*' before consulting the
`*module-type-map*'.

src/lexer-impl.lisp: Describe EOF as `<end-of-file>' consistently.

src/c-types-impl.lisp: Make string -> simple-c-type mapping more useful.

  * Arrange for `define-simple-c-type' to accept multiple C type-name
    strings, and keep records in the `*simple-type-map*' allowing simple
    type names to be canonified.

  * Add a new function `find-simple-c-type' to retrieve the appropriate
    type object given one its names.

  * Use this when looking up types in property values.

  * Remove the type declarations from the builtin module because they're
    all entered as simple types directly now.

src/c-types-impl.lisp: Make `*simple-type-map*' use `equal' as its test.

It's mapping strings to things, so using `eql' was wrong.  In
particular, it caused (c-type (int :const)) to print incorrectly.

src/c-types-impl.lisp (intern-c-type): Canonify class and initargs.

Make sure the class and initargs are canonical before probing the
`*c-type-intern-map*'.

  * The class should ideally be represented by name.

  * The initargs should be in ascending order by keyword name.

In particular, this fixes a bug where `qualify-c-type' erroneously
returns a fresh type when asked to attach an empty list of qualifiers to
an already-interned type.

src/pset-impl.lisp: Don't look in `*module-type-map*' if it's unbound.

It should be bound in general use, but depending on it makes testing
unnecessarily difficult.

src/utilities.lisp: Add new anaphoric `aand'.

src/module-parse.lisp, src/package.lisp: Read code in `sod-user' package.

Define a `sod-user' package which uses `common-lisp' and `sod', and bind
`*package*' to this when we start reading a new module.

src/final.lisp: Improve `test-parser' for testing error reporting.

This is nearly a rewrite.  By default, print errors and warnings
encountered during the parse, so that I can test how well the various
parsers cope with errors.  The output has changed, and there's a new
`:backtrace' keyword argument for disabling the error-trapping, to make
it easier to track down unexpected errors.

The new code is a little tricky.  A `token-scanner' tries to lex its
first token during initialization (`priming the pump'), and can
therefore emit lexical errors at this point.  We must therefore
establish `count-and-report-errors' around construction of the token
scanner; but it shouldn't be wrapped around the output stage -- partly
because I think I want to debug errors in that in the traditional way,
but mostly because the output includes the error counts.

So declare the scanner variables early, but initialize them later,
inside the body function.  This leaves a further problem: if priming the
pump fails badly, then `scanner' won't get set; so guard the final
output item from silliness in this case.

src/pset-parse.lisp: Evaluate the expression in `? SEXP'.

Trap errors, because they shouldn't abort the run.

src/pset-parse.lisp: Export the `parse-property' function.

src/parser/scanner-impl.lisp: Location protocol for `string-scanner'.

Implement the protocol using the utilities carefully provided years ago
for the purpose.

src/parser/scanner-impl.lisp: Add missing `scanner-unread' method.

For some reason, `string-scanner' didn't have this defined.

src/fragment-parse.lisp: Fix some ugly source formatting.

doc/structures.tex, lib/sod-structs.3: Justify union $C$__ichainu_$h$.

doc/structures.tex: Remove spurious line breaks in the source.

Debris from copying from the troff(1) source.

lib/sod-structs.3: Move the definition of type $C$ somewhere more sensible.

Now it's just after where we explain struct $C$__ichain_$h$, which is
where the similar text in the LaTeX manual is.

lib/sod-structs.3: Fix misnamed `struct SodClass__ilayout'.

lib/keyword.h: Some minor fixes to comments.

Delete some stray spaces, and fix some mangled English.

doc/syntax.tex, src/sod-module.5: Add missing `<TYPE>' expression syntax.

doc/syntax.tex, src/sod-module.5: Abstract out <plain-type> nonterminal.

doc/parsing.tex: Document missing `:ignore-unconsumed' flag to `error'.

doc/structures.tex, lib/sod-structs.3: Define variable `M'.

Oops.

doc/{misc,parsing}.tex: Write <form> rather than <body-form>.

doc/{runtime,structures}.tex: Fix careless transfer from the manpages.

doc/meta.tex: Fix nonterminal `<...>' to `@<...>'.

doc/: Align backslashes in C-macros by the right-hand margin.

Do this in the source, and in the typeset code.

doc/: Align layout control commands to right margin in `tabbing' etc.

This is mostly clean in `--word-diff'.  Here are the exceptions.

  * doc/parsing.tex: `--word-diff' gets confused around the various
    `condition-with-location' subclasses.  This is clean in `-b', so
    there's not actually anything complicated happening here.

  * doc/parsing.tex: I've sneakily removed a pointless trailing `%'.

  * doc/runtime.tex: I've inserted a couple of linebreaks with `%' so as
    to shorten the source-file lines.

  * doc/runtime.tex: Some `\-' have harmlessly moved past `@\\' macro-
    backslashes to take their proper places on the right margin.

doc/sod.sty: Typeset code upright, even if surrounding text is italic.

doc/output.tex: Add the `user' and `early-user' output items to comment.

doc/sod.sty, doc/runtime.tex: Improve comment typesetting in code.

  * Don't typeset the initial `;' as commentary; handle multiple initial
    `;;' in sequence.

  * Add new commands for general inside-comment typesetting, and for
    C-style `/* ... */' comments.  Maybe there should be a thing for
    C++-style comments, but I don't tend to use them anyway.

  * Highlight code text in commentary.

doc/parsing.tex: Fix awful inconsistency in indentation.

Somehow the descriptions of the various condition classes ended up all
over the place.

doc/syntax.tex: Replace `listing' environments with `prog'.

doc/syntax.tex: Mention superclass list is mandatory.

And discuss the difficulties of actually defining new root classes.