Fix bug in parsing of dimension specifications

A line of the form

  type(foo) :: foo(:,:)

would have the type and the modifiers in the wrong order:

  ("foo" ("dimension" . 2) "type(foo)")

rather than:

  ("foo" "type(foo)" ("dimension" . 2))

Introduce a test to exercise this case and fix it by appending the
dimension modifier to the type rather than pushing it on the front.

Catch errors when evaluating a test form

Populate completion table lazily

Rather than prepopulating the completion table when invoking M-., do
so lazily when the user asks for a completion candidate.

Set syntax table correctly in f90-arglist-types

Remove unused function f90-match-arglist-to-specialisers

New function to parse all files in a tree

Add a new interactive function that prompts for the top of a directory
tree to recurse into to look for Fortran files to parse.

New variable specifying what file extensions are Fortran 90 code

Rather than hardcoding the regexp for .F90, .f90 and .fpp, add a new
variable `f90-file-extensions', a list of possible extensions that
match Fortran 90 files.  While we're at it, add a customisation group
to pull user options together.

Minor optimisation to f90-normalise-string

Separately try and match for whitespace at the beginning and end of
strings.  This makes the regexp simpler and can speed things up a bit.

Ignore refcount templates when parsing interfaces

Add test framework and some unit tests

Speed up f90-split-arglist

Previously we inserted the arglist into a temporary buffer and split
it there.  Since we're just using that to loop over the characters in
the string one at a time, do it in place by looping across the
characters of the array.  This latter method takes around 70% less
time than the former.  Since we split arglists thousands of times when
parsing a source tree, this is a worthwhile optimisation.

Make dimension parsing more robust

Allow for whitespace in a "dimension(...)" declaration, and move the
parsing of TYPE :: foo(:) style dimension declarations into
f90-parse-single-type-declaration, rather than having it in
f90-make-type-struct.  This way argument matching when looking for
tags works better.

Don't stomp on match data when normalising strings

f90-normalise-string needs to look for whitespace, but shouldn't
destroy the match-data, so wrap the body in save-match-data.

If no tags are loaded don't try and use tags completion

Correctly determine dimension specification

Previously, if we had a dimension spec like dimension(:, max(1, 10))
we thought the variable had rank 3.  Now we only count top-level
commas and correctly determine that it is rank 2.

Default to type-at-point in f90-show-type-definition

Rather than just providing a completion table, try and guess a default
by looking for a type declaration on the current line, or (if that
fails) deriving the type of the variable at point.

Speed up f90-clean-comments

Rather than moving through the buffer one character at a time, search
forward for a possible comment start (a ! character) and then use
parse-partial-sexp to decide if we're actually in a comment or not.

It turns out most of the time in parsing was actually cleaning
comments, so this makes the code run significantly faster overall.

Parse prefix arg through to find-tag from f90-find-tag-interface

If we're searching for a tag, rather than an interface we need to pass
the prefix arg through so that the find-tag invocation can jump to
subsequent definitions.

Require etags and cl at runtime

Since we create structs on the fly, we need cl at runtime, not just
compile time.  We need etags because we push things on to
find-tag-marker-ring which is not autoloaded.

Document INVOCATION-POINT argument to f90-browse-interface-specialisers

Add more suffixes for likely Fortran files

Rather than just looking for .F90, also look for .f90 and .fpp.

Fix bug in f90-populate-specialisers

If an interface had multiple "module procedure" lines, we would only
add the final line to the interface's specialisers.  Fix this by
initialising the specialisers hash table outside the search loop.

Hook into pop-tag-mark machinery when visiting definitions

Make f90-find-definition behave more like find-tag by pushing the
invocation point onto find-tag-marker-ring when we visit a
definition.

Allow f90-find-tag-interface to complete tags names

When binding f90-find-tag-interface to M-. we want to be able to
complete tag names (for find-tag) as well as interface names.  So
merge the tags completion table with the interface name completion
table.

Fix jumping to definitions if we jump past recorded location

In some cases, the cached location of a specialiser might be past the
definition, in this case we need to search backwards for the beginning
of the definition if we can't find it looking forwards.

Fix f90-get-slot-type for new struct definition

Fix byte-compilation

Move inlineable functions before their use.  Change
f90-make-type-struct from a macro to a function (so we can eval its
result).

In addition, add "-varnames" slot to type structs so we don't have to
work the entire obarray when we want to show a type definition.

Docstring fixes

Add function to show the parsed type definition

This allows us to see all the slot names (although without the
documentation the actual sources have).

Normalise type-parsing routines and make arglist matching work

We now correctly match types in parsed arglists even in the case of
slot accesses.  Function calls and array accesses are still not
handled (we just pass UNION-TYPE through).  But, we do get some more
specialisation.  For example with some type definitions:

 type foo
   type(bar) :: slot
 end type foo

 type bar
   real, dimension(:), pointer :: n=>null()
 end type bar

and some code:

  type(foo) :: foo
  integer, dimension(10) :: x

  call some_function(x%slot, x%slot%n, x(1))

we derive the types of the arguments as:

 type(bar); real, dimension(:), pointer; UNION-TYPE

which is significantly better than the previous:

 UNION-TYPE; UNION-TYPE; UNION-TYPE

Further work on type parsing

We're now able to correctly determine argument types that specify
slots of derived types.  This allows us to be better at specifying
subsets of the available interfaces.  Needs more work on the approx
arglist matching code to be really useful.

Whitespace fixes

Add sketch of type definition parsing

We can now parse a derived type definition into its component slots
and produce a lisp struct mapping on to it. For example with a type
definition of:

 type foo
    integer, dimension(:), pointer :: n=>null()
    real, dimension(:, :), allocatable :: p
    character :: char
    integer :: len
 end type foo

We produce a struct defined by:

 (defstruct f90-type.foo
   (n '("integer" ("dimension" . 1) "pointer") :read-only t)
   (p '("real" ("dimension" . 2) "allocatable") :read-only t)
   (char '("character") :read-only t)
   (len '("integer") :read-only t)

The aim of this is to do better argument type derivation.  So that if
we have:

 ...
 type(foo) :: a
 ...
 call add(a%len)

we can figure out that add is being called with an integer argument.

Require thingatpt (for word-at-point)

Fix setting of public/private attribute on interfaces

Add more function documentation

Initial commit