Add note about old-style function declarations to the manual.

Make is_abstract a proper library function.

This function is generally useful.  Add it to the public API.

Reduce "set +x" noise in (un)install targets.

By judicious use of subshells, we can eliminate the need to call
"set +x" explicitly, which should (slightly) reduce the noise of the
(un)install targets.

Generate the specifier switch statement automatically.

We already have a list of specifier names, so use them!

Separate specifier handling from the output routines.

This moves all the code to handle redundant specifiers and multiple
orderings to the parser, so that the output routines just have to
print them out in order.

This will allow the output routines to be used by test generators.

Use #n in strtab.sed.

This feature allows us to make all makefile rules which call sed scripts
the same.  This may help reduce code duplication in the makefile later.

Make CDECL_SPEC_TYPE non-zero.

This allows us to meaningfully OR together the various CDECL_SPEC_
constants.  A bit of code assumes that CDECL_SPEC_TYPE is zero, so that
needs to be fixed.

Update Gnulib to latest version.

Mangle spliced makefile lines in Gnulib correctly.

Otherwise, target and variable mangling may only apply to the first
line.

Add some examples to the manual.

Implement --help.

Add support for translated long options.

Identify nonterminals in the manual's grammar in an alternate way.

Some output devices won't render .Va text differently from .Li text when
displaying the man page.  This unfortunately means that nonterminals
look exactly the same as terminals in the grammar.  Add brackets
around nonterminals (which are otherwise unused in the grammar) so
that it is readable on these devices, too.

Fix typos in manual.

Apparently I was too drunk to spell "declaration" when I wrote this.

Don't call cdecl_free internally.

Use an exported wrapper function to avoid a local PLT entry in the
shared object.

Generate gettext catalog only from source files.

Otherwise the catalog is considered out of date even from a freshly
unpacked tarball.

Start on a facility to translate error codes into strings.

This will be needed to port the remaining error messages over.

Start implementing proper error handling.

Since the library shouldn't be printing its own error messages, we need
a mechanism to propagate error details to the caller.  Implement a
system using thread-local storage which tracks the most recent errors.

Document libcdecl's slice of the C namespaces.

Now that we rename gnulib symbols, this should actually be true.
Document it.

Update timestamps on generated header files before distributing them.

Otherwise we risk breaking VPATH builds from the tarball, as make may
attempt to regenerate the headers.

Add installdirs rule for .mo files.

Use (un)install-local to (un)install .mo files.

These install rules do not depend on any other installed file, so
there's no need to use the -hook versions which guarantee ordering.
Use -local instead.

Add uninstall rule for .mo files.

This was apparently forgotten because distcheck seems to not notice when
you leave crap in the install tree.

Add missing copyright headers.

Add -no-undefined to libcdecl LDFLAGS.

This is now true, so setting this allows shared libraries to be built
on Woe32.

Avoid gratuitous library dependencies linking gnulib.

libcdecl doesn't use the readline module at all, but libtool happily
pulls it in as a dependency.  Handle library dependencies manually to
avoid this problem.

Tell xgettext about _ and N_ markings.

Gnulib uses these, and we will too.

Fix build with NLS disabled.

When NLS is disabled, we should not install any .mo files but we still
need to distribute the .po files.  However, ALL_LINGUAS was not being
set in this case, so the POFILES was not set if NLS is disabled, causing
a distcheck failure.

Also fix a build error in this case due to a missing #include.

Include config.h in all C source files.

Some source files failed to include config.h, which is needed for
some things to work.

Include config.h in scan.l.

This is required for things to work.  Unfortunately, %top{...} appears
to be the only bit where config.h can be put in a flex scanner, as
headers are included before the first %{...} block is output.  Thus, the
include ends up in the scan.h header file.  Nevertheless, this should
not be a problem since config.h only defines macros.

Rewrite Gnulib symbols to be in libcdecl's namespace.

The gnulib symbols are not properly prefixed for libcdecl internal
symbols (e.g. cdecl__blah).  This *will* cause problems when statically
linking against both libcdecl and another library that uses the same
gnulib modules.

Unfortunately, there's no simple way to determine what symbols need
prefixing without compiling all the gnulib objects.  The results can't
be distributed either, because they depend on the configuration.  So,
limited to simple tools and portable make rules, we hack together a
"new" config.h at build time that defines object-like macros to rewrite
the symbols, carefully ensuring that header dependencies are correct.

