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.

Make cdecl_free more robust by handling a NULL argument.

While we're at it, split the function into two so that the parser
doesn't have to call the exported version.

Move typemap stuff into a separate file.

These functions will be generally useful.  They are not part of the
public API, so we use the cdecl__ prefix for internal functions.

While we're at it, make the code easier to understand by automatically
generating the huge switch statement and eliminating the silly macros.

Rename libcdecl.c to parse-decl.c

Paving the way for having more than one source file.

Don't use missing for flex.

Oops, that was a leftover from early testing.

Fix Makefile dependencies.

Dependencies of foo.$(OBJEXT) are not honoured when building a libtool
library; instead we need to use foo.lo.

Add m4/.gitignore.

This ensures that the m4 directory exists in the git checkout.

Don't touch unchanged flex/bison headers.

This prevents some spurious rebuilds.

Add an initial declaration parser.

Initial commit