Split gnulib_headers into 3 variables.

This will be useful for symbol mangling, where additional header files
may need to be added to various points in the dependency chain.

Move all Gnulib CLEANFILES variables to the end of the makefile.

This makes the clean procedure independent of the configuration.

Handle gl_LIBOBJS/gl_LTLIBOBJS correctly.

These AC_SUBSTed variables reference objects whose sources are located
in lib, thus they need to be rewritten like other AC_SUBSTed variables.

These objects also need the header dependencies like other objects.

Eliminate use of BUILT_SOURCES from Gnulib.

As with recursive make, BUILT_SOURCES is harmful because of inadequate
dependency information.  We can achieve a similar effect with by using
order-only dependencies:  These force the headers to be up-to-date
before anything that might require them is built: but rebuilds are only
triggered based on the accurate dependency information generated by the
normal mechanisms.

Unfortunately, order-only dependencies are a GNU make feature, so we use
a hack which should fall back to ordinary dependencies on other make
implementations.  The worst effect of using ordinary dependencies will
be that files might be needlessly rebuilt when a header changes.

Integrate Gnulib non-recursively.

With a little bit of mangling, it's possible to make the makefile
fragment produced by gnulib-tool suitable for use in our non-recursive
makefile.

Enable i18n in Bison.

This makes us require library initialization.  To avoid requiring an
explicit call, we implicitly initialize the library when it is first
required.  Bring in Gnulib's threading library to do this in a
thread-safe manner when available.

Initial README.

Allow bootstrap tools to be overridden via environment variables.

Useful if you want to use a different installed version of autoreconf,
for instance.

Add nodefault to flex options.

We don't rely on this behaviour, and the default rule causes gcc to emit
a warning with -D_FORTIFY_SOURCE=2.  Just kill it.

Add WTFPL2 license document.

Parts of Cdecl99 are released under the terms of this license, thus it
should be included.

Fool autoreconf and automake into ignoring gettext.

Since we define our own makefile rules for gettext, having the autotools
magically perform special actions is counterproductive.

Enable conditional dependencies in gnulib.

Seems to shave about 10% off total configure time on my machine.

Add never-interactive flex option.

This eliminates the (non-ANSI) fileno and isatty calls.  Our input is
always a fixed buffer.

Initial i18n infrastructure.

Use AM_CPPFLAGS for mandatory preprocessor flags.

CPPFLAGS is meant to be overridable by the user.  Don't use it.

Use symlinks for gnulib's m4 files.

This is nice because it makes it really obvious (when working from git)
what files came directly from gnulib.

Use .Pp for paragraph breaks in man pages.

Blank lines are apparently invalid.

Use .Va instead of .Fa in man pages when appropriate.

".Va" means "variable name", which is more appropriate than "function
argument" for variables.  Nevertheless, they're probably typeset the
same way, anyway.

Re-word description of nonterminals in man page.

There's no reason to assume that "function arguments" are typeset with
an underline.  So re-word that sentence to avoid directly stating
typographical conventions by using an example instead.

Abort on "impossible" condition.

A corrupt or otherwise invalid cdecl structure could make the
explain_prologue function fail to return a value.  Add an assertion to
catch that.

Make semicolons after declarations optional.

They're annoying, don't make sense for type names, weren't required by
cdecl, and don't actually do anything productive.

Add cdecl__ prefix to flex/bison functions.

Now all global symbols are prefixed.

Combine English specifiers properly.

If $1 is NULL in post_specs, then $3 won't get attached to the list.

Add man pages.

Add support for parsing English-like declarations.

I think that makes the parser almost feature-complete.

Fix return value of typespec checks.

Returning -1 here means "true"; we actually want to return "false".

Forbid arrays of functions.

Fix error name of ellipsis token.

So it says unexpected ... instead of unexpected .

Fix rendering of non-prototype function declarations.

When there are no parameters, the closing parenthesis was not printed.
Fix that up.

Avoid modifying the input command string.

This gives the individual command functions access to the entire
(unadultered) input from the user.

Fix yyerror's signature.

This only worked because we ignore those parameters.

Add support for --execute and --file options.

For useful non-interactive invocation.

Split up interactive/noninteractive loops.

Readline isn't well suited for non-interactive loops since it tends to
print stuff to standard output.  So use two loops: a readline-based one
and a getline-based one.

Add support for outputting declarations as C code.

This permits us to define a nifty "simplify" function.

Add support for imaginary types.

Somehow these got forgotten.

Reject mixed type names / declarations.

Things like int,; make little sense.  Reject it.

Move advance/advance_ into common code.

These will be useful for other output routines.

Use the reentrant scanner API.

Add initial support for non-interactive modes to cdecl99.

Validate function return types.

Check specifiers for type names.

Type names cannot have storage-class or function specifiers.

Validate declspecs in function parameters.

Don't gratuitously reject inline specifiers.

We actually do support functions now, so we need to handle inline.
Turns out the last user of the old output routines (the code that
prints "inline") didn't actually work properly, so port it over to
the new interface.

Reject declarations of void objects.

Initial support for function declarators.

Wow.  That was way harder than I thought it would be.

Add missing copyright headers.

Kill the "horizontal" declarator chain.

The "next" pointer in declarators is used in exactly one place: the list
of declarators of a declaration.  Move this chain to the toplevel so
that we get a list of declarations instead: now every struct cdecl has
exatly one declarator.

This helps eliminate the nasty hack in "explain" to print multiple
declarators.

Make an explicit null declarator type.

Now that we have a child pointers in every declarator, this is way
cleaner than abusing the identifier type.

Fix broken include guard.

Add a child pointer to cdecl_declarator.

This eliminates the need for separate child pointers for each
declarator type.

Fix pointer declarators.

Support for parsing pointer types like int ** was broken a while back.
Fix it up.

Split advance into two parts.

We need to avoid printing spaces after things on occasion.  This makes
the code a little simpler, too.

Add support for empty declarators.

This allows the parser to recognize type names which are required for
function prototypes, as well as actual declarations.  This also makes it
easy to let the user ask for an explanation of types.  For instance:

  explain int *(*[])[];

prints

  type array of pointer to array of pointer to int.

Use assert(0) instead of abort for exceptional cases.

assert prints helpful context info to stderr.  These cases should never
be reached except by programmer error.

Add support for explaining multiple declarators.

Fix error handling in explain.

On a memory allocation failure, we leak the decl allocated by the
parser.  Fix that up.

Add support for array declarators.

Currently there is a (I think quite reasonable) restriction that the
array length either be unspecified, a positive integer constant, an
identifier, or *.

Add support for pointer declarators.

Fix comment about automatic generation in typenames.sed.

Last I checked, typenames.sed is not validtypes.sed.

Restrict the contexts in which typedef names can appear.

This should resolve a rather nasty ambiguity in the C grammar:

  [declaration] -> [declaration-specifiers] ;
                -> [type-specifier] [declaration-specifiers] ;
                -> int [declaration-specifiers] ;
                -> int [type-specifier] ;
                -> int [typedef-name] ;
                -> int [identifier] ;
                -> int x ;

versus

  [declaration] -> [declaration-specifiers] [init-declarator-list] ;
                -> [type-specifier] [init-declarator-list] ;
                -> int [init-declarator-list] ;
                -> int [init-declarator] ;
                -> int [declarator] ;
                -> int [direct-declarator] ;
                -> int [identifier] ;
                -> int x ;

The standard resolves this ambiguity by having a constraint that is not
part of the context-free grammar.  This ambiguity gets really nasty with
things like int f (x); -- is it a declaration of x with two type
specifiers or a declaration of f (a function with one parameter) with
with one type specifier?

A side-effect of this change is that the parser will now reject
declarations without any type specifiers at all, which probably makes
the error messages a bit less informative.

Fix VPATH builds from git.

In such builds, C source files (that are normally distributed) get
generated, which means they end up in the build tree.  Building them
subsequently fails because headers (in the source tree) are not found.

Split out qualifier explanations from explain_post_specs.

They'll be needed on their own for pointer explanations.

Fix the distribution.

Now make distcheck passes.

Initial support for explaining declarations.

This should support everything that the parser currently does.

Add a function to turn a typemap into a string.

Allow (and ignore) underscores in the list of type names.

This allows the "true" keywords to be used in the list.

Kill typemap_is_valid.

Just do the check when building the map in the first place.  This
enables more useful error messages, too: the case where there are no
type specifiers at all is certainly worth diagnosing separately from
other kinds of nonsense.

Add initial command parser.

Implement the interactive cdecl99 loop.

Bring in gnulib for getopt_long and readline support.