Major mode for editing files of the Interactive Data Language

1 files changed, 5751 insertions, 0 deletions

diff --git a/lisp/progmodes/idlwave.el b/lisp/progmodes/idlwave.el
new file mode 100644
index 00000000000..960d84f9439
--- /dev/null
+++ b/lisp/progmodes/idlwave.el
@@ -0,0 +1,5751 @@
+;;; idlwave.el --- IDL and WAVE CL editing mode for GNU Emacs
+;; Copyright (c) 1994-1997 Chris Chase
+;; Copyright (c) 1999 Carsten Dominik
+;; Copyright (c) 1999 Free Software Foundation
+
+;; Author: Chris Chase <chase@att.com>
+;; Maintainer: Carsten Dominik <dominik@strw.leidenuniv.nl>
+;; Version: 3.11
+;; Date: $Date: 1999/12/16 10:42:46 $
+;; Keywords: languages
+
+;; This file is part of the GNU Emacs.
+
+;; GNU Emacs is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation; either version 2, or (at your option)
+;; any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs; see the file COPYING.  If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
+
+;;; Commentary:
+
+;; In distant past, based on pascal.el.  Though bears little
+;; resemblance to that now.
+;;
+;; Incorporates many ideas, such as abbrevs, action routines, and
+;; continuation line indenting, from wave.el.
+;; wave.el original written by Lubos Pochman, Precision Visuals, Boulder.
+;;
+;; See the mode description ("C-h m" in idlwave-mode or "C-h f idlwave-mode")
+;; for features, key bindings, and info.
+;; Also, Info format documentation is available with `M-x idlwave-info'
+;;
+;;
+;; INSTALLATION
+;; ============
+;;
+;; Follow the instructions in the INSTALL file of the distribution.
+;; In short, put this file on your load path and add the following
+;; lines to your .emacs file:
+;;
+;; (autoload 'idlwave-mode "idlwave" "IDLWAVE Mode" t)
+;; (autoload 'idlwave-shell "idlwave-shell" "IDLWAVE Shell" t)
+;; (setq auto-mode-alist (cons '("\\.pro\\'" . idlwave-mode) auto-mode-alist))
+;;
+;;
+;; SOURCE
+;; ======
+;;
+;; The newest version of this file is available from the maintainers
+;; Webpage.
+;;
+;;   http://www.strw.leidenuniv.el/~dominik/Tools/idlwave
+;;
+;; DOCUMENTATION
+;; =============
+;;
+;; IDLWAVE is documented online in info format.
+;; A printable version of the documentation is available from the
+;; maintainers webpage (see under SOURCE)
+;;
+;; 
+;; ACKNOWLEDGMENTS
+;; ===============
+;;
+;;  Thanks to the following people for their contributions and comments:
+;;
+;;    Ulrik Dickow <dickow@nbi.dk>
+;;    Eric E. Dors <edors@lanl.gov>
+;;    Stein Vidar H. Haugan <s.v.h.haugan@astro.uio.no>
+;;    David Huenemoerder <dph@space.mit.edu>
+;;    Kevin Ivory <Kevin.Ivory@linmpi.mpg.de>
+;;    Xuyong Liu <liu@stsci.edu>
+;;    Simon Marshall <Simon.Marshall@esrin.esa.it>
+;;    Laurent Mugnier <mugnier@onera.fr>
+;;    Lubos Pochman <lubos@rsinc.com>
+;;    Patrick M. Ryan <pat@jaameri.gsfc.nasa.gov>
+;;    Marty Ryba <ryba@ll.mit.edu>
+;;    Phil Williams <williams@irc.chmcc.org>
+;;    J.D. Smith <jdsmith@astrosun.tn.cornell.edu>
+;;    Phil Sterne <sterne@dublin.llnl.gov>
+;;
+;; CUSTOMIZATION:
+;; =============
+;;
+;; IDLWAVE has customize support - so if you want to learn about the
+;;  variables which control the behavior of the mode, use
+;; `M-x idlwave-customize'.
+;;
+;; You can set your own preferred values with Customize, or with Lisp
+;; code in .emacs.  For an example of what to put into .emacs, check
+;; the TexInfo documentation.
+;;
+;; KNOWN PROBLEMS:
+;; ==============
+;;
+;;   Moving the point backwards in conjunction with abbrev expansion
+;;   does not work as I would like it, but this is a problem with
+;;   emacs abbrev expansion done by the self-insert-command.  It ends
+;;   up inserting the character that expanded the abbrev after moving
+;;   point backward, e.g., "\cl" expanded with a space becomes
+;;   "LONG( )" with point before the close paren.  This is solved by
+;;   using a temporary function in `post-command-hook' - not pretty, 
+;;   but it works.<
+;;
+;;   Tabs and spaces are treated equally as whitespace when filling a
+;;   comment paragraph.  To accomplish this, tabs are permanently
+;;   replaced by spaces in the text surrounding the paragraph, which
+;;   may be an undesirable side-effect.  Replacing tabs with spaces is
+;;   limited to comments only and occurs only when a comment
+;;   paragraph is filled via `idlwave-fill-paragraph'.
+;;
+;;   "&" is ignored when parsing statements.
+;;   Avoid muti-statement lines (using "&") on block begin and end
+;;   lines.  Multi-statement lines can mess up the formatting, for
+;;   example, multiple end statements on a line: endif & endif.
+;;   Using "&" outside of block begin/end lines should be okay.
+;;
+;;   It is possible that the parser which decides what to complete has
+;;   problems with pointer dereferencing statements.  I don't use
+;;   pointers often enough to find out - please report any problems.
+;;
+;;   Completion of keywords for SETPROPERTY and GETPROPERTY assumes that
+;;   all INIT keywords are allowed in these methods as well.  In some
+;;   cases, there are exceptions to this rule and IDLWAVE will offer
+;;   a few illegal keyword parameters.
+;;
+;;   Completion and Routine Info do not know about inheritance.  Thus,
+;;   Keywords inherited from superclasses are not displayed and cannot
+;;   completed.
+;;
+;;   When forcing completion of method keywords, the initial
+;;   query for a method has multiple entries for some methods.  Would
+;;   be too difficult to fix this hardly used problem.
+;;
+
+;;; Code:
+
+(eval-when-compile (require 'cl))
+
+(eval-and-compile
+  ;; Kludge to allow `defcustom' for Emacs 19.
+  (condition-case () (require 'custom) (error nil))
+  (if (and (featurep 'custom) (fboundp 'custom-declare-variable))
+      nil ;; We've got what we needed
+    ;; We have the old or no custom-library, hack around it!
+    (defmacro defgroup (&rest args) nil)
+    (defmacro defcustom (var value doc &rest args) 
+      (` (defvar (, var) (, value) (, doc))))))
+
+(defgroup idlwave nil
+  "Major mode for editing IDL/WAVE CL .pro files"
+  :tag "IDLWAVE"
+  :link '(url-link :tag "Home Page" 
+                   "http://strw.leidenuniv.nl/~dominik/Tools/idlwave")
+  :link '(emacs-commentary-link :tag "Commentary in idlwave-shell.el"
+                                "idlwave-shell.el")
+  :link '(emacs-commentary-link :tag "Commentary in idlwave.el" "idlwave.el")
+  :link '(custom-manual "(idlwave)Top")
+  :prefix "idlwave"
+  :group 'languages)
+
+;;; Variables for indentation behavior ---------------------------------------
+
+(defgroup idlwave-code-formatting nil
+  "Indentation and formatting options for IDLWAVE mode."
+  :group 'idlwave)
+
+(defcustom idlwave-main-block-indent 0
+  "*Extra indentation for the main block of code.
+That is the block between the FUNCTION/PRO statement and the END
+statement for that program unit."
+  :group 'idlwave-code-formatting
+  :type 'integer)
+
+(defcustom idlwave-block-indent 4
+  "*Extra indentation applied to block lines.
+If you change this, you probably also want to change `idlwave-end-offset'."
+  :group 'idlwave-code-formatting
+  :type 'integer)
+
+(defcustom idlwave-end-offset -4
+  "*Extra indentation applied to block END lines.
+A value equal to negative `idlwave-block-indent' will make END lines
+line up with the block BEGIN lines."
+  :group 'idlwave-code-formatting
+  :type 'integer)
+
+(defcustom idlwave-continuation-indent 2
+  "*Extra indentation applied to continuation lines.
+This extra offset applies to the first of a set of continuation lines.
+The following lines receive the same indentation as the first.
+Also, the value of this variable applies to continuation lines inside
+parenthesis.  When the current line contains an open unmatched ([{,
+the next line is indented to that parenthesis plus the value of this variable."
+  :group 'idlwave-code-formatting
+  :type 'integer)
+
+(defcustom idlwave-hanging-indent t
+  "*If set non-nil then comment paragraphs are indented under the
+hanging indent given by `idlwave-hang-indent-regexp' match in the first line
+of the paragraph."
+  :group 'idlwave-code-formatting
+  :type 'boolean)
+
+(defcustom idlwave-hang-indent-regexp "- "
+  "*Regular expression matching the position of the hanging indent
+in the first line of a comment paragraph. The size of the indent
+extends to the end of the match for the regular expression."
+  :group 'idlwave-code-formatting
+  :type 'regexp)
+
+(defcustom idlwave-use-last-hang-indent nil
+  "*If non-nil then use last match on line for `idlwave-indent-regexp'."
+  :group 'idlwave-code-formatting
+  :type 'boolean)
+
+(defcustom idlwave-fill-comment-line-only t
+  "*If non-nil then auto fill will only operate on comment lines."
+  :group 'idlwave-code-formatting
+  :type 'boolean)
+
+(defcustom idlwave-auto-fill-split-string t
+  "*If non-nil then auto fill will split strings with the IDL `+' operator.
+When the line end falls within a string, string concatenation with the 
+'+' operator will be used to distribute a long string over lines.  
+If nil and a string is split then a terminal beep and warning are issued.
+
+This variable is ignored when `idlwave-fill-comment-line-only' is
+non-nil, since in this case code is not auto-filled."
+  :group 'idlwave-code-formatting
+  :type 'boolean)
+
+(defcustom idlwave-split-line-string t
+  "*If non-nil then `idlwave-split-line' will split strings with `+'.
+When the splitting point of a line falls inside a string, split the string
+using the `+' string concatenation operator.  If nil and a string is
+split then a terminal beep and warning are issued."
+  :group 'idlwave-code-formatting
+  :type 'boolean)
+
+(defcustom idlwave-no-change-comment ";;;"
+  "*The indentation of a comment that starts with this regular
+expression will not be changed. Note that the indentation of a comment
+at the beginning of a line is never changed."
+  :group 'idlwave-code-formatting
+  :type 'string)
+
+(defcustom idlwave-begin-line-comment nil
+  "*A comment anchored at the beginning of line.
+A comment matching this regular expression will not have its
+indentation changed.  If nil the default is \"^;\", i.e., any line
+beginning with a \";\".  Expressions for comments at the beginning of
+the line should begin with \"^\"."
+  :group 'idlwave-code-formatting
+  :type '(choice (const :tag "Any line beginning with `;'" nil)
+                 'regexp))
+
+(defcustom idlwave-code-comment ";;[^;]"
+  "*A comment that starts with this regular expression on a line by
+itself is indented as if it is a part of IDL code.  As a result if
+the comment is not preceded by whitespace it is unchanged."
+  :group 'idlwave-code-formatting
+  :type 'regexp)
+
+;; Comments not matching any of the above will be indented as a
+;; right-margin comment, i.e., to a minimum of `comment-column'.
+
+
+;;; Routine Info and Completion ---------------------------------------
+
+(defgroup idlwave-routine-info-and-completion nil
+  "Routine info and name/keyword completion options for IDLWAVE mode."
+  :group 'idlwave)
+
+(defcustom idlwave-scan-all-buffers-for-routine-info t
+  "*Non-nil means, scan all buffers for IDL programs when updating info.
+`idlwave-update-routine-info' scans buffers of the current Emacs session
+for routine definitions.  When this variable is nil, it only parses the
+current buffer.  When non-nil, all buffers are searched.
+A prefix to \\[idlwave-update-routine-info] toggles the meaning of this
+variable for the duration of the command."
+  :group 'idlwave-routine-info-and-completion
+  :type 'boolean)
+
+(defcustom idlwave-query-shell-for-routine-info t
+  "*Non-nil means query the shell for info about compiled routines.
+Querying the shell is useful to get information about compiled modules,
+and it is turned on by default.  However, when you have a complete library
+scan, this is not necessary."
+  :group 'idlwave-routine-info-and-completion
+  :type 'boolean)
+
+(defcustom idlwave-library-path nil
+  "Library path for Windows and MacOS.  Not needed under Unix.
+When selecting the directories to scan for IDL library routine info,
+IDLWAVE can under UNIX query the shell for the exact search path.
+However, under Windows and MacOS, the IDLWAVE shell does not work.  In this
+case, this variable specifies the path where IDLWAVE can find library files.
+The shell will only be asked when this variable is nil.
+The value is a list of directories.  A directory preceeded by a `+' will
+be search recursively."
+  :group 'idlwave-routine-info-and-completion
+  :type '(repeat (directory)))
+
+(defcustom idlwave-libinfo-file nil
+  "*File for routine information of the IDL library.
+When this points to a file, the file will be loaded when IDLWAVE first
+accesses routine info (or does completion).
+When you scan the library with `idlwave-create-libinfo-file', this file
+will be used to store the result."
+  :group 'idlwave-routine-info-and-completion
+  :type 'file)
+
+(eval-and-compile
+  (defconst idlwave-tmp
+    '(choice :tag "by applying the function"
+      (const upcase)
+      (const downcase)
+      (const capitalize)
+      (const preserve)
+      (symbol :tag "Other"))))
+
+
+(defcustom idlwave-completion-case '((routine . upcase)
+                                     (keyword . upcase)
+                                     (class   . preserve)
+                                     (method  . preserve))
+  "Association list setting the case of completed words.
+
+This variable determines the case (UPPER/lower/Capitalized...) of
+words inserted into the buffer by completion.  The preferred case can
+be specified separately for routine names, keywords, classes and
+methods. 
+This alist should therefore have entries for `routine' (normal
+functions and procedures, i.e. non-methods), `keyword', `class', and
+`method'.  Plausible values are
+
+upcase      upcase whole word, like `BOX_CURSOR'
+downcase    downcase whole word, like `read_ppm'
+capitalize  capitalize each part, like `Widget_Control'
+preserve    preserve case as is, like `IDLgrView'
+
+The value can also be any Emacs Lisp function which transforms the
+case of characters in a string.
+
+A value of `preserve' means that the case of the completed word is
+identical to the way it was written in the definition statement of the
+routine.  This was implemented to allow for mixed-case completion, in
+particular of object classes and methods.
+If a completable word is defined in multiple locations, the meaning of
+`preserve' is not unique since the different definitions might be
+cased differently.  Therefore IDLWAVE always takes the case of the
+*first* definition it encounters during routine info collection and
+uses the case derived from it consistently.
+
+Note that a lowercase-only string in the buffer will always be completed in
+lower case (but see the variable `idlwave-completion-force-default-case').
+
+After changing this variable, you need to either restart Emacs or press
+`C-u C-c C-i' to update the internal lists."
+  :group 'idlwave-routine-info-and-completion
+  :type `(repeat
+          (cons (symbol :tag "Derive completion case for")
+                ,idlwave-tmp)))
+
+(defcustom idlwave-completion-force-default-case nil
+  "*Non-nil means, completion will always honor `idlwave-completion-case'.
+When nil, only the completion of a mixed case or upper case string
+will honor the default settings in `idlwave-completion-case', while
+the completion of lower case strings will be completed entirely in
+lower case."
+  :group 'idlwave-routine-info-and-completion
+  :type 'boolean)
+
+(defcustom idlwave-complete-empty-string-as-lower-case nil
+  "*Non-nil means, the empty string is considered downcase for completion.
+The case of what is already in the buffer determines the case of completions.
+When this variable is non-nil, the empty string is considered to be downcase.
+Completing on the empty string then offers downcase versions of the possible
+completions."
+  :group 'idlwave-routine-info-and-completion
+  :type 'boolean)
+
+(defvar idlwave-default-completion-case-is-down nil
+  "Obsolete variable.  See `idlwave-complete-empty-string-as-lower-case' and
+`idlwave-completion-case'.")
+
+(defcustom idlwave-buffer-case-takes-precedence nil
+  "*Non-nil means, the case of tokens in buffers dominates over system stuff.
+To make this possible, we need to re-case everything each time we update
+the routine info from the buffers.  This is slow.
+The default is to consider the case given in the system and library files
+first which makes updating much faster."
+  :group 'idlwave-routine-info-and-completion
+  :type 'boolean)
+
+(defcustom idlwave-completion-show-classes 1
+  "*Number of classes to show when completing object methods and keywords.
+When completing methods or keywords for an object with unknown class,
+the *Completions* buffer will show the legal classes for each completion
+like this:
+
+MyMethod <Class1,Class2,Class3>
+
+The value of this variable may be nil to inhibit display, or an integer to
+indicate the maximum number of classes to display.
+
+On XEmacs, a full list of classes will also be placed into a `help-echo'
+property on the competion items, so that the list of classes for the current
+item is displayed in the echo area.  If the value of this variable is a
+negative integer, the `help-echo' property will be suppressed."
+  :group 'idlwave-routine-info-and-completion
+  :type '(choice (const :tag "Don't show" nil)
+                 (integer :tag "Number of classes shown" 1)))
+
+(defcustom idlwave-completion-fontify-classes t
+  "*Non-nil means, fontify the classes in completions buffer.
+This makes it easier to distinguish the completion items from the extra
+class info listed.  See `idlwave-completion-show-classes'."
+  :group 'idlwave-routine-info-and-completion
+  :type 'boolean)
+
+(defcustom idlwave-query-class '((method-default . nil)
+                                 (keyword-default . nil))
+  "Association list governing specification of object classes for completion.
+
+When IDLWAVE is trying to complete items which belong to the object
+oriented part of IDL, it usually cannot determine the class of a given
+object from context.  In order to provide the user with a correct list
+of methods or keywords, it would have to determine the appropriate
+class.  IDLWAVE has two ways to deal with this problem.
+
+1. One possibility is to combine the items of all available
+   classes for the purpose of completion.  So when completing a
+   method, all methods of all classes are available, and when
+   completing a keyword, all keywords allowed for this method in any
+   class will be possible completions.  This behavior is very much
+   like normal completion and is therefore the default.  It works much 
+   better than one might think - only for the INIT, GETPROPERTY and
+   SETPROPERTY the keyword lists become uncomfortably long.
+   See also `idlwave-completion-show-classes'.
+
+2. The second possibility is to ask the user on each occasion.  To
+   make this less interruptive, IDLWAVE can store the class as a text
+   property on the object operator `->'.  For a given object in the
+   source code, class selection will then be needed only once
+   - for example to complete the method.  Keywords to the method can
+   then be completed directly, because the class is already known.
+   You will have to turn on the storage of the selected class
+   explicitly with the variable `idlwave-store-inquired-class'.
+
+This variable allows to configure IDLWAVE's behavior during
+completion.  Its value is an alist, which should contain at least two
+elements: (method-default . VALUE) and (keyword-default . VALUE),
+where VALUE is either t or nil.  These specify if the class should be
+determined during method and keyword completion, respectively.
+
+The alist may have additional entries specifying exceptions from the 
+keyword completion rule for specific methods, like INIT or
+GETPROPERTY.  In order to turn on class specification for the INIT
+method, add an entry (\"INIT\" . t).  The method name must be ALL-CAPS."
+  :group 'idlwave-routine-info-and-completion
+  :type '(list
+          (cons (const method-default)
+                (boolean :tag "Determine class when completing METHODS    "))
+          (cons (const keyword-default)
+                (boolean :tag "Determine class when completing KEYWORDS   "))
+          (repeat
+           :tag "Exceptions to defaults"
+           :inline t
+           (cons (string  :tag "MODULE" :value "")
+                 (boolean :tag "Determine class for this method")))))
+
+(defcustom idlwave-store-inquired-class nil
+  "*Non-nil means, store class of a method call as text property on `->'.
+IDLWAVE sometimes has to ask the user for the class associated with a
+particular object method call.  This happens during the commands
+`idlwave-routine-info' and `idlwave-complete', depending upon the
+value of the variable `idlwave-query-class'.
+
+When you specify a class, this information can be stored as a text
+property on the `->' arrow in the source code, so that during the same 
+editing session, IDLWAVE will not have to ask again.  When this
+variable is non-nil, IDLWAVE will store and reuse the class information.
+The class stored can be checked and removed with `\\[idlwave-routine-info]'
+on the arrow.
+
+The default of this variable is nil, since the result of commands then
+is more predictable.  However, if you know what you are doing, it can
+be nice to turn this on.
+
+An arrow which knows the class will be highlighted with
+`idlwave-class-arrow-face'.  The command \\[idlwave-routine-info]
+displays (with prefix arg: deletes) the class stored on the arrow
+at point."
+  :group 'idlwave-routine-info-and-completion
+  :type 'boolean)
+
+(defcustom idlwave-class-arrow-face 'bold
+  "*Face to highlight object operator arrows `->' which carry a class property.
+When IDLWAVE stores a class name as text property on an object arrow
+(see variable `idlwave-store-inquired-class', it highlights the arrow
+with this font in order to remind the user that this arrow is special."
+  :group 'idlwave-routine-info-and-completion
+  :type 'symbol)
+
+(defcustom idlwave-resize-routine-help-window t
+  "*Non-nil means, resize the Routine-info *Help* window to fit the content."
+  :group 'idlwave-routine-info-and-completion
+  :type 'boolean)
+
+(defcustom idlwave-keyword-completion-adds-equal t
+  "*Non-nil means, completion automatically adds `=' after completed keywords."
+  :group 'idlwave-routine-info
+  :type 'boolean)
+
+(defcustom idlwave-function-completion-adds-paren t
+  "*Non-nil means, completion automatically adds `(' after completed function.
+Nil means, don't add anything.
+A value of `2' means, also add the closing parenthesis and position cursor
+between the two."
+  :group 'idlwave-routine-info
+  :type '(choice (const :tag "Nothing" nil)
+                 (const :tag "(" t)
+                 (const :tag "()" 2)))
+
+(defcustom idlwave-completion-restore-window-configuration t
+  "*Non-nil means, try to restore the window configuration after completion.
+When completion is not unique, Emacs displays a list of completions.
+This messes up your window configuration.  With this variable set, IDLWAVE
+restores the old configuration after successful completion."
+  :group 'idlwave-routine-info-and-completion
+  :type 'boolean)
+
+;;; Variables for abbrev and action behavior -----------------------------
+
+(defgroup idlwave-abbrev-and-indent-action nil
+  "IDLWAVE performs actions when expanding abbreviations or indenting lines.
+The variables in this group govern this."
+  :group 'idlwave)
+
+(defcustom idlwave-do-actions nil
+  "*Non-nil means performs actions when indenting.
+The actions that can be performed are listed in `idlwave-indent-action-table'."
+  :group 'idlwave-abbrev-and-indent-action
+  :type 'boolean)
+
+(defcustom idlwave-abbrev-start-char "\\"
+  "*A single character string used to start abbreviations in abbrev mode.
+Possible characters to chose from: ~`\%
+or even '?'.  '.' is not a good choice because it can make structure
+field names act like abbrevs in certain circumstances.
+
+Changes to this in `idlwave-mode-hook' will have no effect.  Instead a user
+must set it directly using `setq' in the .emacs file before idlwave.el
+is loaded."
+  :group 'idlwave-abbrev-and-indent-action
+  :type 'string)
+
+(defcustom idlwave-surround-by-blank nil
+  "*Non-nil means, enable `idlwave-surround'.
+If non-nil, `=',`<',`>',`&',`,' are surrounded with spaces by
+`idlwave-surround'.
+See help for `idlwave-indent-action-table' for symbols using `idlwave-surround'.
+
+Also see the default key bindings for keys using `idlwave-surround'.
+Keys are bound and made into actions calling `idlwave-surround' with
+`idlwave-action-and-binding'.
+See help for `idlwave-action-and-binding' for examples.
+
+Also see help for `idlwave-surround'."
+  :group 'idlwave-abbrev-and-indent-action
+  :type 'boolean)
+
+(defcustom idlwave-pad-keyword t
+  "*Non-nil means pad '=' for keywords like assignments.
+Whenever `idlwave-surround' is non-nil then this affects how '=' is padded
+for keywords.  If non-nil it is padded the same as for assignments.
+If nil then spaces are removed."
+  :group 'idlwave-abbrev-and-indent-action
+  :type 'boolean)
+
+(defcustom idlwave-show-block t
+  "*Non-nil means point blinks to block beginning for `idlwave-show-begin'."
+  :group 'idlwave-abbrev-and-indent-action
+  :type 'boolean)
+
+(defcustom idlwave-expand-generic-end nil
+  "*Non-nil means expand generic END to ENDIF/ENDELSE/ENDWHILE etc."
+  :group 'idlwave-abbrev-and-indent-action
+  :type 'boolean)
+
+(defcustom idlwave-abbrev-move t
+  "*Non-nil means the abbrev hook can move point.
+Set to nil by `idlwave-expand-region-abbrevs'. To see the abbrev
+definitions, use the command `list-abbrevs', for abbrevs that move
+point. Moving point is useful, for example, to place point between
+parentheses of expanded functions.
+
+See `idlwave-check-abbrev'."
+  :group 'idlwave-abbrev-and-indent-action
+  :type 'boolean)
+
+(defcustom idlwave-abbrev-change-case nil
+  "*Non-nil means all abbrevs will be forced to either upper or lower case.
+If the value t, all expanded abbrevs will be upper case.
+If the value is 'down then abbrevs will be forced to lower case.
+If nil, the case will not change.
+If `idlwave-reserved-word-upcase' is non-nil, reserved words will always be
+upper case, regardless of this variable."
+  :group 'idlwave-abbrev-and-indent-action
+  :type 'boolean)
+
+(defcustom idlwave-reserved-word-upcase nil
+  "*Non-nil means, reserved words will be made upper case via abbrev expansion.
+If nil case of reserved words is controlled by `idlwave-abbrev-change-case'.
+Has effect only if in abbrev-mode."
+  :group 'idlwave-abbrev-and-indent-action
+  :type 'boolean)
+
+;;; Action/Expand Tables.
+;;
+;; The average user may have difficulty modifying this directly.  It
+;; can be modified/set in idlwave-mode-hook, but it is easier to use
+;; idlwave-action-and-binding. See help for idlwave-action-and-binding for
+;; examples of how to add an action.
+;;
+;; The action table is used by `idlwave-indent-line' whereas both the
+;; action and expand tables are used by `idlwave-indent-and-action'.  In
+;; general, the expand table is only used when a line is explicitly
+;; indented.  Whereas, in addition to being used when the expand table
+;; is used, the action table is used when a line is indirectly
+;; indented via line splitting, auto-filling or a new line creation.
+;;
+;; Example actions:
+;;
+;;  Capitalize system vars
+;;   (idlwave-action-and-binding idlwave-sysvar '(capitalize-word 1) t)
+;;
+;;  Capitalize procedure name
+;;   (idlwave-action-and-binding "\\<\\(pro\\|function\\)\\>[ \t]*\\<"
+;;                           '(capitalize-word 1) t)
+;;
+;;  Capitalize common block name
+;;   (idlwave-action-and-binding "\\<common\\>[ \t]+\\<"
+;;                           '(capitalize-word 1) t)
+;;  Capitalize label
+;;   (idlwave-action-and-binding (concat "^[ \t]*" idlwave-label)
+;;                           '(capitalize-word -1) t)
+
+(defvar idlwave-indent-action-table nil
+  "*Associated array containing action lists of search string (car),
+and function as a cdr. This table is used by `idlwave-indent-line'.
+See documentation for `idlwave-do-action' for a complete description of
+the action lists.
+
+Additions to the table are made with `idlwave-action-and-binding' when a
+binding is not requested.
+See help on `idlwave-action-and-binding' for examples.")
+
+(defvar idlwave-indent-expand-table nil
+  "*Associated array containing action lists of search string (car),
+and function as a cdr. The table is used by the
+`idlwave-indent-and-action' function. See documentation for
+`idlwave-do-action' for a complete description of the action lists.
+
+Additions to the table are made with `idlwave-action-and-binding' when a
+binding is requested.
+See help on `idlwave-action-and-binding' for examples.")
+
+;;; Documentation header and history keyword ---------------------------------
+
+(defgroup idlwave-documentation nil
+  "Options for documenting IDLWAVE files."
+  :group 'idlwave)
+
+;; FIXME: make defcustom?
+(defvar idlwave-file-header
+  (list nil
+        ";+
+; NAME:
+;
+;
+;
+; PURPOSE:
+;
+;
+;
+; CATEGORY:
+;
+;
+;
+; CALLING SEQUENCE:
+;
+;
+;
+; INPUTS:
+;
+;
+;
+; OPTIONAL INPUTS:
+;
+;
+;
+; KEYWORD PARAMETERS:
+;
+;
+;
+; OUTPUTS:
+;
+;
+;
+; OPTIONAL OUTPUTS:
+;
+;
+;
+; COMMON BLOCKS:
+;
+;
+;
+; SIDE EFFECTS:
+;
+;
+;
+; RESTRICTIONS:
+;
+;
+;
+; PROCEDURE:
+;
+;
+;
+; EXAMPLE:
+;
+;
+;
+; MODIFICATION HISTORY:
+;
+;-
+")
+  "*A list (PATHNAME STRING) specifying the doc-header template to use for
+summarizing a file. If PATHNAME is non-nil then this file will be included.
+Otherwise STRING is used. If NIL, the file summary will be omitted.
+For example you might set PATHNAME to the path for the
+lib_template.pro file included in the IDL distribution.")
+
+(defcustom idlwave-timestamp-hook 'idlwave-default-insert-timestamp
+  "*The hook function used to update the timestamp of a function."
+  :group 'idlwave-documentation
+  :type 'function)
+
+(defcustom idlwave-doc-modifications-keyword "HISTORY"
+  "*The modifications keyword to use with the log documentation commands.
+A ':' is added to the keyword end.
+Inserted by doc-header and used to position logs by doc-modification.
+If nil it will not be inserted."
+  :group 'idlwave-documentation
+  :type 'string)
+
+(defcustom idlwave-doclib-start "^;+\\+"
+  "*Regexp matching the start of a document library header."
+  :group 'idlwave-documentation
+  :type 'regexp)
+
+(defcustom idlwave-doclib-end "^;+-"
+  "*Regexp matching the end of a document library header."
+  :group 'idlwave-documentation
+  :type 'regexp)
+
+;;; External Programs -------------------------------------------------------
+
+(defgroup idlwave-external-programs nil
+  "Miscellaneous options for IDLWAVE mode."
+  :group 'idlwave)
+
+;; WARNING: The following variable has recently been moved from
+;; idlwave-shell.el to this file.  I hope this does not break
+;; anything.
+
+(defcustom idlwave-shell-explicit-file-name "idl"
+  "*If non-nil, is the command to run IDL.
+Should be an absolute file path or path relative to the current environment
+execution search path."
+  :group 'idlwave-external-programs
+  :type 'string)
+
+;; FIXME: Document a case when is this needed.
+(defcustom idlwave-shell-command-line-options nil
+  "*A list of command line options for calling the IDL program."
+  :type '(repeat (string :value ""))
+  :group 'idlwave-external-programs)
+
+(defcustom idlwave-help-application "idlhelp"
+  "*The external application providing reference help for programming."
+  :group 'idlwave-external-programs
+  :type 'string)
+
+;;; Miscellaneous variables -------------------------------------------------
+
+(defgroup idlwave-misc nil
+  "Miscellaneous options for IDLWAVE mode."
+  :group 'idlwave)
+
+(defcustom idlwave-startup-message t
+  "*Non-nil displays a startup message when `idlwave-mode' is first called."
+  :group 'idlwave-misc
+  :type 'boolean)
+
+(defcustom idlwave-default-font-lock-items 
+  '(pros-and-functions batch-files idl-keywords label goto
+                       common-blocks class-arrows)
+  "Items which should be fontified on the default fontification level 2.
+IDLWAVE defines 3 levels of fontification.  Level 1 is very little, level 3
+is everything and level 2 is specified by this list.
+This variable must be set before IDLWAVE gets loaded.  It is
+a list of symbols, the following symbols are allowed.
+
+pros-and-functions   Procedure and Function definitions
+batch-files          Batch Files
+idl-keywords         IDL Keywords
+label                Statement Labels
+goto                 Goto Statements
+common-blocks        Common Blocks
+keyword-parameters   Keyword Parameters in routine definitions and calls
+system-variables     System Variables
+fixme                FIXME: Warning in comments (on XEmacs only v. 21.0 and up)
+class-arrows         Object Arrows with class property"
+  :group 'idlwave-misc
+  :type '(set
+          :inline t :greedy t
+          (const :tag "Procedure and Function definitions" pros-and-functions)
+          (const :tag "Batch Files"                        batch-files)
+          (const :tag "IDL Keywords (reserved words)"      idl-keywords)
+          (const :tag "Statement Labels"                   label)
+          (const :tag "Goto Statements"                    goto)
+          (const :tag "Common Blocks"                      common-blocks)
+          (const :tag "Keyword Parameters"                 keyword-parameters)
+          (const :tag "System Variables"                   system-variables)
+          (const :tag "FIXME: Warning"                     fixme)
+          (const :tag "Object Arrows with class property " class-arrows)))
+
+(defcustom idlwave-mode-hook nil
+  "Normal hook.  Executed when a buffer is put into `idlwave-mode'."
+  :group 'idlwave-misc
+  :type 'hook)
+
+(defcustom idlwave-load-hook nil
+  "Normal hook.  Executed when idlwave.el is loaded."
+  :group 'idlwave-misc
+  :type 'hook)
+
+;;;
+;;; End customization variables section
+;;;
+
+;;; Non customization variables
+
+;;; font-lock mode - Additions by Phil Williams, Ulrik Dickow and
+;;; Simon Marshall <simon@gnu.ai.mit.edu>
+;;; and Carsten Dominik...
+
+(defconst idlwave-font-lock-keywords-1 nil
+  "Subdued level highlighting for IDLWAVE mode.")
+
+(defconst idlwave-font-lock-keywords-2 nil
+  "Medium level highlighting for IDLWAVE mode.")
+
+(defconst idlwave-font-lock-keywords-3 nil
+  "Gaudy level highlighting for IDLWAVE mode.")
+
+(let* ((oldp (or (string-match "Lucid" emacs-version)
+                 (not (boundp 'emacs-minor-version))
+                 (and (<= emacs-major-version 19) 
+                      (<= emacs-minor-version 29))))
+
+       ;; The following are the reserved words in IDL.  Maybe we should
+       ;; highlight some more stuff as well?       
+       (idl-keywords
+;       '("and" "or" "xor" "not"
+;         "eq" "ge" "gt" "le" "lt" "ne" 
+;         "for" "do" "endfor"
+;         "if" "then" "endif" "else" "endelse" 
+;         "case" "of" "endcase"
+;         "begin" "end"
+;         "repeat" "until" "endrep"
+;         "while" "endwhile" 
+;         "goto" "return"
+;         "inherits" "mod" "on_error" "on_ioerror")  ;; on_error is not reserved
+        (concat "\\<\\("
+                "and\\|begin\\|case\\|do\\|e\\(lse\\|nd\\(case\\|else\\|"
+                "for\\|if\\|rep\\|while\\)?\\|q\\)\\|for\\|g\\(oto\\|[et]\\)"
+                "\\|i\\(f\\|nherits\\)\\|l[et]\\|mod\\|n\\(e\\|ot\\)\\|"
+                "o\\(n_ioerror\\|[fr]\\)\\|re\\(peat\\|turn\\)\\|then\\|"
+                "until\\|while\\|xor"
+                "\\)\\>"))
+
+       ;; Procedure declarations.  Fontify keyword plus procedure name.
+       ;; Function  declarations.  Fontify keyword plus function  name.
+       (pros-and-functions
+        '("\\<\\(function\\|pro\\)\\>[ \t]+\\(\\sw+\\(::\\sw+\\)?\\)"
+          (1 font-lock-keyword-face)
+          (2 font-lock-function-name-face nil t)))
+
+       ;; Common blocks
+       (common-blocks
+        '("\\<\\(common\\)\\>[ \t]*\\(\\sw+\\)?[ \t]*,?"
+          (1 font-lock-keyword-face)              ; "common"
+          (2 font-lock-reference-face nil t)      ; block name
+          (font-lock-match-c++-style-declaration-item-and-skip-to-next
+           ;; Start with point after block name and comma
+           (goto-char (match-end 0))  ; needed for XEmacs, could be nil 
+           nil
+           (1 font-lock-variable-name-face)       ; variable names
+           )))
+
+       ;; Batch files
+       (batch-files
+        '("^[ \t]*\\(@[^ \t\n]+\\)" (1 font-lock-string-face)))
+
+       ;; FIXME warning.
+       (fixme
+        '("\\<FIXME:" (0 font-lock-warning-face t)))
+
+       ;; Labels
+       (label
+        '("^[ \t]*\\([a-zA-Z]\\sw*:\\)" (1 font-lock-reference-face)))
+
+       ;; The goto statement and its label
+       (goto
+        '("\\(goto\\)[ \t]*,[ \t]*\\([a-zA-Z]\\sw*\\)"
+          (1 font-lock-keyword-face)
+          (2 font-lock-reference-face)))
+
+       ;; Named parameters, like /xlog or ,xrange=[]
+       ;; This is anchored to the comma preceeding the keyword.
+       ;; With continuation lines, works only during whole buffer fontification.
+       (keyword-parameters
+        '("[(,][ \t]*\\(\\$[ \t]*\n[ \t]*\\)?\\(/[a-zA-Z_]\\sw*\\|[a-zA-Z_]\\sw*[ \t]*=\\)"
+          (2 font-lock-reference-face)))
+
+       ;; System variables stars with a bang.
+       (system-variables
+        '("\\(![a-zA-Z_]+\\(\\.\\sw+\\)?\\)"
+          (1 font-lock-variable-name-face)))
+
+       ;; Special and unusual operators (not used because too noisy)
+       (special-operators
+        '("[<>#]" (0 font-lock-keyword-face)))
+
+       ;; All operators (not used because too noisy)
+       (all-operators
+        '("[-*^#+<>/]" (0 font-lock-keyword-face)))
+        
+       ;; Arrows with text property `idlwave-class'
+       (class-arrows
+        (list 'idlwave-match-class-arrows 
+              (list 0 (if (featurep 'xemacs) 
+                          idlwave-class-arrow-face
+                        'idlwave-class-arrow-face))))
+
+       )
+
+  ;; The following lines are just a dummy to make the compiler shut up
+  ;; about variables bound but not used.
+  (setq oldp oldp
+        idl-keywords idl-keywords
+        pros-and-functions pros-and-functions
+        common-blocks common-blocks
+        batch-files batch-files
+        fixme fixme
+        label label
+        goto goto
+        keyword-parameters keyword-parameters
+        system-variables system-variables
+        special-operators special-operators
+        all-operators all-operators
+        class-arrows class-arrows)
+
+  (setq idlwave-font-lock-keywords-1
+        (list pros-and-functions
+              batch-files
+              ))
+
+  (setq idlwave-font-lock-keywords-2
+        (mapcar 'symbol-value idlwave-default-font-lock-items))
+
+  (setq idlwave-font-lock-keywords-3 
+        (list pros-and-functions
+              batch-files
+              idl-keywords
+              label goto
+              common-blocks
+              keyword-parameters
+              system-variables
+              class-arrows
+              ))
+  )
+
+(defun idlwave-match-class-arrows (limit)
+  ;; Match an object arrow with class property
+  (and idlwave-store-inquired-class
+       (re-search-forward "->" limit 'limit)
+       (get-text-property (match-beginning 0) 'idlwave-class)))
+
+(defvar idlwave-font-lock-keywords idlwave-font-lock-keywords-2
+  "Default expressions to highlight in IDLWAVE mode.")
+
+(defvar idlwave-font-lock-defaults
+  '((idlwave-font-lock-keywords
+     idlwave-font-lock-keywords-1 
+     idlwave-font-lock-keywords-2
+     idlwave-font-lock-keywords-3)
+    nil t 
+    ((?$ . "w") (?_ . "w") (?. . "w")) 
+    beginning-of-line))
+
+(put 'idlwave-mode 'font-lock-defaults 
+     idlwave-font-lock-defaults) ; XEmacs
+
+(defconst idlwave-comment-line-start-skip "^[ \t]*;"
+  "Regexp to match the start of a full-line comment.
+That is the _beginning_ of a line containing a comment delimiter `;' preceded
+only by whitespace.")
+
+(defconst idlwave-begin-block-reg "\\<\\(pro\\|function\\|begin\\|case\\)\\>"
+  "Regular expression to find the beginning of a block. The case does
+not matter. The search skips matches in comments.")
+
+(defconst idlwave-begin-unit-reg "\\<\\(pro\\|function\\)\\>\\|\\`"
+  "Regular expression to find the beginning of a unit. The case does
+not matter.")
+
+(defconst idlwave-end-unit-reg "\\<\\(pro\\|function\\)\\>\\|\\'"
+  "Regular expression to find the line that indicates the end of unit.
+This line is the end of buffer or the start of another unit. The case does
+not matter. The search skips matches in comments.")
+
+(defconst idlwave-continue-line-reg "\\<\\$"
+  "Regular expression to match a continued line.")
+
+(defconst idlwave-end-block-reg
+  "\\<end\\(\\|case\\|else\\|for\\|if\\|rep\\|while\\)\\>"
+  "Regular expression to find the end of a block. The case does
+not matter. The search skips matches found in comments.")
+
+(defconst idlwave-block-matches
+  '(("pro"      . "end")
+    ("function" . "end")
+    ("case"     . "endcase")
+    ("else"     . "endelse")
+    ("for"      . "endfor")
+    ("then"     . "endif")
+    ("repeat"   . "endrep")
+    ("while"    . "endwhile"))
+  "Matches between statements and the corresponding END variant.
+The cars are the reserved words starting a block.  If the block really
+begins with BEGIN, the cars are the reserved words before the begin
+which can be used to identify the block type.
+This is used to check for the correct END type, to close blocks and
+to expand generic end statements to their detailed form.")
+
+(defconst idlwave-block-match-regexp
+  "\\<\\(else\\|for\\|then\\|repeat\\|while\\)\\>"
+"Regular expression matching reserved words which can stand before
+blocks starting with a BEGIN statement.  The matches must have associations
+`idlwave-block-matches'")
+
+(defconst idlwave-identifier "[a-zA-Z][a-zA-Z0-9$_]*"
+  "Regular expression matching an IDL identifier.")
+
+(defconst idlwave-sysvar (concat "!" idlwave-identifier)
+  "Regular expression matching IDL system variables.")
+
+(defconst idlwave-variable (concat idlwave-identifier "\\|" idlwave-sysvar)
+  "Regular expression matching IDL variable names.")
+
+(defconst idlwave-label (concat idlwave-identifier ":")
+  "Regular expression matching IDL labels.")
+
+(defconst idlwave-statement-match
+  (list
+   ;; "endif else" is the the only possible "end" that can be
+   ;; followed by a statement on the same line.
+   '(endelse . ("end\\(\\|if\\)\\s +else" "end\\(\\|if\\)\\s +else"))
+   ;; all other "end"s can not be followed by a statement.
+   (cons 'end (list idlwave-end-block-reg nil))
+   '(if . ("if\\>" "then"))
+   '(for . ("for\\>" "do"))
+   '(begin . ("begin\\>" nil))
+   '(pdef . ("pro\\>\\|function\\>" nil))
+   '(while . ("while\\>" "do"))
+   '(repeat . ("repeat\\>" "repeat"))
+   '(goto . ("goto\\>" nil))
+   '(case . ("case\\>" nil))
+   (cons 'call (list (concat idlwave-identifier "\\(\\s *$\\|\\s *,\\)") nil))
+   '(assign . ("[^=\n]*=" nil)))
+  
+  "Associated list of statement matching regular expressions.
+Each regular expression matches the start of an IDL statement.  The
+first element of each association is a symbol giving the statement
+type.  The associated value is a list.  The first element of this list
+is a regular expression matching the start of an IDL statement for
+identifying the statement type.  The second element of this list is a
+regular expression for finding a substatement for the type.  The
+substatement starts after the end of the found match modulo
+whitespace.  If it is nil then the statement has no substatement.  The
+list order matters since matching an assignment statement exactly is
+not possible without parsing.  Thus assignment statement become just
+the leftover unidentified statements containing and equal sign. "  )
+
+(defvar idlwave-fill-function 'auto-fill-function
+  "IDL mode auto fill function.")
+
+(defvar idlwave-comment-indent-function 'comment-indent-function
+  "IDL mode comment indent function.")
+
+;; Note that this is documented in the v18 manuals as being a string
+;; of length one rather than a single character.
+;; The code in this file accepts either format for compatibility.
+(defvar idlwave-comment-indent-char ?\ 
+  "Character to be inserted for IDL comment indentation.
+Normally a space.")
+
+(defconst idlwave-continuation-char ?$
+  "Character which is inserted as a last character on previous line by
+   \\[idlwave-split-line] to begin a continuation line.  Normally $.")
+
+(defconst idlwave-mode-version " 3.11")
+
+(defmacro idlwave-keyword-abbrev (&rest args)
+  "Creates a function for abbrev hooks to call `idlwave-check-abbrev' with args."
+  (` (quote (lambda ()
+              (, (append '(idlwave-check-abbrev) args))))))
+
+;; If I take the time I can replace idlwave-keyword-abbrev with
+;; idlwave-code-abbrev and remove the quoted abbrev check from
+;; idlwave-check-abbrev.  Then, e.g, (idlwave-keyword-abbrev 0 t) becomes
+;; (idlwave-code-abbrev idlwave-check-abbrev 0 t).  In fact I should change
+;; the name of idlwave-check-abbrev to something like idlwave-modify-abbrev.
+
+(defmacro idlwave-code-abbrev (&rest args)
+  "Creates a function for abbrev hooks that ensures abbrevs are not quoted.
+Specifically, if the abbrev is in a comment or string it is unexpanded.
+Otherwise ARGS forms a list that is evaluated."
+  (` (quote (lambda ()
+              (, (prin1-to-string args))  ;; Puts the code in the doc string
+              (if (idlwave-quoted) (progn (unexpand-abbrev) nil)
+                (, (append args)))))))
+
+(defvar idlwave-mode-map (make-sparse-keymap)
+  "Keymap used in IDL mode.")
+
+(defvar idlwave-mode-syntax-table (make-syntax-table)
+  "Syntax table in use in `idlwave-mode' buffers.")
+
+(modify-syntax-entry ?+   "."  idlwave-mode-syntax-table)
+(modify-syntax-entry ?-   "."  idlwave-mode-syntax-table)
+(modify-syntax-entry ?*   "."  idlwave-mode-syntax-table)
+(modify-syntax-entry ?/   "."  idlwave-mode-syntax-table)
+(modify-syntax-entry ?^   "."  idlwave-mode-syntax-table)
+(modify-syntax-entry ?#   "."  idlwave-mode-syntax-table)
+(modify-syntax-entry ?=   "."  idlwave-mode-syntax-table)
+(modify-syntax-entry ?%   "."  idlwave-mode-syntax-table)
+(modify-syntax-entry ?<   "."  idlwave-mode-syntax-table)
+(modify-syntax-entry ?>   "."  idlwave-mode-syntax-table)
+(modify-syntax-entry ?\'  "\"" idlwave-mode-syntax-table)
+(modify-syntax-entry ?\"  "\"" idlwave-mode-syntax-table)
+(modify-syntax-entry ?\\  "."  idlwave-mode-syntax-table)
+(modify-syntax-entry ?_   "_"  idlwave-mode-syntax-table)
+(modify-syntax-entry ?{   "(}" idlwave-mode-syntax-table)
+(modify-syntax-entry ?}   "){" idlwave-mode-syntax-table)
+(modify-syntax-entry ?$   "_"  idlwave-mode-syntax-table)
+(modify-syntax-entry ?.   "."  idlwave-mode-syntax-table)
+(modify-syntax-entry ?\;  "<"  idlwave-mode-syntax-table)
+(modify-syntax-entry ?\n  ">"  idlwave-mode-syntax-table)
+(modify-syntax-entry ?\f  ">"  idlwave-mode-syntax-table)
+
+(defvar idlwave-find-symbol-syntax-table
+  (copy-syntax-table idlwave-mode-syntax-table)
+  "Syntax table that treats symbol characters as word characters.")
+
+(modify-syntax-entry ?$   "w"  idlwave-find-symbol-syntax-table)
+(modify-syntax-entry ?_   "w"  idlwave-find-symbol-syntax-table)
+
+(defun idlwave-action-and-binding (key cmd &optional select)
+  "KEY and CMD are made into a key binding and an indent action.
+KEY is a string - same as for the `define-key' function.  CMD is a
+function of no arguments or a list to be evaluated.  CMD is bound to
+KEY in `idlwave-mode-map' by defining an anonymous function calling
+`self-insert-command' followed by CMD.  If KEY contains more than one
+character a binding will only be set if SELECT is 'both.
+
+(KEY . CMD\ is also placed in the `idlwave-indent-expand-table',
+replacing any previous value for KEY.  If a binding is not set then it
+will instead be placed in `idlwave-indent-action-table'.
+
+If the optional argument SELECT is nil then an action and binding are
+created.  If SELECT is 'noaction, then a binding is always set and no
+action is created.  If SELECT is 'both then an action and binding
+will both be created even if KEY contains more than one character.
+Otherwise, if SELECT is non-nil then only an action is created.
+
+Some examples:
+No spaces before and 1 after a comma
+   (idlwave-action-and-binding \",\"  '(idlwave-surround 0 1))
+A minimum of 1 space before and after `=' (see `idlwave-expand-equal').
+   (idlwave-action-and-binding \"=\"  '(idlwave-expand-equal -1 -1))
+Capitalize system variables - action only
+   (idlwave-action-and-binding idlwave-sysvar '(capitalize-word 1) t)"
+  (if (not (equal select 'noaction))
+      ;; Add action
+      (let* ((table (if select 'idlwave-indent-action-table
+                      'idlwave-indent-expand-table))
+             (cell (assoc key (eval table))))
+        (if cell
+            ;; Replace action command
+            (setcdr cell cmd)
+          ;; New action
+          (set table (append (eval table) (list (cons key cmd)))))))
+  ;; Make key binding for action
+  (if (or (and (null select) (= (length key) 1))
+          (equal select 'noaction)
+          (equal select 'both))
+      (define-key idlwave-mode-map key
+        (append '(lambda ()
+                            (interactive)
+                            (self-insert-command 1))
+                (list (if (listp cmd)
+                          cmd
+                        (list cmd)))))))
+
+(fset 'idlwave-debug-map (make-sparse-keymap))
+
+(define-key idlwave-mode-map "'"        'idlwave-show-matching-quote)
+(define-key idlwave-mode-map "\""       'idlwave-show-matching-quote)
+(define-key idlwave-mode-map "\C-c;"    'idlwave-toggle-comment-region)
+(define-key idlwave-mode-map "\C-\M-a"  'idlwave-beginning-of-subprogram)
+(define-key idlwave-mode-map "\C-\M-e"  'idlwave-end-of-subprogram)
+(define-key idlwave-mode-map "\C-c{"    'idlwave-beginning-of-block)
+(define-key idlwave-mode-map "\C-c}"    'idlwave-end-of-block)
+(define-key idlwave-mode-map "\C-c]"    'idlwave-close-block)
+(define-key idlwave-mode-map "\M-\C-h"  'idlwave-mark-subprogram)
+(define-key idlwave-mode-map "\M-\C-n"  'idlwave-forward-block)
+(define-key idlwave-mode-map "\M-\C-p"  'idlwave-backward-block)
+(define-key idlwave-mode-map "\M-\C-d"  'idlwave-down-block)
+(define-key idlwave-mode-map "\M-\C-u"  'idlwave-backward-up-block)
+(define-key idlwave-mode-map "\M-\r"    'idlwave-split-line)
+(define-key idlwave-mode-map "\M-\C-q"  'idlwave-indent-subprogram)
+(define-key idlwave-mode-map "\C-c\C-p" 'idlwave-previous-statement)
+(define-key idlwave-mode-map "\C-c\C-n" 'idlwave-next-statement)
+;; (define-key idlwave-mode-map "\r"       'idlwave-newline)
+;; (define-key idlwave-mode-map "\t"       'idlwave-indent-line)
+(define-key idlwave-mode-map "\C-c\C-a" 'idlwave-auto-fill-mode)
+(define-key idlwave-mode-map "\M-q"     'idlwave-fill-paragraph)
+(define-key idlwave-mode-map "\M-s"     'idlwave-edit-in-idlde)
+(define-key idlwave-mode-map "\C-c\C-h" 'idlwave-doc-header)
+(define-key idlwave-mode-map "\C-c\C-m" 'idlwave-doc-modification)
+(define-key idlwave-mode-map "\C-c\C-c" 'idlwave-case)
+(define-key idlwave-mode-map "\C-c\C-d" 'idlwave-debug-map)
+(define-key idlwave-mode-map "\C-c\C-d\C-c" 'idlwave-shell-save-and-run)
+(define-key idlwave-mode-map "\C-c\C-f" 'idlwave-for)
+;;  (define-key idlwave-mode-map "\C-c\C-f" 'idlwave-function)
+;;  (define-key idlwave-mode-map "\C-c\C-p" 'idlwave-procedure)
+(define-key idlwave-mode-map "\C-c\C-r" 'idlwave-repeat)
+(define-key idlwave-mode-map "\C-c\C-w" 'idlwave-while)
+(define-key idlwave-mode-map "\C-c\C-s" 'idlwave-shell)
+(define-key idlwave-mode-map "\C-c\C-l" 'idlwave-shell-recenter-shell-window)
+(autoload 'idlwave-shell-send-command "idlwave-shell")
+(autoload 'idlwave-shell-recenter-shell-window "idlwave-shell"
+  "Run `idlwave-shell' and switch back to current window" t)
+(autoload 'idlwave-shell-save-and-run "idlwave-shell"
+  "Save and run buffer under the shell." t)
+(define-key idlwave-mode-map "\C-c\C-v"   'idlwave-find-module)
+(define-key idlwave-mode-map "\C-c?"      'idlwave-routine-info)
+(define-key idlwave-mode-map "\M-?"       'idlwave-routine-info-from-idlhelp)
+(define-key idlwave-mode-map [(meta tab)] 'idlwave-complete)
+(define-key idlwave-mode-map "\C-c\C-i"   'idlwave-update-routine-info)
+(define-key idlwave-mode-map "\C-c="      'idlwave-resolve)
+
+;; Set action and key bindings.
+;; See description of the function `idlwave-action-and-binding'.
+;; Automatically add spaces for the following characters
+(idlwave-action-and-binding "&"  '(idlwave-surround -1 -1))
+(idlwave-action-and-binding "<"  '(idlwave-surround -1 -1))
+(idlwave-action-and-binding ">"  '(idlwave-surround -1 -1 '(?-)))
+(idlwave-action-and-binding ","  '(idlwave-surround 0 -1))
+;; Automatically add spaces to equal sign if not keyword
+(idlwave-action-and-binding "="  '(idlwave-expand-equal -1 -1))
+
+;;;
+;;; Abbrev Section
+;;;
+;;; When expanding abbrevs and the abbrev hook moves backward, an extra
+;;; space is inserted (this is the space typed by the user to expanded
+;;; the abbrev).
+;;;
+
+(condition-case nil
+    (modify-syntax-entry (string-to-char idlwave-abbrev-start-char) 
+                         "w" idlwave-mode-syntax-table)
+  (error nil))
+
+(defvar idlwave-mode-abbrev-table nil
+  "Abbreviation table used for IDLWAVE mode")
+(define-abbrev-table 'idlwave-mode-abbrev-table ())
+(let ((abbrevs-changed nil)          ;; mask the current value to avoid save
+      (tb idlwave-mode-abbrev-table)
+      (c idlwave-abbrev-start-char))
+  ;;
+  ;; Templates
+  ;;
+  (define-abbrev tb (concat c "c")   "" (idlwave-code-abbrev idlwave-case))
+  (define-abbrev tb (concat c "f")   "" (idlwave-code-abbrev idlwave-for))
+  (define-abbrev tb (concat c "fu")  "" (idlwave-code-abbrev idlwave-function))
+  (define-abbrev tb (concat c "pr")  "" (idlwave-code-abbrev idlwave-procedure))
+  (define-abbrev tb (concat c "r")   "" (idlwave-code-abbrev idlwave-repeat))
+  (define-abbrev tb (concat c "w")   "" (idlwave-code-abbrev idlwave-while))
+  (define-abbrev tb (concat c "i")   "" (idlwave-code-abbrev idlwave-if))
+  (define-abbrev tb (concat c "elif") "" (idlwave-code-abbrev idlwave-elif))
+  ;;
+  ;; Keywords, system functions, conversion routines
+  ;;
+  (define-abbrev tb (concat c "b")  "begin"        (idlwave-keyword-abbrev 0 t))
+  (define-abbrev tb (concat c "co") "common"       (idlwave-keyword-abbrev 0 t))
+  (define-abbrev tb (concat c "cb") "byte()"       (idlwave-keyword-abbrev 1))
+  (define-abbrev tb (concat c "cx") "fix()"        (idlwave-keyword-abbrev 1))
+  (define-abbrev tb (concat c "cl") "long()"       (idlwave-keyword-abbrev 1))
+  (define-abbrev tb (concat c "cf") "float()"      (idlwave-keyword-abbrev 1))
+  (define-abbrev tb (concat c "cs") "string()"     (idlwave-keyword-abbrev 1))
+  (define-abbrev tb (concat c "cc") "complex()"    (idlwave-keyword-abbrev 1))
+  (define-abbrev tb (concat c "cd") "double()"     (idlwave-keyword-abbrev 1))
+  (define-abbrev tb (concat c "e")  "else"         (idlwave-keyword-abbrev 0 t))
+  (define-abbrev tb (concat c "ec") "endcase"      'idlwave-show-begin)
+  (define-abbrev tb (concat c "ee") "endelse"      'idlwave-show-begin)
+  (define-abbrev tb (concat c "ef") "endfor"       'idlwave-show-begin)
+  (define-abbrev tb (concat c "ei") "endif else if" 'idlwave-show-begin)
+  (define-abbrev tb (concat c "el") "endif else"   'idlwave-show-begin)
+  (define-abbrev tb (concat c "en") "endif"        'idlwave-show-begin)
+  (define-abbrev tb (concat c "er") "endrep"       'idlwave-show-begin)
+  (define-abbrev tb (concat c "ew") "endwhile"     'idlwave-show-begin)
+  (define-abbrev tb (concat c "g")  "goto,"        (idlwave-keyword-abbrev 0 t))
+  (define-abbrev tb (concat c "h")  "help,"        (idlwave-keyword-abbrev 0))
+  (define-abbrev tb (concat c "k")  "keyword_set()" (idlwave-keyword-abbrev 1))
+  (define-abbrev tb (concat c "n")  "n_elements()" (idlwave-keyword-abbrev 1))
+  (define-abbrev tb (concat c "on") "on_error,"    (idlwave-keyword-abbrev 0))
+  (define-abbrev tb (concat c "oi") "on_ioerror,"  (idlwave-keyword-abbrev 0 1))
+  (define-abbrev tb (concat c "ow") "openw,"       (idlwave-keyword-abbrev 0))
+  (define-abbrev tb (concat c "or") "openr,"       (idlwave-keyword-abbrev 0))
+  (define-abbrev tb (concat c "ou") "openu,"       (idlwave-keyword-abbrev 0))
+  (define-abbrev tb (concat c "p")  "print,"       (idlwave-keyword-abbrev 0))
+  (define-abbrev tb (concat c "pt") "plot,"        (idlwave-keyword-abbrev 0))
+  (define-abbrev tb (concat c "re") "read,"        (idlwave-keyword-abbrev 0))
+  (define-abbrev tb (concat c "rf") "readf,"       (idlwave-keyword-abbrev 0))
+  (define-abbrev tb (concat c "ru") "readu,"       (idlwave-keyword-abbrev 0))
+  (define-abbrev tb (concat c "rt") "return"       (idlwave-keyword-abbrev 0))
+  (define-abbrev tb (concat c "sc") "strcompress()" (idlwave-keyword-abbrev 1))
+  (define-abbrev tb (concat c "sn") "strlen()"     (idlwave-keyword-abbrev 1))
+  (define-abbrev tb (concat c "sl") "strlowcase()" (idlwave-keyword-abbrev 1))
+  (define-abbrev tb (concat c "su") "strupcase()"  (idlwave-keyword-abbrev 1))
+  (define-abbrev tb (concat c "sm") "strmid()"     (idlwave-keyword-abbrev 1))
+  (define-abbrev tb (concat c "sp") "strpos()"     (idlwave-keyword-abbrev 1))
+  (define-abbrev tb (concat c "st") "strput()"     (idlwave-keyword-abbrev 1))
+  (define-abbrev tb (concat c "sr") "strtrim()"    (idlwave-keyword-abbrev 1))
+  (define-abbrev tb (concat c "t")  "then"         (idlwave-keyword-abbrev 0 t))
+  (define-abbrev tb (concat c "u")  "until"        (idlwave-keyword-abbrev 0 t))
+  (define-abbrev tb (concat c "wu") "writeu,"      (idlwave-keyword-abbrev 0))
+  (define-abbrev tb (concat c "ine") "if n_elements() eq 0 then"
+    (idlwave-keyword-abbrev 11))
+  (define-abbrev tb (concat c "inn") "if n_elements() ne 0 then"
+    (idlwave-keyword-abbrev 11))
+  (define-abbrev tb (concat c "np") "n_params()"   (idlwave-keyword-abbrev 0))
+  (define-abbrev tb (concat c "s")  "size()"       (idlwave-keyword-abbrev 1))
+  (define-abbrev tb (concat c "wi") "widget_info()" (idlwave-keyword-abbrev 1))
+  (define-abbrev tb (concat c "wc") "widget_control," (idlwave-keyword-abbrev 0))
+  
+  ;; This section is reserved words only. (From IDL user manual)
+  ;;
+  (define-abbrev tb "and"        "and"        (idlwave-keyword-abbrev 0 t))
+  (define-abbrev tb "begin"      "begin"      (idlwave-keyword-abbrev 0 t))
+  (define-abbrev tb "case"       "case"       (idlwave-keyword-abbrev 0 t))
+  (define-abbrev tb "common"     "common"     (idlwave-keyword-abbrev 0 t))
+  (define-abbrev tb "do"         "do"         (idlwave-keyword-abbrev 0 t))
+  (define-abbrev tb "else"       "else"       (idlwave-keyword-abbrev 0 t))
+  (define-abbrev tb "end"        "end"        'idlwave-show-begin-check)
+  (define-abbrev tb "endcase"    "endcase"    'idlwave-show-begin-check)
+  (define-abbrev tb "endelse"    "endelse"    'idlwave-show-begin-check)
+  (define-abbrev tb "endfor"     "endfor"     'idlwave-show-begin-check)
+  (define-abbrev tb "endif"      "endif"      'idlwave-show-begin-check)
+  (define-abbrev tb "endrep"     "endrep"     'idlwave-show-begin-check)
+  (define-abbrev tb "endwhi"     "endwhi"     'idlwave-show-begin-check)
+  (define-abbrev tb "endwhile"   "endwhile"   'idlwave-show-begin-check)
+  (define-abbrev tb "eq"         "eq"         (idlwave-keyword-abbrev 0 t))
+  (define-abbrev tb "for"        "for"        (idlwave-keyword-abbrev 0 t))
+  (define-abbrev tb "function"   "function"   (idlwave-keyword-abbrev 0 t))
+  (define-abbrev tb "ge"         "ge"         (idlwave-keyword-abbrev 0 t))
+  (define-abbrev tb "goto"       "goto"       (idlwave-keyword-abbrev 0 t))
+  (define-abbrev tb "gt"         "gt"         (idlwave-keyword-abbrev 0 t))
+  (define-abbrev tb "if"         "if"         (idlwave-keyword-abbrev 0 t))
+  (define-abbrev tb "le"         "le"         (idlwave-keyword-abbrev 0 t))
+  (define-abbrev tb "lt"         "lt"         (idlwave-keyword-abbrev 0 t))
+  (define-abbrev tb "mod"        "mod"        (idlwave-keyword-abbrev 0 t))
+  (define-abbrev tb "ne"         "ne"         (idlwave-keyword-abbrev 0 t))
+  (define-abbrev tb "not"        "not"        (idlwave-keyword-abbrev 0 t))
+  (define-abbrev tb "of"         "of"         (idlwave-keyword-abbrev 0 t))
+  (define-abbrev tb "on_ioerror" "on_ioerror" (idlwave-keyword-abbrev 0 t))
+  (define-abbrev tb "or"         "or"         (idlwave-keyword-abbrev 0 t))
+  (define-abbrev tb "pro"        "pro"        (idlwave-keyword-abbrev 0 t))
+  (define-abbrev tb "repeat"     "repeat"     (idlwave-keyword-abbrev 0 t))
+  (define-abbrev tb "then"       "then"       (idlwave-keyword-abbrev 0 t))
+  (define-abbrev tb "until"      "until"      (idlwave-keyword-abbrev 0 t))
+  (define-abbrev tb "while"      "while"      (idlwave-keyword-abbrev 0 t))
+  (define-abbrev tb "xor"        "xor"        (idlwave-keyword-abbrev 0 t)))
+
+(defvar imenu-create-index-function)
+(defvar extract-index-name-function)
+(defvar prev-index-position-function)
+(defvar imenu-extract-index-name-function)
+(defvar imenu-prev-index-position-function)
+;; defined later - so just make the compiler shut up
+(defvar idlwave-mode-menu)  
+(defvar idlwave-mode-debug-menu)
+
+;;;###autoload
+(defun idlwave-mode ()
+  "Major mode for editing IDL and WAVE CL .pro files.
+
+The main features of this mode are
+
+1. Indentation and Formatting
+   --------------------------
+   Like other Emacs programming modes, C-j inserts a newline and indents.
+   TAB is used for explicit indentation of the current line.
+
+   To start a continuation line, use \\[idlwave-split-line].  This function can also
+   be used in the middle of a line to split the line at that point.
+   When used inside a long constant string, the string is split at
+   that point with the `+' concatenation operator.
+
+   Comments are indented as follows:
+
+   `;;;' Indentation remains unchanged.
+   `;;'  Indent like the surrounding code
+   `;'   Indent to a minimum column.
+
+   The indentation of comments starting in column 0 is never changed.
+
+   Use \\[idlwave-fill-paragraph] to refill a paragraph inside a comment.  The indentation
+   of the second line of the paragraph relative to the first will be
+   retained.  Use \\[idlwave-auto-fill-mode] to toggle auto-fill mode for these comments.
+   When the variable `idlwave-fill-comment-line-only' is nil, code
+   can also be auto-filled and auto-indented (not recommended).
+
+   To convert pre-existing IDL code to your formatting style, mark the
+   entire buffer with \\[mark-whole-buffer] and execute \\[idlwave-expand-region-abbrevs].
+   Then mark the entire buffer again followed by \\[indent-region] (`indent-region').
+
+2. Routine Info
+   ------------
+   IDLWAVE displays information about the calling sequence and the accepted
+   keyword parameters of a procedure or function with \\[idlwave-routine-info].
+   \\[idlwave-find-module] jumps to the source file of a module.
+   These commands know about system routines, all routines in idlwave-mode
+   buffers and (when the idlwave-shell is active) about all modules
+   currently compiled under this shell.  Use \\[idlwave-update-routine-info] to update this
+   information, which is also used for completion (see next item).
+
+3. Completion
+   ----------
+   \\[idlwave-complete] completes the names of procedures, functions and
+   keyword parameters.  It is context sensitive and figures out what
+   is expected at point (procedure/function/keyword).  Lower case
+   strings are completed in lower case, other strings in mixed or
+   upper case.
+
+4. Code Templates and Abbreviations
+   --------------------------------
+   Many Abbreviations are predefined to expand to code fragments and templates.
+   The abbreviations start generally with a `\\`.  Some examples
+
+   \\pr        PROCEDURE template
+   \\fu        FUNCTION template
+   \\c         CASE statement template
+   \\f         FOR loop template
+   \\r         REPEAT Loop template
+   \\w         WHILE loop template
+   \\i         IF statement template
+   \\elif      IF-ELSE statement template
+   \\b         BEGIN
+   
+   For a full list, use \\[idlwave-list-abbrevs].  Some templates also have
+   direct keybindings - see the list of keybindings below.
+
+   \\[idlwave-doc-header] inserts a documentation header at the beginning of the
+   current program unit (pro, function or main).  Change log entries
+   can be added to the current program unit with \\[idlwave-doc-modification].
+
+5. Automatic Case Conversion
+   -------------------------
+   The case of reserved words and some abbrevs is controlled by
+   `idlwave-reserved-word-upcase' and `idlwave-abbrev-change-case'.
+
+6. Automatic END completion
+   ------------------------
+   If the variable `idlwave-expand-generic-end' is non-nil, each END typed
+   will be converted to the specific version, like ENDIF, ENDFOR, etc.
+
+7. Hooks
+   -----
+   Loading idlwave.el runs `idlwave-load-hook'.
+   Turning on `idlwave-mode' runs `idlwave-mode-hook'.
+
+8. Documentation and Customization
+   -------------------------------
+   Info documentation for this package is available.  Use \\[idlwave-info]
+   to display (complain to your sysadmin if that does not work).
+   For Postscript and HTML versions of the documentation, check IDLWAVE's
+   homepage at `http://www.strw.leidenuniv.nl/~dominik/Tools/idlwave'.
+   IDLWAVE has customize support - see the group `idlwave'.
+
+9. Keybindings
+   -----------
+   Here is a list of all keybindings of this mode.
+   If some of the key bindings below show with ??, use \\[describe-key]
+   followed by the key sequence to see what the key sequence does.
+
+\\{idlwave-mode-map}"
+
+  (interactive)
+  (kill-all-local-variables)
+  
+  (if idlwave-startup-message
+      (message "Emacs IDLWAVE mode version %s." idlwave-mode-version))
+  (setq idlwave-startup-message nil)
+  
+  (setq local-abbrev-table idlwave-mode-abbrev-table)
+  (set-syntax-table idlwave-mode-syntax-table)
+  
+  (set (make-local-variable 'indent-line-function) 'idlwave-indent-and-action)
+  
+  (make-local-variable idlwave-comment-indent-function)
+  (set idlwave-comment-indent-function 'idlwave-comment-hook)
+  
+  (set (make-local-variable 'comment-start-skip) ";+[ \t]*")
+  (set (make-local-variable 'comment-start) ";")
+  (set (make-local-variable 'require-final-newline) t)
+  (set (make-local-variable 'abbrev-all-caps) t)
+  (set (make-local-variable 'indent-tabs-mode) nil)
+  (set (make-local-variable 'completion-ignore-case) t)
+  
+  (use-local-map idlwave-mode-map)
+
+  (when (featurep 'easymenu)
+    (easy-menu-add idlwave-mode-menu idlwave-mode-map)
+    (easy-menu-add idlwave-mode-debug-menu idlwave-mode-map))
+
+  (setq mode-name "IDLWAVE")
+  (setq major-mode 'idlwave-mode)
+  (setq abbrev-mode t)
+  
+  (set (make-local-variable idlwave-fill-function) 'idlwave-auto-fill)
+  (setq comment-end "")
+  (set (make-local-variable 'comment-multi-line) nil)
+  (set (make-local-variable 'paragraph-separate) "[ \t\f]*$\\|[ \t]*;+[ \t]*$")
+  (set (make-local-variable 'paragraph-start) "[ \t\f]\\|[ \t]*;+[ \t]")
+  (set (make-local-variable 'paragraph-ignore-fill-prefix) nil)
+  (set (make-local-variable 'parse-sexp-ignore-comments) nil)
+  
+  ;; Set tag table list to use IDLTAGS as file name.
+  (if (boundp 'tag-table-alist)
+      (add-to-list 'tag-table-alist '("\\.pro$" . "IDLTAGS")))
+  
+  ;; Font-lock additions - originally Phil Williams, then Ulrik Dickow
+  ;; Following line is for Emacs - XEmacs uses the corresponding porperty
+  ;; on the `idlwave-mode' symbol.
+  (set (make-local-variable 'font-lock-defaults) idlwave-font-lock-defaults)
+
+  ;; Imenu setup
+  (set (make-local-variable 'imenu-create-index-function)
+       'imenu-default-create-index-function)
+  (set (make-local-variable 'imenu-extract-index-name-function)
+       'idlwave-unit-name)
+  (set (make-local-variable 'imenu-prev-index-position-function)
+       'idlwave-prev-index-position)
+
+  ;; Make a local post-command-hook and add our hook to it
+  (make-local-hook 'post-command-hook)
+  (add-hook 'post-command-hook 'idlwave-command-hook nil t)
+
+  ;; Run the mode hook
+  (run-hooks 'idlwave-mode-hook))
+
+;;
+;;  Done with start up and initialization code.
+;;  The remaining routines are the code formatting functions.
+;;
+
+(defun idlwave-push-mark (&rest rest)
+  "Push mark for compatibility with Emacs 18/19."
+  (if (fboundp 'iconify-frame)
+      (apply 'push-mark rest)
+    (push-mark)))
+
+(defun idlwave-hard-tab ()
+  "Inserts TAB in buffer in current position."
+  (interactive)
+  (insert "\t"))
+
+;;; This stuff is experimental
+
+(defvar idlwave-command-hook nil
+  "If non-nil, a list that can be evaluated using `eval'.
+It is evaluated in the lisp function `idlwave-command-hook' which is
+placed in `post-command-hook'.")
+
+(defun idlwave-command-hook ()
+  "Command run after every command.
+Evaluates a non-nil value of the *variable* `idlwave-command-hook' and
+sets the variable to zero afterwards."
+  (and idlwave-command-hook
+       (listp idlwave-command-hook)
+       (condition-case nil
+           (eval idlwave-command-hook)
+         (error nil)))
+  (setq idlwave-command-hook nil))
+
+;;; End experiment
+
+;; It would be better to use expand.el for better abbrev handling and
+;; versatility.
+
+(defun idlwave-check-abbrev (arg &optional reserved)
+  "Reverses abbrev expansion if in comment or string.
+Argument ARG is the number of characters to move point
+backward if `idlwave-abbrev-move' is non-nil.
+If optional argument RESERVED is non-nil then the expansion
+consists of reserved words, which will be capitalized if
+`idlwave-reserved-word-upcase' is non-nil.
+Otherwise, the abbrev will be capitalized if `idlwave-abbrev-change-case'
+is non-nil, unless its value is \`down in which case the abbrev will be
+made into all lowercase.
+Returns non-nil if abbrev is left expanded."
+  (if (idlwave-quoted)
+      (progn (unexpand-abbrev)
+             nil)
+    (if (and reserved idlwave-reserved-word-upcase)
+        (upcase-region last-abbrev-location (point))
+      (cond
+       ((equal idlwave-abbrev-change-case 'down)
+        (downcase-region last-abbrev-location (point)))
+       (idlwave-abbrev-change-case
+        (upcase-region last-abbrev-location (point)))))
+    (if (and idlwave-abbrev-move (> arg 0))
+        (if (boundp 'post-command-hook)
+            (setq idlwave-command-hook (list 'backward-char (1+ arg)))
+          (backward-char arg)))
+    t))
+
+(defun idlwave-in-comment ()
+  "Returns t if point is inside a comment, nil otherwise."
+  (save-excursion
+    (let ((here (point)))
+      (and (idlwave-goto-comment) (> here (point))))))
+
+(defun idlwave-goto-comment ()
+  "Move to start of comment delimiter on current line.
+Moves to end of line if there is no comment delimiter.
+Ignores comment delimiters in strings.
+Returns point if comment found and nil otherwise."
+  (let ((eos (progn (end-of-line) (point)))
+        (data (match-data))
+        found)
+    ;; Look for first comment delimiter not in a string
+    (beginning-of-line)
+    (setq found (search-forward comment-start eos 'lim))
+    (while (and found (idlwave-in-quote))
+      (setq found (search-forward comment-start eos 'lim)))
+    (store-match-data data)
+    (and found (not (idlwave-in-quote))
+         (progn
+           (backward-char 1)
+           (point)))))
+
+(defun idlwave-show-matching-quote ()
+  "Insert quote and show matching quote if this is end of a string."
+  (interactive)
+  (let ((bq (idlwave-in-quote))
+        (inq last-command-char))
+    (if (and bq (not (idlwave-in-comment)))
+        (let ((delim (char-after bq)))
+          (insert inq)
+          (if (eq inq delim)
+              (save-excursion
+                (goto-char bq)
+                (sit-for 1))))
+      ;; Not the end of a string
+      (insert inq))))
+
+(defun idlwave-show-begin-check ()
+  "Ensure that the previous word was a token before `idlwave-show-begin'.
+An END token must be preceded by whitespace."
+  (if
+      (save-excursion
+        (backward-word 1)
+        (backward-char 1)
+        (looking-at "[ \t\n\f]"))
+      (idlwave-show-begin)))
+
+(defun idlwave-show-begin ()
+  "Finds the start of current block and blinks to it for a second.
+Also checks if the correct end statement has been used."
+  ;; All end statements are reserved words
+  (let* ((pos (point))
+         end end1)
+    (when (and (idlwave-check-abbrev 0 t)
+               idlwave-show-block)
+      (save-excursion
+        ;; Move inside current block
+        (setq end (buffer-substring 
+                   (save-excursion (skip-chars-backward "a-zA-Z")
+                                   (point))
+                   (point)))
+        (idlwave-beginning-of-statement)
+        (idlwave-block-jump-out -1 'nomark)
+        (when (setq end1 (cdr (idlwave-block-master)))
+          (cond
+           ((null end1)) ; no-opeartion
+           ((string= (downcase end) (downcase end1))
+            (sit-for 1))
+           ((string= (downcase end) "end")
+            ;; A generic end
+            (if idlwave-expand-generic-end
+                (save-excursion
+                  (goto-char pos)
+                  (backward-char 3)
+                  (insert (if (string= end "END") (upcase end1) end1))
+                  (delete-char 3)))
+            (sit-for 1))
+           (t
+            (beep)
+            (message "Warning: Shouldn't this be \"%s\" instead of \"%s\"?" 
+                     end1 end)
+            (sit-for 1))))))))
+
+(defun idlwave-block-master ()
+  (let ((case-fold-search t))
+    (save-excursion
+      (cond
+       ((looking-at "pro\\|case\\|function\\>")
+        (assoc (downcase (match-string 0)) idlwave-block-matches))
+       ((looking-at "begin\\>")
+        (let ((limit (save-excursion 
+                       (idlwave-beginning-of-statement) 
+                       (point))))
+          (cond
+           ((re-search-backward idlwave-block-match-regexp limit t)
+            (assoc (downcase (match-string 1))
+                   idlwave-block-matches))
+           ;;((re-search-backward ":[ \t]*\\=" limit t)
+           ;; ;; seems to be a case thing
+           ;; '("begin" . "end"))
+           (t
+            ;; Just a nromal block
+            '("begin" . "end")))))
+       (t nil)))))
+
+(defun idlwave-close-block ()
+  "Terminate the current block with the correct END statement."
+  (interactive)
+
+  ;; Start new line if we are not in a new line
+  (unless (save-excursion
+            (skip-chars-backward " \t")
+            (bolp))
+    (let ((idlwave-show-block nil))
+      (newline-and-indent)))
+
+  ;; Check which end is needed and insert it.
+  (let ((case-fold-search t) end)
+    (save-excursion
+      (idlwave-beginning-of-statement)
+      (idlwave-block-jump-out -1 'nomark)
+      (if (setq end (idlwave-block-master))
+          (setq end (cdr end))
+        (error "Cannot close block")))
+    (insert end)
+    (idlwave-newline)))
+
+(defun idlwave-surround (&optional before after escape-chars)
+  "Surround the character before point with blanks.
+Optional arguments BEFORE and AFTER affect the behavior before and
+after the previous character. See description of `idlwave-make-space'.
+
+The function does nothing if any of the following conditions is true:
+- `idlwave-surround-by-blank' is nil
+- the character before point is inside a string or comment
+
+When the character 2 positions before point is a member of
+ESCAPE-CHARS, BEFORE is forced to nil."
+
+  (if (and idlwave-surround-by-blank
+           (not (idlwave-quoted)))
+      (progn
+        (if (memq (char-after (- (point) 2)) escape-chars)
+            (setq before nil))
+        (backward-char 1)
+        (save-restriction
+          (let ((here (point)))
+            (skip-chars-backward " \t")
+            (if (bolp)
+                ;; avoid clobbering indent
+                (progn
+                  (move-to-column (idlwave-calculate-indent))
+                  (if (<= (point) here)
+                      (narrow-to-region (point) here))
+                  (goto-char here)))
+            (idlwave-make-space before))
+          (skip-chars-forward " \t"))
+        (forward-char 1)
+        (idlwave-make-space after)
+        ;; Check to see if the line should auto wrap
+        (if (and (equal (char-after (1- (point))) ? )
+                 (> (current-column) fill-column))
+            (funcall auto-fill-function)))))
+
+(defun idlwave-make-space (n)
+  "Make space at point.
+The space affected is all the spaces and tabs around point.
+If n is non-nil then point is left abs(n) spaces from the beginning of
+the contiguous space.
+The amount of space at point is determined by N.
+If the value of N is:
+nil   - do nothing.
+c > 0 - exactly c spaces.
+c < 0 - a minimum of -c spaces, i.e., do not change if there are
+        already -c spaces.
+0     - no spaces."
+  (if (integerp n)
+      (let
+          ((start-col (progn (skip-chars-backward " \t") (current-column)))
+           (left (point))
+           (end-col (progn (skip-chars-forward " \t") (current-column))))
+        (delete-horizontal-space)
+        (cond
+         ((> n 0)
+          (idlwave-indent-to (+ start-col n))
+          (goto-char (+ left n)))
+         ((< n 0)
+          (idlwave-indent-to end-col (- n))
+          (goto-char (- left n)))
+         ;; n = 0, done
+         ))))
+
+(defun idlwave-newline ()
+  "Inserts a newline and indents the current and previous line."
+  (interactive)
+  ;;
+  ;; Handle unterminated single and double quotes
+  ;; If not in a comment and in a string then insertion of a newline
+  ;; will mean unbalanced quotes.
+  ;;
+  (if (and (not (idlwave-in-comment)) (idlwave-in-quote))
+      (progn (beep)
+             (message "Warning: unbalanced quotes?")))
+  (newline)
+  ;;
+  ;; The current line is being split, the cursor should be at the
+  ;; beginning of the new line skipping the leading indentation.
+  ;;
+  ;; The reason we insert the new line before indenting is that the
+  ;; indenting could be confused by keywords (e.g. END) on the line
+  ;; after the split point.  This prevents us from just using
+  ;; `indent-for-tab-command' followed by `newline-and-indent'.
+  ;;
+  (beginning-of-line 0)
+  (idlwave-indent-line)
+  (forward-line)
+  (idlwave-indent-line))
+
+;;
+;;  Use global variable 'comment-column' to set parallel comment
+;;
+;; Modeled on lisp.el
+;; Emacs Lisp and IDL (Wave CL) have identical comment syntax
+(defun idlwave-comment-hook ()
+  "Compute indent for the beginning of the IDL comment delimiter."
+  (if (or (looking-at idlwave-no-change-comment)
+          (if idlwave-begin-line-comment
+              (looking-at idlwave-begin-line-comment)
+            (looking-at "^;")))
+      (current-column)
+    (if (looking-at idlwave-code-comment)
+        (if (save-excursion (skip-chars-backward " \t") (bolp))
+            ;; On line by itself, indent as code
+            (let ((tem (idlwave-calculate-indent)))
+              (if (listp tem) (car tem) tem))
+          ;; after code - do not change
+          (current-column))
+      (skip-chars-backward " \t")
+      (max (if (bolp) 0 (1+ (current-column)))
+           comment-column))))
+
+(defun idlwave-split-line ()
+  "Continue line by breaking line at point and indent the lines.
+For a code line insert continuation marker. If the line is a line comment
+then the new line will contain a comment with the same indentation.
+Splits strings with the IDL operator `+' if `idlwave-split-line-string' is
+non-nil."
+  (interactive)
+  (let (beg)
+    (if (not (idlwave-in-comment))
+        ;; For code line add continuation.
+        ;; Check if splitting a string.
+        (progn
+          (if (setq beg (idlwave-in-quote))
+              (if idlwave-split-line-string
+                  ;; Split the string.
+                  (progn (insert (setq beg (char-after beg)) " + "
+                                 idlwave-continuation-char beg)
+                         (backward-char 1))
+                ;; Do not split the string.
+                (beep)
+                (message "Warning: continuation inside string!!")
+                (insert " " idlwave-continuation-char))
+            ;; Not splitting a string.
+            (insert " " idlwave-continuation-char))
+          (newline-and-indent))
+      (indent-new-comment-line))
+    ;; Indent previous line
+    (setq beg (- (point-max) (point)))
+    (forward-line -1)
+    (idlwave-indent-line)
+    (goto-char (- (point-max) beg))
+    ;; Reindent new line
+    (idlwave-indent-line)))
+
+(defun idlwave-beginning-of-subprogram ()
+  "Moves point to the beginning of the current program unit."
+  (interactive)
+  (idlwave-find-key idlwave-begin-unit-reg -1))
+
+(defun idlwave-end-of-subprogram ()
+  "Moves point to the start of the next program unit."
+  (interactive)
+  (idlwave-end-of-statement)
+  (idlwave-find-key idlwave-end-unit-reg 1))
+
+(defun idlwave-mark-statement ()
+  "Mark current IDL statement."
+  (interactive)
+  (idlwave-end-of-statement)
+  (let ((end (point)))
+    (idlwave-beginning-of-statement)
+    (idlwave-push-mark end nil t)))
+
+(defun idlwave-mark-block ()
+  "Mark containing block."
+  (interactive)
+  (idlwave-end-of-statement)
+  (idlwave-backward-up-block -1)
+  (idlwave-end-of-statement)
+  (let ((end (point)))
+    (idlwave-backward-block)
+    (idlwave-beginning-of-statement)
+    (idlwave-push-mark end nil t)))
+
+
+(defun idlwave-mark-subprogram ()
+  "Put mark at beginning of program, point at end.
+The marks are pushed."
+  (interactive)
+  (idlwave-end-of-statement)
+  (idlwave-beginning-of-subprogram)
+  (let ((beg (point)))
+    (idlwave-forward-block)
+    (idlwave-push-mark beg nil t))
+  (exchange-point-and-mark))
+
+(defun idlwave-backward-up-block (&optional arg)
+  "Move to beginning of enclosing block if prefix ARG >= 0.
+If prefix ARG < 0 then move forward to enclosing block end."
+  (interactive "p")
+  (idlwave-block-jump-out (- arg) 'nomark))
+
+(defun idlwave-beginning-of-block ()
+  "Go to the beginning of the current block."
+  (interactive)
+  (idlwave-block-jump-out -1 'nomark)
+  (forward-word 1))
+
+(defun idlwave-end-of-block ()
+  "Go to the beginning of the current block."
+  (interactive)
+  (idlwave-block-jump-out 1 'nomark)
+  (backward-word 1))
+
+(defun idlwave-forward-block ()
+  "Move across next nested block."
+  (interactive)
+  (if (idlwave-down-block 1)
+      (idlwave-block-jump-out 1 'nomark)))
+
+(defun idlwave-backward-block ()
+  "Move backward across previous nested block."
+  (interactive)
+  (if (idlwave-down-block -1)
+      (idlwave-block-jump-out -1 'nomark)))
+
+(defun idlwave-down-block (&optional arg)
+  "Go down a block.
+With ARG: ARG >= 0 go forwards, ARG < 0 go backwards.
+Returns non-nil if successfull."
+  (interactive "p")
+  (let (status)
+    (if (< arg 0)
+        ;; Backward
+        (let ((eos (save-excursion
+                     (idlwave-block-jump-out -1 'nomark)
+                     (point))))
+          (if (setq status (idlwave-find-key 
+                            idlwave-end-block-reg -1 'nomark eos))
+              (idlwave-beginning-of-statement)
+            (message "No nested block before beginning of containing block.")))
+      ;; Forward
+      (let ((eos (save-excursion
+                   (idlwave-block-jump-out 1 'nomark)
+                   (point))))
+        (if (setq status (idlwave-find-key 
+                          idlwave-begin-block-reg 1 'nomark eos))
+            (idlwave-end-of-statement)
+          (message "No nested block before end of containing block."))))
+    status))
+
+(defun idlwave-mark-doclib ()
+  "Put point at beginning of doc library header, mark at end.
+The marks are pushed."
+  (interactive)
+  (let (beg
+        (here (point)))
+    (goto-char (point-max))
+    (if (re-search-backward idlwave-doclib-start nil t)
+        (progn 
+          (setq beg (progn (beginning-of-line) (point)))
+          (if (re-search-forward idlwave-doclib-end nil t)
+              (progn
+                (forward-line 1)
+                (idlwave-push-mark beg nil t)
+                (message "Could not find end of doc library header.")))
+          (message "Could not find doc library header start.")
+          (goto-char here)))))
+
+(defvar idlwave-shell-prompt-pattern)
+(defun idlwave-beginning-of-statement ()
+  "Move to beginning of the current statement.
+Skips back past statement continuations.
+Point is placed at the beginning of the line whether or not this is an
+actual statement."
+  (interactive)
+  (cond
+   ((eq major-mode 'idlwave-shell-mode)
+    (if (re-search-backward idlwave-shell-prompt-pattern nil t)
+        (goto-char (match-end 0))))
+   (t   
+    (if (save-excursion (forward-line -1) (idlwave-is-continuation-line))
+        (idlwave-previous-statement)
+      (beginning-of-line)))))
+
+(defun idlwave-previous-statement ()
+  "Moves point to beginning of the previous statement.
+Returns t if the current line before moving is the beginning of
+the first non-comment statement in the file, and nil otherwise."
+  (interactive)
+  (let (first-statement)
+    (if (not (= (forward-line -1) 0))
+        ;; first line in file
+        t
+      ;; skip blank lines, label lines, include lines and line comments
+      (while (and
+              ;; The current statement is the first statement until we
+              ;; reach another statement.
+              (setq first-statement
+                    (or
+                     (looking-at idlwave-comment-line-start-skip)
+                     (looking-at "[ \t]*$")
+                     (looking-at (concat "[ \t]*" idlwave-label "[ \t]*$"))
+                     (looking-at "^@")))
+              (= (forward-line -1) 0)))
+      ;; skip continuation lines
+      (while (and
+              (save-excursion
+                (forward-line -1)
+                (idlwave-is-continuation-line))
+              (= (forward-line -1) 0)))
+      first-statement)))
+
+;; FIXME: end-of-statement does not work correctly when comment lines
+;; are inside the statement.  It does work correctly for line-end
+;; comments, though.
+(defun idlwave-end-of-statement ()
+  "Moves point to the end of the current IDL statement.
+If not in a statement just moves to end of line. Returns position."
+  (interactive)
+  (while (and (idlwave-is-continuation-line)
+              (= (forward-line 1) 0)))
+  (end-of-line)
+  (point))
+
+(defun idlwave-next-statement ()
+  "Moves point to beginning of the next IDL statement.
+ Returns t if that statement is the last
+ non-comment IDL statement in the file, and nil otherwise."
+  (interactive)
+  (let (last-statement)
+    (idlwave-end-of-statement)
+    ;; skip blank lines, label lines, include lines and line comments
+    (while (and (= (forward-line 1) 0)
+                ;; The current statement is the last statement until
+                ;; we reach a new statement.
+                (setq last-statement
+                      (or
+                       (looking-at idlwave-comment-line-start-skip)
+                       (looking-at "[ \t]*$")
+                       (looking-at (concat "[ \t]*" idlwave-label "[ \t]*$"))
+                       (looking-at "^@")))))
+    last-statement))
+
+(defun idlwave-skip-label ()
+  "Skip label or case statement element.
+Returns position after label.
+If there is no label point is not moved and nil is returned."
+  ;; Just look for the first non quoted colon and check to see if it
+  ;; is inside a sexp.  If is not in a sexp it must be part of a label
+  ;; or case statement element.
+  (let ((start (point))
+        (end (idlwave-find-key ":" 1 'nomark
+                               (save-excursion
+                                 (idlwave-end-of-statement) (point)))))
+    (if (and end
+             (= (nth 0 (parse-partial-sexp start end)) 0))
+        (progn
+          (forward-char)
+          (point))
+      (goto-char start)
+      nil)))
+
+(defun idlwave-start-of-substatement (&optional pre)
+  "Move to start of next IDL substatement after point.
+Uses the type of the current IDL statement to determine if the next
+statement is on a new line or is a subpart of the current statement.
+Returns point at start of substatement modulo whitespace.
+If optional argument is non-nil move to beginning of current
+substatement. "
+  (let ((orig (point))
+        (eos (idlwave-end-of-statement))
+        (ifnest 0)
+        st nst last)
+    (idlwave-beginning-of-statement)
+    (idlwave-skip-label)
+    (setq last (point))
+    ;; Continue looking for substatements until we are past orig
+    (while (and (<= (point) orig) (not (eobp)))
+      (setq last (point))
+      (setq nst (nth 1 (cdr (setq st (car (idlwave-statement-type))))))
+      (if (equal (car st) 'if) (setq ifnest (1+ ifnest)))
+      (cond ((and nst
+                  (idlwave-find-key nst 1 'nomark eos))
+             (goto-char (match-end 0)))
+            ((and (> ifnest 0) (idlwave-find-key "\\<else\\>" 1 'nomark eos))
+             (setq ifnest (1- ifnest))
+             (goto-char (match-end 0)))
+            (t (setq ifnest 0)
+               (idlwave-next-statement))))
+    (if pre (goto-char last))
+    (point)))
+
+(defun idlwave-statement-type ()
+  "Return the type of the current IDL statement.
+Uses `idlwave-statement-match' to return a cons of (type . point) with
+point the ending position where the type was determined. Type is the
+association from `idlwave-statement-match', i.e. the cons cell from the
+list not just the type symbol. Returns nil if not an identifiable
+statement."
+  (save-excursion
+    ;; Skip whitespace within a statement which is spaces, tabs, continuations
+    (while (looking-at "[ \t]*\\<\\$")
+      (forward-line 1))
+    (skip-chars-forward " \t")
+    (let ((st idlwave-statement-match)
+          (case-fold-search t))
+      (while (and (not (looking-at (nth 0 (cdr (car st)))))
+                  (setq st (cdr st))))
+      (if st
+          (append st (match-end 0))))))
+
+(defun idlwave-expand-equal (&optional before after)
+  "Pad '=' with spaces.
+Two cases: Assignment statement, and keyword assignment.
+The case is determined using `idlwave-start-of-substatement' and
+`idlwave-statement-type'.
+The equal sign will be surrounded by BEFORE and AFTER blanks.
+If `idlwave-pad-keyword' is non-nil then keyword
+assignment is treated just like assignment statements.  Otherwise,
+spaces are removed for keyword assignment.
+Limits in for loops are treated as keyword assignment.
+See `idlwave-surround'. "
+  ;; Even though idlwave-surround checks `idlwave-surround-by-blank' this
+  ;; check saves the time of finding the statement type.
+  (if idlwave-surround-by-blank
+      (let ((st (save-excursion
+                  (idlwave-start-of-substatement t)
+                  (idlwave-statement-type))))
+        (if (or
+             (and (equal (car (car st)) 'assign)
+                  (equal (cdr st) (point)))
+             idlwave-pad-keyword)
+            ;; An assignment statement
+            (idlwave-surround before after)
+          (idlwave-surround 0 0)))))
+
+(defun idlwave-indent-and-action ()
+  "Call `idlwave-indent-line' and do expand actions."
+  (interactive)
+  (idlwave-indent-line t)
+  )
+
+(defun idlwave-indent-line (&optional expand)
+  "Indents current IDL line as code or as a comment.
+The actions in `idlwave-indent-action-table' are performed.
+If the optional argument EXPAND is non-nil then the actions in
+`idlwave-indent-expand-table' are performed."
+  (interactive)
+  ;; Move point out of left margin.
+  (if (save-excursion
+        (skip-chars-backward " \t")
+        (bolp))
+      (skip-chars-forward " \t"))
+  (let ((mloc (point-marker)))
+    (save-excursion
+      (beginning-of-line)
+      (if (looking-at idlwave-comment-line-start-skip)
+          ;; Indentation for a line comment
+          (progn
+            (skip-chars-forward " \t")
+            (idlwave-indent-left-margin (idlwave-comment-hook)))
+        ;;
+        ;; Code Line
+        ;;
+        ;; Before indenting, run action routines.
+        ;;
+        (if (and expand idlwave-do-actions)
+            (mapcar 'idlwave-do-action idlwave-indent-expand-table))
+        ;;
+        (if idlwave-do-actions
+            (mapcar 'idlwave-do-action idlwave-indent-action-table))
+        ;;
+        ;; No longer expand abbrevs on the line.  The user can do this
+        ;; manually using expand-region-abbrevs.
+        ;;
+        ;; Indent for code line
+        ;;
+        (beginning-of-line)
+        (if (or
+             ;; a label line
+             (looking-at (concat "^" idlwave-label "[ \t]*$"))
+             ;; a batch command
+             (looking-at "^[ \t]*@"))
+            ;; leave flush left
+            nil
+          ;; indent the line
+          (idlwave-indent-left-margin (idlwave-calculate-indent)))
+        ;; Adjust parallel comment
+        (end-of-line)
+        (if (idlwave-in-comment)
+            (indent-for-comment))))
+    (goto-char mloc)
+    ;; Get rid of marker
+    (set-marker mloc nil)
+    ))
+
+(defun idlwave-do-action (action)
+  "Perform an action repeatedly on a line.
+ACTION is a list (REG . FUNC).  REG is a regular expression.  FUNC is
+either a function name to be called with `funcall' or a list to be
+evaluated with `eval'.  The action performed by FUNC should leave point
+after the match for REG - otherwise an infinite loop may be entered."
+  (let ((action-key (car action))
+        (action-routine (cdr action)))
+    (beginning-of-line)
+    (while (idlwave-look-at action-key)
+      (if (listp action-routine)
+          (eval action-routine)
+        (funcall action-routine)))))
+
+(defun idlwave-indent-to (col &optional min)
+  "Indent from point with spaces until column COL.
+Inserts space before markers at point."
+  (if (not min) (setq min 0))
+  (insert-before-markers
+   (make-string (max min (- col (current-column))) ? )))
+
+(defun idlwave-indent-left-margin (col)
+  "Indent the current line to column COL.
+Indents such that first non-whitespace character is at column COL
+Inserts spaces before markers at point."
+  (save-excursion
+    (beginning-of-line)
+    (delete-horizontal-space)
+    (idlwave-indent-to col)))
+
+(defun idlwave-indent-subprogram ()
+  "Indents program unit which contains point."
+  (interactive)
+  (save-excursion
+    (idlwave-end-of-statement)
+    (idlwave-beginning-of-subprogram)
+    (let ((beg (point)))
+      (idlwave-forward-block)
+      (message "Indenting subprogram...")
+      (indent-region beg (point) nil))
+    (message "Indenting subprogram...done.")))
+
+(defun idlwave-calculate-indent ()
+  "Return appropriate indentation for current line as IDL code."
+  (save-excursion
+    (beginning-of-line)
+    (cond
+     ;; Check for beginning of unit - main (beginning of buffer), pro, or
+     ;; function
+     ((idlwave-look-at idlwave-begin-unit-reg)
+      0)
+     ;; Check for continuation line
+     ((save-excursion
+        (and (= (forward-line -1) 0)
+             (idlwave-is-continuation-line)))
+      (idlwave-calculate-cont-indent))
+     ;; calculate indent based on previous and current statements
+     (t (let ((the-indent
+               ;; calculate indent based on previous statement
+               (save-excursion
+                 (cond
+                  ((idlwave-previous-statement)
+                   0)
+                  ;; Main block
+                  ((idlwave-look-at idlwave-begin-unit-reg t)
+                   (+ (idlwave-current-statement-indent)
+                      idlwave-main-block-indent))
+                  ;; Begin block
+                  ((idlwave-look-at idlwave-begin-block-reg t)
+                   (+ (idlwave-current-statement-indent)
+                      idlwave-block-indent))
+                  ((idlwave-look-at idlwave-end-block-reg t)
+                   (- (idlwave-current-statement-indent)
+                      idlwave-end-offset
+                      idlwave-block-indent))
+                  ((idlwave-current-statement-indent))))))
+          ;; adjust the indentation based on the current statement
+          (cond
+           ;; End block
+           ((idlwave-look-at idlwave-end-block-reg t)
+            (+ the-indent idlwave-end-offset))
+           (the-indent)))))))
+
+;;
+;; Parenthesses balacing/indent
+;;
+
+(defun idlwave-calculate-cont-indent ()
+  "Calculates the IDL continuation indent column from the previous statement.
+Note that here previous statement means the beginning of the current
+statement if this statement is a continuation of the previous line.
+Intervening comments or comments within the previous statement can
+screw things up if the comments contain parentheses characters."
+  (save-excursion
+    (let* (open
+           (case-fold-search t)
+           (end-reg (progn (beginning-of-line) (point)))
+           (close-exp (progn (skip-chars-forward " \t") (looking-at "\\s)")))
+           (beg-reg (progn (idlwave-previous-statement) (point))))
+      ;;
+      ;; If PRO or FUNCTION declaration indent after name, and first comma.
+      ;;
+      (if (idlwave-look-at "\\<\\(pro\\|function\\)\\>")
+          (progn
+            (forward-sexp 1)
+            (if (looking-at "[ \t]*,[ \t]*")
+                (goto-char (match-end 0)))
+            (current-column))
+        ;;
+        ;; Not a PRO or FUNCTION
+        ;;
+        ;; Look for innermost unmatched open paren
+        ;;
+        (if (setq open (car (cdr (parse-partial-sexp beg-reg end-reg))))
+            ;; Found innermost open paren.
+            (progn
+              (goto-char open)
+              ;; Line up with next word unless this is a closing paren.
+              (cond
+               ;; This is a closed paren - line up under open paren.
+               (close-exp
+                (current-column))
+               ;; Empty - just add regular indent. Take into account
+               ;; the forward-char
+               ((progn
+                  ;; Skip paren
+                  (forward-char 1)
+                  (looking-at "[ \t$]*$"))
+                (+ (current-column) idlwave-continuation-indent -1))
+               ;; Line up with first word
+               ((progn
+                  (skip-chars-forward " \t")
+                  (current-column)))))
+          ;; No unmatched open paren. Just a simple continuation.
+          (goto-char beg-reg)
+          (+ (idlwave-current-indent)
+             ;; Make adjustments based on current line
+             (cond
+              ;; Else statement
+              ((progn
+                 (goto-char end-reg)
+                 (skip-chars-forward " \t")
+                 (looking-at "else"))
+               0)
+              ;; Ordinary continuation
+              (idlwave-continuation-indent))))))))
+
+(defun idlwave-find-key (key-reg &optional dir nomark limit)
+  "Move in direction of the optional second argument DIR to the
+next keyword not contained in a comment or string and occurring before
+optional fourth argument LIMIT. DIR defaults to forward direction.  If
+DIR is negative the search is backwards, otherwise, it is
+forward. LIMIT defaults to the beginning or end of the buffer
+according to the direction of the search. The keyword is given by the
+regular expression argument KEY-REG.  The search is case insensitive.
+Returns position if successful and nil otherwise.  If found
+`push-mark' is executed unless the optional third argument NOMARK is
+non-nil. If found, the point is left at the keyword beginning."
+  (or dir (setq dir 0))
+  (or limit (setq limit (cond ((>= dir 0) (point-max)) ((point-min)))))
+  (let (found
+        (old-syntax-table (syntax-table))
+        (case-fold-search t))
+    (unwind-protect
+        (save-excursion
+          (set-syntax-table idlwave-find-symbol-syntax-table)
+          (if (>= dir 0)
+              (while (and (setq found (and
+                                       (re-search-forward key-reg limit t)
+                                       (match-beginning 0)))
+                          (idlwave-quoted)
+                          (not (eobp))))
+            (while (and (setq found (and
+                                     (re-search-backward key-reg limit t)
+                                     (match-beginning 0)))
+                        (idlwave-quoted)
+                        (not (bobp))))))
+      (set-syntax-table old-syntax-table))
+    (if found (progn
+                (if (not nomark) (push-mark))
+                (goto-char found)))))
+
+(defun idlwave-block-jump-out (&optional dir nomark)
+  "When optional argument DIR is non-negative, move forward to end of
+current block using the `idlwave-begin-block-reg' and `idlwave-end-block-reg'
+regular expressions. When DIR is negative, move backwards to block beginning.
+Recursively calls itself to skip over nested blocks. DIR defaults to
+forward. Calls `push-mark' unless the optional argument NOMARK is
+non-nil. Movement is limited by the start of program units because of
+possibility of unbalanced blocks."
+  (interactive "P")
+  (or dir (setq dir 0))
+  (let* ((here (point))
+         (case-fold-search t)
+         (limit (if (>= dir 0) (point-max) (point-min)))
+         (block-limit (if (>= dir 0) 
+                          idlwave-begin-block-reg
+                        idlwave-end-block-reg))
+         found
+         (block-reg (concat idlwave-begin-block-reg "\\|"
+                            idlwave-end-block-reg))
+         (unit-limit (or (save-excursion
+                           (if (< dir 0)
+                               (idlwave-find-key
+                                idlwave-begin-unit-reg dir t limit)
+                             (end-of-line)
+                             (idlwave-find-key 
+                              idlwave-end-unit-reg dir t limit)))
+                         limit)))
+    (if (>= dir 0) (end-of-line)) ;Make sure we are in current block
+    (if (setq found (idlwave-find-key  block-reg dir t unit-limit))
+        (while (and found (looking-at block-limit))
+          (if (>= dir 0) (forward-word 1))
+          (idlwave-block-jump-out dir t)
+          (setq found (idlwave-find-key block-reg dir t unit-limit))))
+    (if (not nomark) (push-mark here))
+    (if (not found) (goto-char unit-limit)
+      (if (>= dir 0) (forward-word 1)))))
+
+(defun idlwave-current-statement-indent ()
+  "Return indentation of the current statement.
+If in a statement, moves to beginning of statement before finding indent."
+  (idlwave-beginning-of-statement)
+  (idlwave-current-indent))
+
+(defun idlwave-current-indent ()
+  "Return the column of the indentation of the current line.
+Skips any whitespace. Returns 0 if the end-of-line follows the whitespace."
+  (save-excursion
+    (beginning-of-line)
+    (skip-chars-forward " \t")
+    ;; if we are at the end of blank line return 0
+    (cond ((eolp) 0)
+          ((current-column)))))
+
+(defun idlwave-is-continuation-line ()
+  "Tests if current line is continuation line."
+  (save-excursion
+    (idlwave-look-at "\\<\\$")))
+
+(defun idlwave-is-comment-line ()
+  (save-excursion
+    (beginning-of-line 1)
+    (looking-at "[ \t]*;")))
+
+(defun idlwave-look-at (regexp &optional cont beg)
+  "Searches current line from current point for the regular expression
+REGEXP. If optional argument CONT is non-nil, searches to the end of
+the current statement. If optional arg BEG is non-nil, search starts
+from the beginning of the current statement. Ignores matches that end
+in a comment or inside a string expression. Returns point if
+successful, nil otherwise.  This function produces unexpected results
+if REGEXP contains quotes or a comment delimiter. The search is case
+insensitive.  If successful leaves point after the match, otherwise,
+does not move point."
+  (let ((here (point))
+        (old-syntax-table (syntax-table))
+        (case-fold-search t)
+        eos
+        found)
+    (unwind-protect
+        (progn
+          (set-syntax-table idlwave-find-symbol-syntax-table)
+          (setq eos
+                (if cont
+                    (save-excursion (idlwave-end-of-statement) (point))
+                  (save-excursion (end-of-line) (point))))
+          (if beg (idlwave-beginning-of-statement))
+          (while (and (setq found (re-search-forward regexp eos t))
+                      (idlwave-quoted))))
+      (set-syntax-table old-syntax-table))
+    (if (not found) (goto-char here))
+    found))
+
+(defun idlwave-fill-paragraph (&optional nohang)
+  "Fills paragraphs in comments.
+A paragraph is made up of all contiguous lines having the same comment
+leader (the leading whitespace before the comment delimiter and the
+comment delimiter).  In addition, paragraphs are separated by blank
+line comments. The indentation is given by the hanging indent of the
+first line, otherwise by the minimum indentation of the lines after
+the first line. The indentation of the first line does not change.
+Does not effect code lines. Does not fill comments on the same line
+with code.  The hanging indent is given by the end of the first match
+matching `idlwave-hang-indent-regexp' on the paragraph's first line . If the
+optional argument NOHANG is non-nil then the hanging indent is
+ignored."
+  (interactive "P")
+  ;; check if this is a line comment
+  (if (save-excursion
+        (beginning-of-line)
+        (skip-chars-forward " \t")
+        (looking-at comment-start))
+      (let
+          ((indent 999)
+           pre here diff fill-prefix-reg bcl first-indent
+           hang start end)
+        ;; Change tabs to spaces in the surrounding paragraph.
+        ;; The surrounding paragraph will be the largest containing block of
+        ;; contiguous line comments. Thus, we may be changing tabs in
+        ;; a much larger area than is needed, but this is the easiest
+        ;; brute force way to do it.
+        ;;
+        ;; This has the undesirable side effect of replacing the tabs
+        ;; permanently without the user's request or knowledge.
+        (save-excursion
+          (backward-paragraph)
+          (setq start (point)))
+        (save-excursion
+          (forward-paragraph)
+          (setq end (point)))
+        (untabify start end)
+        ;;
+        (setq here (point))
+        (beginning-of-line)
+        (setq bcl (point))
+        (re-search-forward
+         (concat "^[ \t]*" comment-start "+")
+         (save-excursion (end-of-line) (point))
+         t)
+        ;; Get the comment leader on the line and its length
+        (setq pre (current-column))
+        ;; the comment leader is the indentation plus exactly the
+        ;; number of consecutive ";".
+        (setq fill-prefix-reg
+              (concat
+               (setq fill-prefix
+                     (regexp-quote
+                      (buffer-substring (save-excursion
+                                          (beginning-of-line) (point))
+                                        (point))))
+               "[^;]"))
+        
+        ;; Mark the beginning and end of the paragraph
+        (goto-char bcl)
+        (while (and (looking-at fill-prefix-reg)
+                    (not (looking-at paragraph-separate))
+                    (not (bobp)))
+          (forward-line -1))
+        ;; Move to first line of paragraph
+        (if (/= (point) bcl)
+            (forward-line 1))
+        (setq start (point))
+        (goto-char bcl)
+        (while (and (looking-at fill-prefix-reg)
+                    (not (looking-at paragraph-separate))
+                    (not (eobp)))
+          (forward-line 1))
+        (beginning-of-line)
+        (if (or (not (looking-at fill-prefix-reg))
+                (looking-at paragraph-separate))
+            (forward-line -1))
+        (end-of-line)
+        ;; if at end of buffer add a newline (need this because
+        ;; fill-region needs END to be at the beginning of line after
+        ;; the paragraph or it will add a line).
+        (if (eobp)
+            (progn (insert ?\n) (backward-char 1)))
+        ;; Set END to the beginning of line after the paragraph
+        ;; END is calculated as distance from end of buffer
+        (setq end (- (point-max) (point) 1))
+        ;;
+        ;; Calculate the indentation for the paragraph.
+        ;;
+        ;; In the following while statements, after one iteration
+        ;; point will be at the beginning of a line in which case
+        ;; the while will not be executed for the
+        ;; the first paragraph line and thus will not affect the
+        ;; indentation.
+        ;;
+        ;; First check to see if indentation is based on hanging indent.
+        (if (and (not nohang) idlwave-hanging-indent
+                 (setq hang
+                       (save-excursion
+                         (goto-char start)
+                         (idlwave-calc-hanging-indent))))
+            ;; Adjust lines of paragraph by inserting spaces so that
+            ;; each line's indent is at least as great as the hanging
+            ;; indent. This is needed for fill-paragraph to work with
+            ;; a fill-prefix.
+            (progn
+              (setq indent hang)
+              (beginning-of-line)
+              (while (> (point) start)
+                (re-search-forward comment-start-skip
+                                   (save-excursion (end-of-line) (point))
+                                   t)
+                (if (> (setq diff (- indent (current-column))) 0)
+                    (progn
+                      (if (>= here (point))
+                          ;; adjust the original location for the
+                          ;; inserted text.
+                          (setq here (+ here diff)))
+                      (insert (make-string diff ? ))))
+                (forward-line -1))
+              )
+          
+          ;; No hang. Instead find minimum indentation of paragraph
+          ;; after first line.
+          ;; For the following while statement, since START is at the
+          ;; beginning of line and END is at the the end of line
+          ;; point is greater than START at least once (which would
+          ;; be the case for a single line paragraph).
+          (while (> (point) start)
+            (beginning-of-line)
+            (setq indent
+                  (min indent
+                       (progn
+                         (re-search-forward
+                          comment-start-skip
+                          (save-excursion (end-of-line) (point))
+                          t)
+                         (current-column))))
+            (forward-line -1))
+          )
+        (setq fill-prefix (concat fill-prefix
+                                  (make-string (- indent pre)
+                                               ? )))
+        ;; first-line indent
+        (setq first-indent
+              (max
+               (progn
+                 (re-search-forward
+                  comment-start-skip
+                  (save-excursion (end-of-line) (point))
+                  t)
+                 (current-column))
+               indent))
+        
+        ;; try to keep point at its original place
+        (goto-char here)
+
+        ;; In place of the more modern fill-region-as-paragraph, a hack
+        ;; to keep whitespace untouched on the first line within the
+        ;; indent length and to preserve any indent on the first line
+        ;; (first indent).
+        (save-excursion
+          (setq diff
+                (buffer-substring start (+ start first-indent -1)))
+          (subst-char-in-region start (+ start first-indent -1) ?  ?~ nil)
+          (fill-region-as-paragraph
+           start
+           (- (point-max) end)
+           (current-justification)
+           nil)
+          (delete-region start (+ start first-indent -1))
+          (goto-char start)
+          (insert diff))
+        ;; When we want the point at the beginning of the comment
+        ;; body fill-region will put it at the beginning of the line.
+        (if (bolp) (skip-chars-forward (concat " \t" comment-start)))
+        (setq fill-prefix nil))))
+
+(defun idlwave-calc-hanging-indent ()
+  "Calculate the position of the hanging indent for the comment
+paragraph.  The hanging indent position is given by the first match
+with the `idlwave-hang-indent-regexp'.  If `idlwave-use-last-hang-indent' is
+non-nil then use last occurrence matching `idlwave-hang-indent-regexp' on
+the line.
+If not found returns nil."
+  (if idlwave-use-last-hang-indent
+      (save-excursion
+        (end-of-line)
+        (if (re-search-backward
+             idlwave-hang-indent-regexp
+             (save-excursion (beginning-of-line) (point))
+             t)
+            (+ (current-column) (length idlwave-hang-indent-regexp))))
+    (save-excursion
+      (beginning-of-line)
+      (if (re-search-forward
+           idlwave-hang-indent-regexp
+           (save-excursion (end-of-line) (point))
+           t)
+          (current-column)))))
+
+(defun idlwave-auto-fill ()
+  "Called to break lines in auto fill mode.
+Only fills comment lines if `idlwave-fill-comment-line-only' is non-nil.
+Places a continuation character at the end of the line
+if not in a comment.  Splits strings with IDL concatenation operator
+`+' if `idlwave-auto-fill-split-string is non-nil."
+  (if (<= (current-column) fill-column)
+      nil                             ; do not to fill
+    (if (or (not idlwave-fill-comment-line-only)
+            (save-excursion
+              ;; Check for comment line
+              (beginning-of-line)
+              (looking-at idlwave-comment-line-start-skip)))
+        (let (beg)
+          (idlwave-indent-line)
+          ;; Prevent actions do-auto-fill which calls indent-line-function.
+          (let (idlwave-do-actions
+                (paragraph-start ".")
+                (paragraph-separate "."))
+            (do-auto-fill))
+          (save-excursion
+            (end-of-line 0)
+            ;; Indent the split line
+            (idlwave-indent-line)
+            )
+          (if (save-excursion
+                (beginning-of-line)
+                (looking-at idlwave-comment-line-start-skip))
+              ;; A continued line comment
+              ;; We treat continued line comments as part of a comment
+              ;; paragraph. So we check for a hanging indent.
+              (if idlwave-hanging-indent
+                  (let ((here (- (point-max) (point)))
+                        (indent
+                         (save-excursion
+                           (forward-line -1)
+                           (idlwave-calc-hanging-indent))))
+                    (if indent
+                        (progn
+                          ;; Remove whitespace between comment delimiter and
+                          ;; text, insert spaces for appropriate indentation.
+                          (beginning-of-line)
+                          (re-search-forward
+                           comment-start-skip
+                           (save-excursion (end-of-line) (point)) t)
+                          (delete-horizontal-space)
+                          (idlwave-indent-to indent)
+                          (goto-char (- (point-max) here)))
+                      )))
+            ;; Split code or comment?
+            (if (save-excursion
+                  (end-of-line 0)
+                  (idlwave-in-comment))
+                ;; Splitting a non-line comment.
+                ;; Insert the comment delimiter from split line
+                (progn
+                  (save-excursion
+                    (beginning-of-line)
+                    (skip-chars-forward " \t")
+                    ;; Insert blank to keep off beginning of line
+                    (insert " "
+                            (save-excursion
+                              (forward-line -1)
+                              (buffer-substring (idlwave-goto-comment)
+                                                (progn
+                                                  (skip-chars-forward "; ")
+                                                  (point))))))
+                  (idlwave-indent-line))
+              ;; Split code line - add continuation character
+              (save-excursion
+                (end-of-line 0)
+                ;; Check to see if we split a string
+                (if (and (setq beg (idlwave-in-quote))
+                         idlwave-auto-fill-split-string)
+                    ;; Split the string and concatenate.
+                    ;; The first extra space is for the space
+                    ;; the line was split. That space was removed.
+                    (insert " " (char-after beg) " +"))
+                (insert " $"))
+              (if beg
+                  (if idlwave-auto-fill-split-string
+                      ;; Make the second part of continued string
+                      (save-excursion
+                        (beginning-of-line)
+                        (skip-chars-forward " \t")
+                        (insert (char-after beg)))
+                    ;; Warning
+                    (beep)
+                    (message "Warning: continuation inside a string.")))
+              ;; Although do-auto-fill (via indent-new-comment-line) calls
+              ;; idlwave-indent-line for the new line, re-indent again
+              ;; because of the addition of the continuation character.
+              (idlwave-indent-line))
+            )))))
+
+(defun idlwave-auto-fill-mode (arg)
+  "Toggle auto-fill mode for IDL mode.
+With arg, turn auto-fill mode on if arg is positive.
+In auto-fill mode, inserting a space at a column beyond `fill-column'
+automatically breaks the line at a previous space."
+  (interactive "P")
+  (prog1 (set idlwave-fill-function
+              (if (if (null arg)
+                      (not (symbol-value idlwave-fill-function))
+                    (> (prefix-numeric-value arg) 0))
+                  'idlwave-auto-fill
+                nil))
+    ;; update mode-line
+    (set-buffer-modified-p (buffer-modified-p))))
+
+(defun idlwave-doc-header (&optional nomark )
+  "Insert a documentation header at the beginning of the unit.
+Inserts the value of the variable idlwave-file-header. Sets mark before
+moving to do insertion unless the optional prefix argument NOMARK
+is non-nil."
+  (interactive "P")
+  (or nomark (push-mark))
+  ;; make sure we catch the current line if it begins the unit
+  (end-of-line)
+  (idlwave-beginning-of-subprogram)
+  (beginning-of-line)
+  ;; skip function or procedure line
+  (if (idlwave-look-at "\\<\\(pro\\|function\\)\\>")
+      (progn
+        (idlwave-end-of-statement)
+        (if (> (forward-line 1) 0) (insert "\n"))))
+  (if idlwave-file-header
+      (cond ((car idlwave-file-header)
+             (insert-file (car idlwave-file-header)))
+            ((stringp (car (cdr idlwave-file-header)))
+             (insert (car (cdr idlwave-file-header)))))))
+
+
+(defun idlwave-default-insert-timestamp ()
+  "Default timestamp insertion function"
+  (insert (current-time-string))
+  (insert ", " (user-full-name))
+  (insert " <" (user-login-name) "@" (system-name) ">")
+  ;; Remove extra spaces from line
+  (idlwave-fill-paragraph)
+  ;; Insert a blank line comment to separate from the date entry -
+  ;; will keep the entry from flowing onto date line if re-filled.
+  (insert "\n;\n;\t\t"))
+
+(defun idlwave-doc-modification ()
+  "Insert a brief modification log at the beginning of the current program.
+Looks for an occurrence of the value of user variable
+`idlwave-doc-modifications-keyword' if non-nil. Inserts time and user name
+and places the point for the user to add a log. Before moving, saves
+location on mark ring so that the user can return to previous point."
+  (interactive)
+  (push-mark)
+  ;; make sure we catch the current line if it begins the unit
+  (end-of-line)
+  (idlwave-beginning-of-subprogram)
+  (let ((pro (idlwave-look-at "\\<\\(function\\|pro\\)\\>"))
+        (case-fold-search nil))
+    (if (re-search-forward
+         (concat idlwave-doc-modifications-keyword ":")
+         ;; set search limit at next unit beginning
+         (save-excursion (idlwave-end-of-subprogram) (point))
+         t)
+        (end-of-line)
+      ;; keyword not present, insert keyword
+      (if pro (idlwave-next-statement))  ; skip past pro or function statement
+      (beginning-of-line)
+      (insert "\n" comment-start "\n")
+      (forward-line -2)
+      (insert comment-start " " idlwave-doc-modifications-keyword ":")))
+  (idlwave-newline)
+  (beginning-of-line)
+  (insert ";\n;\t")
+  (run-hooks 'idlwave-timestamp-hook))
+
+;;; CJC 3/16/93
+;;; Interface to expand-region-abbrevs which did not work when the
+;;; abbrev hook associated with an abbrev moves point backwards
+;;; after abbrev expansion, e.g., as with the abbrev '.n'.
+;;; The original would enter an infinite loop in attempting to expand
+;;; .n (it would continually expand and unexpand the abbrev without expanding
+;;; because the point would keep going back to the beginning of the
+;;; abbrev instead of to the end of the abbrev). We now keep the
+;;; abbrev hook from moving backwards.
+;;;
+(defun idlwave-expand-region-abbrevs (start end)
+  "Expand each abbrev occurrence in the region.
+Calling from a program, arguments are START END."
+  (interactive "r")
+  (save-excursion
+    (goto-char (min start end))
+    (let ((idlwave-show-block nil)          ;Do not blink
+          (idlwave-abbrev-move nil))        ;Do not move
+      (expand-region-abbrevs start end 'noquery))))
+
+(defun idlwave-quoted ()
+  "Returns t if point is in a comment or quoted string.
+nil otherwise."
+  (or (idlwave-in-comment) (idlwave-in-quote)))
+
+(defun idlwave-in-quote ()
+  "Returns location of the opening quote
+if point is in a IDL string constant, nil otherwise.
+Ignores comment delimiters on the current line.
+Properly handles nested quotation marks and octal
+constants - a double quote followed by an octal digit."
+;;; Treat an octal inside an apostrophe to be a normal string. Treat a
+;;; double quote followed by an octal digit to be an octal constant
+;;; rather than a string. Therefore, there is no terminating double
+;;; quote.
+  (save-excursion
+    ;; Because single and double quotes can quote each other we must
+    ;; search for the string start from the beginning of line.
+    (let* ((start (point))
+           (eol (progn (end-of-line) (point)))
+           (bq (progn (beginning-of-line) (point)))
+           (endq (point))
+           (data (match-data))
+           delim
+           found)
+      (while  (< endq start)
+        ;; Find string start
+        ;; Don't find an octal constant beginning with a double quote
+        (if (re-search-forward "\"[^0-7]\\|'\\|\"$" eol 'lim)
+            ;; Find the string end.
+            ;; In IDL, two consecutive delimiters after the start of a
+            ;; string act as an
+            ;; escape for the delimiter in the string.
+            ;; Two consecutive delimiters alone (i.e., not after the
+            ;; start of a string) is the the null string.
+            (progn
+              ;; Move to position after quote
+              (goto-char (1+ (match-beginning 0)))
+              (setq bq (1- (point)))
+              ;; Get the string delimiter
+              (setq delim (char-to-string (preceding-char)))
+              ;; Check for null string
+              (if (looking-at delim)
+                  (progn (setq endq (point)) (forward-char 1))
+                ;; Look for next unpaired delimiter
+                (setq found (search-forward delim eol 'lim))
+                (while (looking-at delim)
+                  (forward-char 1)
+                  (setq found (search-forward delim eol 'lim)))
+                (if found
+                    (setq endq (- (point) 1))
+                  (setq endq (point)))
+                ))
+          (progn (setq bq (point)) (setq endq (point)))))
+      (store-match-data data)
+      ;; return string beginning position or nil
+      (if (> start bq) bq))))
+
+;; Statement templates
+
+;; Replace these with a general template function, something like
+;; expand.el (I think there was also something with a name similar to
+;; dmacro.el)
+
+(defun idlwave-template (s1 s2 &optional prompt noindent)
+  "Build a template with optional prompt expression.
+
+Opens a line if point is not followed by a newline modulo intervening
+whitespace.  S1 and S2 are strings.  S1 is inserted at point followed
+by S2.  Point is inserted between S1 and S2.  If optional argument
+PROMPT is a string then it is displayed as a message in the
+minibuffer.  The PROMPT serves as a reminder to the user of an
+expression to enter.
+
+The lines containing S1 and S2 are reindented using `indent-region'
+unless the optional second argument NOINDENT is non-nil."
+  (let ((beg (save-excursion (beginning-of-line) (point)))
+        end)
+    (if (not (looking-at "\\s-*\n"))
+        (open-line 1))
+    (insert s1)
+    (save-excursion
+      (insert s2)
+      (setq end (point)))
+    (if (not noindent)
+        (indent-region beg end nil))
+    (if (stringp prompt)
+        (message prompt))))
+
+(defun idlwave-elif ()
+  "Build skeleton IDL if-else block."
+  (interactive)
+  (idlwave-template "if" 
+                    " then begin\n\nendif else begin\n\nendelse"
+                    "Condition expression"))
+
+(defun idlwave-case ()
+  "Build skeleton IDL case statement."
+  (interactive)
+  (idlwave-template "case" " of\n\nendcase" "Selector expression"))
+
+(defun idlwave-for ()
+  "Build skeleton for loop statment."
+  (interactive)
+  (idlwave-template "for" " do begin\n\nendfor" "Loop expression"))
+
+(defun idlwave-if ()
+  "Build skeleton for loop statment."
+  (interactive)
+  (idlwave-template "if" " then begin\n\nendif" "Scalar logical expression"))
+
+(defun idlwave-procedure ()
+  (interactive)
+  (idlwave-template "pro" "\n\nreturn\nend" "Procedure name"))
+
+(defun idlwave-function ()
+  (interactive)
+  (idlwave-template "function" "\n\nreturn\nend" "Function name"))
+
+(defun idlwave-repeat ()
+  (interactive)
+  (idlwave-template "repeat begin\n\nendrep until" "" "Exit condition"))
+
+(defun idlwave-while ()
+  (interactive)
+  (idlwave-template "while" " do begin\n\nendwhile" "Entry condition"))
+
+(defun idlwave-split-string (string &optional pattern)
+  "Return a list of substrings of STRING which are separated by PATTERN.
+If PATTERN is omitted, it defaults to \"[ \\f\\t\\n\\r\\v]+\"."
+  (or pattern
+      (setq pattern "[ \f\t\n\r\v]+"))
+  (let (parts (start 0))
+    (while (string-match pattern string start)
+      (setq parts (cons (substring string start (match-beginning 0)) parts)
+            start (match-end 0)))
+    (nreverse (cons (substring string start) parts))))
+
+(defun idlwave-replace-string (string replace_string replace_with)
+  (let* ((start 0)
+         (last (length string))
+         (ret_string "")
+         end)
+    (while (setq end (string-match replace_string string start))
+      (setq ret_string
+            (concat ret_string (substring string start end) replace_with))
+      (setq start (match-end 0)))
+    (setq ret_string (concat ret_string (substring string start last)))))
+
+(defun idlwave-get-buffer-visiting (file)
+  ;; Return the buffer currently visiting FILE
+  (cond
+   ((boundp 'find-file-compare-truenames) ; XEmacs
+    (let ((find-file-compare-truenames t))
+      (get-file-buffer file)))
+   ((fboundp 'find-buffer-visiting)       ; Emacs
+    (find-buffer-visiting file))
+   (t (error "This should not happen (idlwave-get-buffer-visiting)"))))
+
+(defun idlwave-find-file-noselect (file)
+  ;; Return a buffer visiting file.
+  (or (idlwave-get-buffer-visiting file)
+      (find-file-noselect file)))
+
+(defvar idlwave-scanned-lib-directories)
+(defun idlwave-find-lib-file-noselet (file)
+  ;; Find FILE on the scanned lib path and return a buffer visiting it
+  (let* ((dirs idlwave-scanned-lib-directories)
+         dir efile)
+    (catch 'exit
+      (while (setq dir (pop dirs))
+        (if (file-regular-p
+             (setq efile (expand-file-name file dir)))
+            (throw 'exit (idlwave-find-file-noselect efile)))))))
+
+(defun idlwave-make-tags ()
+  "Creates the IDL tags file IDLTAGS in the current directory from
+the list of directories specified in the minibuffer. Directories may be
+for example: . /usr/local/rsi/idl/lib. All the subdirectories of the
+specified top directories are searched if the directory name is prefixed
+by @. Specify @ directories with care, it may take a long, long time if
+you specify /."
+  (interactive)
+  (let (directory directories cmd append status numdirs dir getsubdirs
+                  buffer save_buffer files numfiles item errbuf)
+    
+    ;;
+    ;; Read list of directories
+    (setq directory (read-string "Tag Directories: " "."))
+    (setq directories (idlwave-split-string directory "[ \t]+"))
+    ;;
+    ;; Set etags command, vars
+    (setq cmd "etags --output=IDLTAGS --language=none --regex='/[
+\\t]*[pP][Rr][Oo][ \\t]+\\([^ \\t,]+\\)/' --regex='/[
+\\t]*[Ff][Uu][Nn][Cc][Tt][Ii][Oo][Nn][ \\t]+\\([^ \\t,]+\\)/' ")
+    (setq append " ")
+    (setq status 0)
+    ;;
+    ;; For each directory
+    (setq numdirs 0)
+    (setq dir (nth numdirs directories))
+    (while (and dir)
+      ;;
+      ;; Find the subdirectories
+      (if (string-match "^[@]\\(.+\\)$" dir)
+          (setq getsubdirs t) (setq getsubdirs nil))
+      (if (and getsubdirs) (setq dir (substring dir 1 (length dir))))
+      (setq dir (expand-file-name dir))
+      (if (file-directory-p dir)
+          (progn
+            (if (and getsubdirs)
+                (progn
+                  (setq buffer (get-buffer-create "*idltags*"))
+                  (call-process "sh" nil buffer nil "-c"
+                                (concat "find " dir " -type d -print"))
+                  (setq save_buffer (current-buffer))
+                  (set-buffer buffer)
+                  (setq files (idlwave-split-string
+                               (idlwave-replace-string
+                                (buffer-substring 1 (point-max))
+                                "\n" "/*.pro ")
+                               "[ \t]+"))
+                  (set-buffer save_buffer)
+                  (kill-buffer buffer))
+              (setq files (list (concat dir "/*.pro"))))
+            ;;
+            ;; For each subdirectory
+            (setq numfiles 0)
+            (setq item (nth numfiles files))
+            (while (and item)
+              ;;
+              ;; Call etags
+              (if (not (string-match "^[ \\t]*$" item))
+                  (progn
+                    (message (concat "Tagging " item "..."))
+                    (setq errbuf (get-buffer-create "*idltags-error*"))
+                    (setq status (+ status
+                                    (call-process "sh" nil errbuf nil "-c"
+                                                  (concat cmd append item))))
+                    ;;
+                    ;; Append additional tags
+                    (setq append " --append ")
+                    (setq numfiles (1+ numfiles))
+                    (setq item (nth numfiles files)))
+                (progn
+                  (setq numfiles (1+ numfiles))
+                  (setq item (nth numfiles files))
+                  )))
+            
+            (setq numdirs (1+ numdirs))
+            (setq dir (nth numdirs directories)))
+        (progn
+          (setq numdirs (1+ numdirs))
+          (setq dir (nth numdirs directories)))))
+    
+    (setq errbuf (get-buffer-create "*idltags-error*"))
+    (if (= status 0)
+        (kill-buffer errbuf))
+    (message "")
+    ))
+
+(defun idlwave-toggle-comment-region (beg end &optional n)
+  "Comment the lines in the region if the first non-blank line is
+commented, and conversely, uncomment region. If optional prefix arg
+N is non-nil, then for N positive, add N comment delimiters or for N
+negative, remove N comment delimiters.
+Uses `comment-region' which does not place comment delimiters on
+blank lines."
+  (interactive "r\nP")
+  (if n
+      (comment-region beg end (prefix-numeric-value n))
+    (save-excursion
+      (goto-char beg)
+      (beginning-of-line)
+      ;; skip blank lines
+      (skip-chars-forward " \t\n")
+      (if (looking-at (concat "[ \t]*\\(" comment-start "+\\)"))
+          (comment-region beg end
+                          (- (length (buffer-substring
+                                      (match-beginning 1)
+                                      (match-end 1)))))
+        (comment-region beg end)))))
+
+
+;; ----------------------------------------------------------------------------
+;; ----------------------------------------------------------------------------
+;; ----------------------------------------------------------------------------
+;; ----------------------------------------------------------------------------
+;;
+;; Completion and Routine Info
+;;
+
+;; String "intern" functions
+
+;; For the completion and routine info function, we want to normalize
+;; the case of procedure names etc.  We do this by "interning" these
+;; string is a hand-crafted way.  Hashes are used to map the downcase
+;; version of the strings to the cased versions.  Since these cased
+;; versions are really lisp objects, we can use `eq' to search, which
+;; is a large performance boost.
+;; All new strings need to be "sinterned".  We do this as early as
+;; possible after getting these strings from completion or buffer
+;; substrings.  So most of the code can simply assume to deal with
+;; "sinterned" strings.  The only exception is that the functions
+;; which scan whole buffers for routine information do not intern the
+;; grabbed strings.  This is only done afterwards.  Therefore in these 
+;; functions it is *not* save to assume the strings can be compared
+;; with `eq' and be fed into the routine assq functions.
+
+;; Here we define the hashing functions.
+
+;; The variables which hold the hashes.
+(defvar idlwave-sint-routines '(nil))
+(defvar idlwave-sint-keywords '(nil))
+(defvar idlwave-sint-methods  '(nil))
+(defvar idlwave-sint-classes  '(nil))
+(defvar idlwave-sint-files    '(nil))
+
+(defun idlwave-reset-sintern (&optional what)
+  "Reset all sintern hashes."
+  ;; Make sure the hash functions are accessible.
+  (if (or (not (fboundp 'gethash))
+          (not (fboundp 'puthash)))
+      (progn 
+        (require 'cl)
+        (or (fboundp 'puthash)
+            (defalias 'puthash 'cl-puthash))))
+  (let ((entries '((idlwave-sint-routines 1000 10)
+                   (idlwave-sint-keywords 1000 10)
+                   (idlwave-sint-methods   100 10)
+                   (idlwave-sint-classes    10 10))))
+
+    ;; Make sure these are lists
+    (loop for entry in entries
+      for var = (car entry)
+      do (if (not (consp (symbol-value var))) (set var (list nil))))
+
+    (when (or (eq what t) (eq what 'syslib)
+              (null (cdr idlwave-sint-routines)))
+      ;; Reset the system & library hash
+      (loop for entry in entries
+        for var = (car entry) for size = (nth 1 entry)
+        do (setcdr (symbol-value var) 
+                   (make-hash-table ':size size ':test 'equal)))
+      (setq idlwave-sint-files nil))
+
+    (when (or (eq what t) (eq what 'bufsh)
+              (null (car idlwave-sint-routines)))
+      ;; Reset the buffer & shell hash
+      (loop for entry in entries
+        for var = (car entry) for size = (nth 1 entry)
+        do (setcar (symbol-value var) 
+                   (make-hash-table ':size size ':test 'equal))))))
+
+(defun idlwave-sintern-routine-or-method (name &optional class set)
+  (if class
+      (idlwave-sintern-method name set)
+    (idlwave-sintern-routine name set)))
+
+(defun idlwave-sintern (stype &rest args)
+  (apply (intern (concat "idlwave-sintern-" (symbol-name stype))) args))
+
+;;(defmacro idlwave-sintern (type var)
+;;  `(cond ((not (stringp name)) name)
+;;       ((gethash (downcase name) (cdr ,var)))
+;;       ((gethash (downcase name) (car ,var)))
+;;       (set (idlwave-sintern-set name ,type ,var set))
+;;       (name)))
+
+(defun idlwave-sintern-routine (name &optional set)
+  (cond ((not (stringp name)) name)
+        ((gethash (downcase name) (cdr idlwave-sint-routines)))
+        ((gethash (downcase name) (car idlwave-sint-routines)))
+        (set (idlwave-sintern-set name 'routine idlwave-sint-routines set))
+        (name)))
+(defun idlwave-sintern-keyword (name &optional set)
+  (cond ((not (stringp name)) name)
+        ((gethash (downcase name) (cdr idlwave-sint-keywords)))
+        ((gethash (downcase name) (car idlwave-sint-keywords)))
+        (set (idlwave-sintern-set name 'keyword idlwave-sint-keywords set))
+        (name)))
+(defun idlwave-sintern-method (name &optional set)
+  (cond ((not (stringp name)) name)
+        ((gethash (downcase name) (cdr idlwave-sint-methods)))
+        ((gethash (downcase name) (car idlwave-sint-methods)))
+        (set (idlwave-sintern-set name 'method idlwave-sint-methods set))
+        (name)))
+(defun idlwave-sintern-class (name &optional set)
+  (cond ((not (stringp name)) name)
+        ((gethash (downcase name) (cdr idlwave-sint-classes)))
+        ((gethash (downcase name) (car idlwave-sint-classes)))
+        (set (idlwave-sintern-set name 'class idlwave-sint-classes set))
+        (name)))
+
+(defun idlwave-sintern-file (name &optional set)
+  (car (or (member name idlwave-sint-files)
+           (setq idlwave-sint-files (cons name idlwave-sint-files)))))
+
+(defun idlwave-sintern-set (name type tables set)
+  (let* ((func (or (cdr (assq type idlwave-completion-case))
+                   'identity))
+         (iname (funcall (if (eq func 'preserve) 'identity func) name))
+         (table (if (eq set 'sys) (cdr tables) (car tables))))
+    (puthash (downcase name) iname table)
+    iname))
+
+(defun idlwave-sintern-rinfo-list (list &optional set)
+  "Sintern all strings in the rinfo LIST.  With optional parameter SET:
+also set new patterns.  Probably this will always have to be t."
+  (let (entry name type class kwds res source call olh new)
+    (while list
+      (setq entry (car list)
+            list (cdr list)
+            name (car entry)
+            type (nth 1 entry)
+            class (nth 2 entry)
+            source (nth 3 entry)
+            call (nth 4 entry)
+            kwds (nth 5 entry)
+            olh (nth 6 entry))
+      (setq kwds (mapcar (lambda (x)
+                           (list (idlwave-sintern-keyword (car x) set)))
+                         kwds))
+      (if class
+          (progn
+            (if (symbolp class) (setq class (symbol-name class)))
+            (setq class (idlwave-sintern-class class set))
+            (setq name (idlwave-sintern-method name set)))
+        (setq name (idlwave-sintern-routine name set)))
+      (if (stringp (cdr source))
+          (setcdr source (idlwave-sintern-file (cdr source) t)))
+      (setq new (if olh
+                    (list name type class source call kwds olh)
+                  (list name type class source call kwds)))
+      (setq res (cons new res)))
+    (nreverse res)))
+
+;;---------------------------------------------------------------------------
+
+
+;; The variables which hold the information
+(defvar idlwave-builtin-routines nil
+  "Holds the routine-info obtained by scanning buffers.")
+(defvar idlwave-buffer-routines nil
+  "Holds the routine-info obtained by scanning buffers.")
+(defvar idlwave-compiled-routines nil
+  "Holds the procedure routine-info obtained by asking the shell.")
+(defvar idlwave-library-routines nil
+  "Holds the procedure routine-info from the library scan.")
+(defvar idlwave-scanned-lib-directories nil
+  "The directories scanned to get libinfo.")
+(defvar idlwave-routines nil
+  "Holds the combinded procedure routine-info.")
+(defvar idlwave-class-alist nil
+  "Holds the class names known to IDLWAVE.")
+(defvar idlwave-class-history nil
+  "The history of classes selected with the minibuffer.")
+(defvar idlwave-force-class-query nil)
+(defvar idlwave-before-completion-wconf nil
+  "The window configuration just before the completion buffer was displayed.")
+
+;;
+;; The code to get routine info from different sources.
+
+(defvar idlwave-builtin-routines)
+(defun idlwave-routines ()
+  "Provide a list of IDL routines.
+This routine loads the builtin routines on the first call.  Later it
+only returns the value of the variable."
+  (or idlwave-routines
+      (progn
+        (idlwave-update-routine-info)
+        ;; return the current value
+        idlwave-routines)))
+
+(defun idlwave-update-routine-info (&optional arg)
+  "Update the internal routine-info lists.
+These lists are used by `idlwave-routine-info' (\\[idlwave-routine-info])
+and by `idlwave-complete' (\\[idlwave-complete]) to provide information
+about individual routines.
+
+The information can come from 4 sources:
+1. IDL programs in the current editing session
+2. Compiled modules in an IDL shell running as Emacs subprocess
+3. A list which covers the IDL system routines.
+4. A list which covers the prescanned library files.
+
+Scans all IDLWAVE-mode buffers of the current editing session (see
+`idlwave-scan-all-buffers-for-routine-info').
+When an IDL shell is running, this command also queries the IDL program
+for currently compiled routines.
+
+With prefix ARG, also reload the system and library lists.
+With two prefix ARG's, also rescans the library tree."
+  (interactive "P")
+  (if (equal arg '(16))
+      (idlwave-create-libinfo-file t)
+    (let* ((reload (or arg
+                       idlwave-buffer-case-takes-precedence
+                       (null idlwave-builtin-routines))))
+      
+      (setq idlwave-buffer-routines nil
+            idlwave-compiled-routines nil)
+      ;; Reset the appropriate hashes
+      (idlwave-reset-sintern (cond (reload t)
+                                   ((null idlwave-builtin-routines) t)
+                                   (t 'bufsh)))
+      
+      (if idlwave-buffer-case-takes-precedence
+          ;; We can safely scan the buffer stuff first
+          (progn
+            (idlwave-update-buffer-routine-info)
+            (and reload (idlwave-load-system-rinfo)))
+        ;; We first do the system info, and then the buffers
+        (and reload (idlwave-load-system-rinfo))
+        (idlwave-update-buffer-routine-info))
+
+      ;; Let's see if there is a shell
+      (let* ((shell-is-running (and (fboundp 'idlwave-shell-is-running)
+                                    (idlwave-shell-is-running)))
+             (ask-shell (and shell-is-running
+                             idlwave-query-shell-for-routine-info)))
+      
+        (if (or (not ask-shell)
+                (not (interactive-p)))
+            ;; 1. If we are not going to ask the shell, we need to do the
+            ;;    concatenation now.
+            ;; 2. When this function is called non-interactively, it means
+            ;;    that someone needs routine info *now*.  The shell update
+            ;;    causes the concatenation *delayed*, so not in time for
+            ;;    the current command.  Therefore, we do a concatenation
+            ;;    now, even though the shell might do it again.
+            (idlwave-concatenate-rinfo-lists))
+      
+        (when ask-shell
+          ;; Ask the shell about the routines it knows.
+          (message "Querying the shell")
+          (idlwave-shell-update-routine-info))))))
+
+(defun idlwave-load-system-rinfo ()
+  ;; Load and case-treat the system and lib info files.
+  (load "idlwave-rinfo" t)
+  (message "Normalizing idlwave-builtin-routines...")
+  (setq idlwave-builtin-routines
+        (idlwave-sintern-rinfo-list idlwave-builtin-routines 'sys))
+  (message "Normalizing idlwave-builtin-routines...done")
+  (setq idlwave-routines idlwave-builtin-routines)
+  (when (and (stringp idlwave-libinfo-file)
+             (file-regular-p idlwave-libinfo-file))
+    (condition-case nil
+        (progn
+          (load-file idlwave-libinfo-file)
+          (message "Normalizing idlwave-library-routines...")
+          (setq idlwave-library-routines (idlwave-sintern-rinfo-list
+                                          idlwave-library-routines 'sys))
+          (message "Normalizing idlwave-library-routines...done"))
+      (error nil))))
+
+(defun idlwave-update-buffer-routine-info ()
+  (let (res)
+    (if idlwave-scan-all-buffers-for-routine-info
+        (progn
+          ;; Scan all buffers, current buffer last
+          (message "Scanning all buffers...")
+          (setq res (idlwave-get-routine-info-from-buffers 
+                     (reverse (buffer-list)))))
+      ;; Just scan this buffer
+      (if (eq major-mode 'idlwave-mode)
+          (progn
+            (message "Scanning current buffer...")
+            (setq res (idlwave-get-routine-info-from-buffers
+                       (list (current-buffer)))))))
+    ;; Put the result into the correct variable
+    (setq idlwave-buffer-routines 
+          (idlwave-sintern-rinfo-list res t))))
+
+(defun idlwave-concatenate-rinfo-lists ()
+  "Put the different sources for routine information together."
+  ;; The sequence here is important because earlier definitions shadow 
+  ;; later ones.  We assume that if things in the buffers are newer
+  ;; then in the shell of the system, it is meant to be different.
+  ;; FIXME: should the builtin stuff be before the library?
+  ;;        This is how IDL searches, the user may also have
+  ;;        functions overloading system stuff, and then the lib
+  ;;        should be first.  Difficult to find a general solution.
+  ;; FIXME: can't we use nconc here in some way, to save memory?
+  ;;        This is possible for buffer abd shell stuff, but these are 
+  ;;        small anyway, and so it is not so critical.
+  (setq idlwave-routines (append idlwave-buffer-routines
+                                 idlwave-compiled-routines
+                                 idlwave-library-routines
+                                 idlwave-builtin-routines))
+  (setq idlwave-class-alist nil)
+  (let (class)
+    (loop for x in idlwave-routines do
+      (when (and (setq class (nth 2 x))
+                 (not (assq class idlwave-class-alist)))
+        (push (list class) idlwave-class-alist))))
+  ;; Give a message with information about the number of routines we have.
+  (message 
+   "Routine info updated:  buffer(%d)  compiled(%d)  library(%d)  system(%d)"
+   (length idlwave-buffer-routines)
+   (length idlwave-compiled-routines)
+   (length idlwave-library-routines)
+   (length idlwave-builtin-routines)))
+
+;;----- Scanning buffers -------------------
+
+(defun idlwave-get-routine-info-from-buffers (buffers)
+  "Call `idlwave-get-buffer-routine-info' on idlwave-mode buffers in BUFFERS."
+  (let (buf routine-lists res)
+    (save-excursion
+      (while (setq buf (pop buffers))
+        (set-buffer buf)
+        (if (eq major-mode 'idlwave-mode)
+            ;; yes, this buffer has the right mode.
+            (progn (setq res (condition-case nil
+                                 (idlwave-get-buffer-routine-info)
+                               (error nil)))
+                   (push res routine-lists)))))
+    ;; Concatenate the individual lists and return the result
+    (apply 'nconc routine-lists)))
+
+(defun idlwave-get-buffer-routine-info ()
+  "Scan the current buffer for routine info.  Return (PRO-LIST FUNC-LIST)."
+  (let* ((case-fold-search t)
+         routine-list string entry)
+    (save-excursion
+      (save-restriction
+        (widen)
+        (goto-char (point-min))
+        (while (re-search-forward 
+                "^[ \t]*\\<\\(pro\\|function\\)\\>" nil t)
+          (setq string (buffer-substring 
+                        (match-beginning 0)
+                        (progn 
+                          (idlwave-end-of-statement)
+                          (point))))
+          (setq entry (idlwave-parse-definition string))
+          (push entry routine-list))))
+    routine-list))
+
+(defun idlwave-parse-definition (string)
+  "Parse a module definition."
+  (let ((case-fold-search t)
+        start name args type keywords class)
+    ;; Remove comments
+    (while (string-match ";.*" string)
+      (setq string (replace-match "" t t string)))
+    ;; Remove the continuation line stuff
+    (while (string-match "\\([^a-zA-Z0-9$_]\\)\\$[ \t]*\n" string)
+      (setq string (replace-match "\\1 " t nil string)))
+    ;; Match the name and type.
+    (when (string-match
+           "\\<\\(pro\\|function\\)\\>\\s-+\\(\\([a-zA-Z0-9$_]+\\)::\\)?\\([a-zA-Z0-9$_]+\\)" string)
+      (setq start (match-end 0))
+      (setq type (downcase (match-string 1 string)))
+      (if (match-beginning 3)
+          (setq class (match-string 3 string)))
+      (setq name (match-string 4 string)))
+    ;; Match normal args and keyword args
+    (while (string-match
+            ",\\s-*\\([a-zA-Z][a-zA-Z0-9$_]*\\|_extra\\)\\s-*\\(=\\)?"
+            string start)
+      (setq start (match-end 0))
+      (if (match-beginning 2)
+          (push (match-string 1 string) keywords)
+        (push (match-string 1 string) args)))
+    ;; Normalize and sort.
+    (setq args (nreverse args))
+    (setq keywords (sort keywords (lambda (a b) 
+                                    (string< (downcase a) (downcase b)))))
+    ;; Make and return the entry
+    ;; We don't know which argument are optional, so this information
+    ;; will not be contained in the calling sequence.
+    (list name
+          (if (equal type "pro") 'pro 'fun)
+          class
+          (cond ((not (boundp 'idlwave-scanning-lib))
+                 (cons 'buffer (buffer-file-name)))
+                ((string= (downcase 
+                           (file-name-sans-extension
+                            (file-name-nondirectory (buffer-file-name))))
+                          (downcase name))
+                 (list 'lib))
+                (t (cons 'lib (file-name-nondirectory (buffer-file-name)))))
+          (concat 
+           (if (string= type "function") "Result = " "")
+           (if class "Obj ->[%s::]" "")
+           "%s"
+           (if args
+               (concat
+                (if (string= type "function") "(" ", ")
+                (mapconcat 'identity args ", ")
+                (if (string= type "function") ")" ""))))
+          (if keywords
+              (mapcar 'list keywords)
+            nil))))
+
+;;----- Scanning the library -------------------
+
+(defun idlwave-create-libinfo-file (&optional arg)
+  "Scan all files on selected dirs of IDL search path for routine information.
+A widget checklist will allow you to choose the directories.
+Write the result as a file `idlwave-libinfo-file'.  When this file exists,
+will be automatically loaded to give routine information about library
+routines.
+With ARG, just rescan the same directories as last time - so no widget
+will pop up."
+  (interactive "P")
+  ;; Make sure the file is loaded if it exists.
+  (if (and (stringp idlwave-libinfo-file)
+           (file-regular-p idlwave-libinfo-file))
+      (condition-case nil
+          (load-file idlwave-libinfo-file)
+        (error nil)))
+  ;; Make sure the file name makes sense
+  (unless (and (stringp idlwave-libinfo-file)
+               (file-accessible-directory-p
+                (file-name-directory idlwave-libinfo-file))
+               (not (string= "" (file-name-nondirectory 
+                                 idlwave-libinfo-file))))
+    (error "`idlwave-libinfo-file' does not point to file in accessible directory."))
+  
+  (cond
+   ((and arg idlwave-scanned-lib-directories)
+    ;; Rescan the known directories
+    (idlwave-scan-lib-files idlwave-scanned-lib-directories))
+   (idlwave-library-path
+    ;; Get the directories from that variable
+    (idlwave-display-libinfo-widget
+     (idlwave-expand-path idlwave-library-path)
+     idlwave-scanned-lib-directories))
+   (t
+    ;; Ask the shell for the path and run the widget
+    (message "Asking the shell for IDL path...")
+    (idlwave-shell-send-command 
+     "__pa=expand_path(!path,/array)&for i=0,n_elements(__pa)-1 do print,'PATH:',__pa[i]"
+     '(idlwave-libinfo-command-hook nil)
+     'hide))))
+
+(defun idlwave-libinfo-command-hook (&optional arg)
+  ;; Command hook used by `idlwave-create-libinfo-file'.
+  (if arg
+      ;; Scan immediately
+      (idlwave-scan-lib-files idlwave-scanned-lib-directories)
+    ;; Display the widget
+    (idlwave-display-libinfo-widget (idlwave-shell-path-filter)
+                                    idlwave-scanned-lib-directories)))
+
+(defvar idlwave-shell-command-output)
+(defun idlwave-shell-path-filter ()
+  ;; Convert the output of the path query into a list of directories
+  (let ((path-string idlwave-shell-command-output)
+        (case-fold-search t)
+        (start 0)
+        dirs)
+    (while (string-match "^PATH:[ \t]*\\(.*\\)\n" path-string start)
+      (push (match-string 1 path-string) dirs)
+      (setq start (match-end 0)))
+    (nreverse dirs)))
+
+(defconst idlwave-libinfo-widget-help-string 
+  "This is the front-end to the creation of IDLWAVE library routine info.
+Please select below the directories on IDL's search path from which you
+would like to extract routine information, which will be stored in the file
+
+             %s
+
+If this is not the correct file, first set variable `idlwave-libinfo-file'.
+Then call this command again.
+After selecting the directories, choose [Scan & Save] to scan the library
+directories and save the routine info.
+\n")
+
+(defvar idlwave-widget)
+(defvar widget-keymap)
+(defun idlwave-display-libinfo-widget (dirs selected-dirs)
+  "Create the widget to select IDL search path directories for scanning."
+  (interactive)
+  (require 'widget)
+  (require 'wid-edit)
+  (unless dirs
+      (error "Don't know IDL's search path"))
+
+  ;; Allow only those directories to be selected which are in the path.
+  (setq selected-dirs (delq nil (mapcar (lambda (x)
+                                          (if (member x dirs) x nil))
+                                        selected-dirs)))
+  (kill-buffer (get-buffer-create "*IDLWAVE Widget*"))
+  (switch-to-buffer (get-buffer-create "*IDLWAVE Widget*"))
+  (kill-all-local-variables)
+  (make-local-variable 'idlwave-widget)
+  (widget-insert (format idlwave-libinfo-widget-help-string
+                         idlwave-libinfo-file))
+  
+  (widget-create 'push-button
+                 :notify 'idlwave-widget-scan-lib-files
+                 :help-echo "testing"
+                 "Scan & Save")
+  (widget-insert "  ")
+  (widget-create 'push-button
+                 :notify (lambda (&rest ignore)
+                           (kill-buffer (current-buffer)))
+                 "Quit")
+  (widget-insert "  ")
+  (widget-create 'push-button
+                 :notify 'idlwave-delete-libinfo-file
+                 "Delete File")
+  (widget-insert "  ")
+  (widget-create 'push-button
+                 :notify '(lambda (&rest ignore)
+                            (idlwave-display-libinfo-widget
+                             (widget-get idlwave-widget :path-dirs)
+                             (widget-get idlwave-widget :path-dirs)))
+                 "Select All")
+  (widget-insert "  ")
+  (widget-create 'push-button
+                 :notify '(lambda (&rest ignore)
+                            (idlwave-display-libinfo-widget
+                             (widget-get idlwave-widget :path-dirs)
+                             nil))
+                 "Deselect All")
+  (widget-insert "\n\n")
+
+  (widget-insert "Select Directories\n")
+  
+  (setq idlwave-widget
+        (apply 'widget-create
+               'checklist
+               :value selected-dirs
+               :greedy t
+               :tag "List of directories"
+               (mapcar (lambda (x) (list 'item x)) dirs)))
+  (widget-put idlwave-widget :path-dirs dirs)
+  (widget-insert "\n")
+  (use-local-map widget-keymap)
+  (widget-setup)
+  (goto-char (point-min))
+  (delete-other-windows))
+  
+(defun idlwave-delete-libinfo-file (&rest ignore)
+  (if (yes-or-no-p
+       (format "Delete file %s " idlwave-libinfo-file))
+      (progn
+        (delete-file idlwave-libinfo-file)
+        (message "%s has been deleted" idlwave-libinfo-file))))
+
+(defun idlwave-widget-scan-lib-files (&rest ignore)
+  ;; Call `idlwave-scan-lib-files' with data taken from the widget.
+  (let* ((widget idlwave-widget)
+         (selected-dirs (widget-value widget)))
+    (idlwave-scan-lib-files selected-dirs)))
+
+(defvar font-lock-mode)
+(defun idlwave-scan-lib-files (selected-dirs)
+  ;; Scan the files in SELECTED-DIRS and store the info in a file
+  (let* ((idlwave-scanning-lib t)
+         (idlwave-completion-case nil)
+         dirs dir files file)
+    (setq idlwave-library-routines nil)
+    (setq idlwave-scanned-lib-directories selected-dirs)
+    (save-excursion
+      (set-buffer (get-buffer-create "*idlwave-scan.pro*"))
+      (idlwave-mode)
+      (setq dirs (reverse selected-dirs))
+      (while (setq dir (pop dirs))
+        (when (file-directory-p dir)
+          (setq files (directory-files dir 'full "\\.[pP][rR][oO]\\'"))
+          (while (setq file (pop files))
+            (when (file-regular-p file)
+              (if (not (file-readable-p file))
+                  (message "Skipping %s (no read permission)" file)
+                (message "Scanning %s..." file)
+                (erase-buffer)
+                (insert-file-contents file 'visit)
+                (setq idlwave-library-routines
+                      (append (idlwave-get-routine-info-from-buffers
+                               (list (current-buffer)))
+                              idlwave-library-routines)))
+              )))))
+    (kill-buffer "*idlwave-scan.pro*")
+    (kill-buffer (get-buffer-create "*IDLWAVE Widget*"))
+    (let ((font-lock-maximum-size 0))
+      (find-file idlwave-libinfo-file))
+    (if (and (boundp 'font-lock-mode)
+             font-lock-mode)
+        (font-lock-mode 0))
+    (erase-buffer)
+    (insert ";; IDLWAVE libinfo file\n")
+    (insert (format ";; Created %s\n\n" (current-time-string)))
+
+    ;; Define the variable which contains a list of all scanned directories
+    (insert "\n(setq idlwave-scanned-lib-directories\n    '(")
+    (mapcar (lambda (x)
+              (insert (format "\n      \"%s\"" x)))
+            selected-dirs)
+    (insert "))\n")
+    ;; Define the routine info list
+    (insert "\n(setq idlwave-library-routines\n    '(")
+    (mapcar (lambda (x)
+              (insert "\n    ")
+              (insert (with-output-to-string (prin1 x))))
+            idlwave-library-routines)
+    (insert (format "))\n\n;;; %s ends here\n"
+                    (file-name-nondirectory idlwave-libinfo-file)))
+    (goto-char (point-min))
+    ;; Save the buffer
+    (save-buffer 0)
+    (kill-buffer (current-buffer)))
+  (message "Info for %d routines saved in %s"
+           (length idlwave-library-routines)
+           idlwave-libinfo-file)
+  (sit-for 2)
+  (idlwave-update-routine-info t))
+
+(defun idlwave-expand-path (path &optional default-dir)
+  ;; Expand parts of path starting with '+' recursively into directory list.
+  ;; Relative recursive path elements are expanded relative to DEFAULT-DIR.
+  (message "Expanding path...")
+  (let (path1 dir recursive)
+    (while (setq dir (pop path))
+      (if (setq recursive (string= (substring dir 0 1) "+"))
+          (setq dir (substring dir 1)))
+      (if (and recursive
+               (not (file-name-absolute-p dir)))
+          (setq dir (expand-file-name dir default-dir)))
+      (if recursive
+          ;; Expand recursively
+          (setq path1 (append (idlwave-recursive-directory-list dir) path1))
+        ;; Keep unchanged
+        (push dir path1)))
+    (message "Expanding path...done")
+    (nreverse path1)))
+
+(defun idlwave-recursive-directory-list (dir)
+  ;; Return a list of all directories below DIR, including DIR itself
+  (let ((path (list dir)) path1 file files)
+    (while (setq dir (pop path))
+      (when (file-directory-p dir)
+        (setq files (nreverse (directory-files dir t "[^.]")))
+        (while (setq file (pop files))
+          (if (file-directory-p file) 
+              (push (file-name-as-directory file) path)))
+        (push dir path1)))
+    path1))
+
+;;----- Asking the shell -------------------
+
+;; First, here is the idl program which can be used to query IDL for
+;; defined routines. 
+(defconst idlwave-routine-info.pro
+  "
+function idlwave_make_info_entry,name,func=func,separator=sep
+  ;; See if it's an object method
+  func    = keyword_set(func) 
+  methsep = strpos(name,'::')
+  meth    = methsep ne -1
+  
+  ;; Get routine info
+  pars   = routine_info(name,/parameters,functions=func)
+  source = routine_info(name,/source,functions=func)
+  nargs  = pars.num_args
+  nkw    = pars.num_kw_args
+  if nargs gt 0 then args = pars.args
+  if nkw   gt 0 then kwargs = pars.kw_args
+  
+  ;; Trim the class, and make the name
+  if meth then begin 
+      class = strmid(name,0,methsep)
+      name  = strmid(name,methsep+2,strlen(name)-1)
+      if nargs gt 0 then begin 
+          ;; remove the self argument
+          wh = where(args ne 'SELF',nargs)
+          if nargs gt 0 then args = args(wh)
+      endif
+  endif else begin
+      ;; No class, just a normal routine.
+      class = \"\"
+  endelse
+   
+  ;; Calling sequence
+  cs = \"\"
+  if func then cs = 'Result = '
+  if meth then cs = cs + 'Obj -> [' + '%s' + '::]'
+  cs = cs + '%s'
+  if func then cs = cs + '(' else if nargs gt 0 then cs = cs + ', '
+  if nargs gt 0 then begin
+      for j=0,nargs-1 do begin
+          cs = cs + args(j)
+          if j lt nargs-1 then cs = cs + ', '
+      endfor
+  end
+  if func then cs = cs + ')'
+  ;; Keyword arguments
+  kwstring = ''
+  if nkw gt 0 then begin
+      for j=0,nkw-1 do begin
+          kwstring = kwstring + ' ' + kwargs(j)
+      endfor
+  endif
+  
+  ret=(['IDLWAVE-PRO','IDLWAVE-FUN', $
+        'IDLWAVE-PRO','IDLWAVE-FUN'])(func+2*meth)
+  
+  return,ret + ': ' + name + sep + class + sep + source(0).path  $
+    + sep + cs + sep + kwstring
+end
+
+pro idlwave_routine_info
+  sep = '<@>'
+  print,'>>>BEGIN OF IDLWAVE ROUTINE INFO (\"' + sep + '\" IS THE SEPARATOR)'
+  all = routine_info()
+  for i=0,n_elements(all)-1 do $
+    print,idlwave_make_info_entry(all(i),separator=sep)
+  all = routine_info(/functions)
+  for i=0,n_elements(all)-1 do $
+    print,idlwave_make_info_entry(all(i),/func,separator=sep)
+  print,'>>>END OF IDLWAVE ROUTINE INFO'
+end
+" 
+  "The idl program to get the routine info stuff.
+The output of this program is parsed by `idlwave-shell-routine-info-filter'.")
+
+(defun idlwave-shell-routine-info-filter ()
+  "Function which parses the special output from idlwave_routine_info.pro."
+  (let ((text idlwave-shell-command-output)
+        (start 0)
+        sep sep-re file type spec specs name cs key keys class)
+    ;; Initialize variables
+    (setq idlwave-compiled-routines nil)
+    ;; Cut out the correct part of the output.
+    (if (string-match
+         "^>>>BEGIN OF IDLWAVE ROUTINE INFO (\"\\(.+\\)\" IS THE SEPARATOR.*"
+         text)
+        (setq sep (match-string 1 text)
+              sep-re (concat (regexp-quote sep) " *")
+              text (substring text (match-end 0)))
+      (error "Routine Info error: No match for BEGIN line"))
+    (if (string-match "^>>>END OF IDLWAVE ROUTINE INFO.*" text)
+        (setq text (substring text 0 (match-beginning 0)))
+      (error "Routine Info error: No match for END line"))
+    ;; Match the output lines
+    (while (string-match "^IDLWAVE-\\(PRO\\|FUN\\): \\(.*\\)" text start)
+      (setq start (match-end 0))
+      (setq type (match-string 1 text)
+            spec (match-string 2 text)
+            specs (idlwave-split-string spec sep-re)
+            name (nth 0 specs)
+            class (if (equal (nth 1 specs) "") nil (nth 1 specs))
+            file (nth 2 specs)
+            cs (nth 3 specs)
+            key (nth 4 specs)
+            keys (if (and (stringp key)
+                          (not (string-match "\\` *\\'" key)))
+                     (mapcar 'list 
+                             (delete "" (idlwave-split-string key " +")))))
+      (setq name (idlwave-sintern-routine-or-method name class t)
+            class (idlwave-sintern-class class t)
+            keys (mapcar (lambda (x) 
+                           (list (idlwave-sintern-keyword (car x) t))) keys))
+      ;; Make sure we use the same string object for the same file
+      (setq file (idlwave-sintern-file file t))
+      ;; FIXME: What should I do with routines from the temp file???
+      ;;        Maybe just leave it in - there is a chance that the
+      ;;        routine is still in there.
+      ;;      (if (equal file idlwave-shell-temp-pro-file)
+      ;;          (setq file nil))
+
+      ;; In the following ignore routines already defined in buffers,
+      ;; assuming that if the buffer stuff differs, it is a "new"
+      ;; version. 
+      ;; We could do the same for the library to avoid duplicates -
+      ;; but I think frequently a user might have several versions of
+      ;; the same function in different programs, and in this case the 
+      ;; compiled one will be the best guess of all version.
+      ;; Therefore, we leave duplicates of library routines in.
+
+      (cond ((string= name "$MAIN$"))    ; ignore this one
+            ((and (string= type "PRO")
+                  ;; FIXME: is it OK to make the buffer routines dominate?
+                  (not (idlwave-rinfo-assq name 'pro class 
+                                           idlwave-buffer-routines))
+                  ;; FIXME: is it OK to make the library routines dominate?
+                  ;;(not (idlwave-rinfo-assq name 'pro class 
+                  ;;                       idlwave-library-routines))
+                  )
+             (push (list name 'pro class (cons 'compiled file) cs keys)
+                   idlwave-compiled-routines))
+            ((and (string= type "FUN")
+                  ;; FIXME: is it OK to make the buffer routines dominate?
+                  (not (idlwave-rinfo-assq name 'fun class 
+                                           idlwave-buffer-routines))
+                  ;; FIXME: is it OK to make the library routines dominate?
+                  ;; (not (idlwave-rinfo-assq name 'fun class 
+                  ;;                       idlwave-library-routines))
+                  )
+             (push (list name 'fun class (cons 'compiled file) cs keys)
+                   idlwave-compiled-routines)))))
+  ;; Reverse the definitions so that they are alphabetically sorted.
+  (setq idlwave-compiled-routines
+        (nreverse idlwave-compiled-routines)))
+
+(defvar idlwave-shell-temp-pro-file)
+(defun idlwave-shell-update-routine-info ()
+  "Query the shell for routine_info of compiled modules and update the lists."
+  ;; Save and compile the procedure
+  (save-excursion
+    (set-buffer (idlwave-find-file-noselect
+                 idlwave-shell-temp-pro-file))
+    (erase-buffer)
+    (insert idlwave-routine-info.pro)
+    (save-buffer 0))
+  (idlwave-shell-send-command (concat ".run " idlwave-shell-temp-pro-file)
+                              nil 'hide)
+
+  ;; Execute the procedure and analyze the output
+  (idlwave-shell-send-command "idlwave_routine_info"
+                              '(progn
+                                 (idlwave-shell-routine-info-filter)
+                                 (idlwave-concatenate-rinfo-lists))
+                              'hide))
+
+;; ---------------------------------------------------------------------------
+;;
+;; Completion and displaying routine calling sequences
+
+(defun idlwave-complete (&optional arg module class)
+  "Complete a function, procedure or keyword name at point.
+This function is smart and figures out what can be legally completed
+at this point.
+- At the beginning of a statement it completes procedure names.
+- In the middle of a statement it completes function names.
+- after a `(' or `,' in the argument list of a function or procedure,
+  it completes a keyword of the relevant function or procedure.
+- In the first arg of `OBJ_NEW', it completes a class name.
+
+When several completions are possible, a list will be displayed in the 
+*Completions* buffer.  If this list is too long to fit into the
+window, scrolling can be achieved by repeatedly pressing \\[idlwave-complete].
+
+The function also knows about object methods.  When it needs a class
+name, the action depends upon `idlwave-query-class', which see.  You
+can force IDLWAVE to ask you for a class name with a \\[universal-argument] prefix
+argument to this command.
+
+See also the variables `idlwave-keyword-completion-adds-equal' and
+`idlwave-function-completion-adds-paren'.
+
+The optional ARG can be used to specify the completion type in order
+to override IDLWAVE's idea of what should be completed at point.
+Possible values are:
+
+0  <=>  query for the completion type
+1  <=>  'procedure
+2  <=>  'procedure-keyword
+3  <=>  'function
+4  <=>  'function-keyword
+5  <=>  'procedure-method
+6  <=>  'procedure-method-keyword
+7  <=>  'function-method
+8  <=>  'function-method-keyword
+9  <=>  'class
+
+For Lisp programmers only:
+When we force a keyword, optional argument MODULE can contain the module name.
+When we force a method or a method keyword, CLASS can specify the class."
+  (interactive "P")
+  (idlwave-routines)
+  (let* ((where-list
+          (if (and arg
+                   (or (integerp arg)
+                       (symbolp arg)))
+              (idlwave-make-force-complete-where-list arg module class)
+            (idlwave-where)))
+         (what (nth 2 where-list))
+         (idlwave-force-class-query (equal arg '(4)))
+         cwin)
+
+    (if (and module (string-match "::" module))
+        (setq class (substring module 0 (match-beginning 0))
+              module (substring module (match-end 0))))
+
+    (cond
+
+     ((and (null arg)
+           (eq (car-safe last-command) 'idlwave-display-completion-list)
+           (setq cwin (get-buffer-window "*Completions*")))
+      (setq this-command last-command)
+      (idlwave-scroll-completions))
+
+     ((null what)
+      (error "Nothing to complete here"))
+
+     ((eq what 'class)
+      (idlwave-complete-class))
+
+     ((eq what 'procedure)
+      ;; Complete a procedure name
+      (let* ((class-selector (idlwave-determine-class (nth 3 where-list) 'pro))
+             (isa (concat "procedure" (if class-selector "-method" "")))
+             (type-selector 'pro))
+        (idlwave-complete-in-buffer
+         'procedure (if class-selector 'method 'routine)
+         (idlwave-routines) 'idlwave-selector
+         (format "Select a %s name%s"
+                 isa
+                 (if class-selector
+                     (format " (class is %s)" class-selector)
+                   ""))
+         isa
+         'idlwave-attach-method-classes)))
+
+     ((eq what 'function)
+      ;; Complete a function name
+      (let* ((class-selector (idlwave-determine-class (nth 3 where-list) 'fun))
+             (isa (concat "function" (if class-selector "-method" "")))
+             (type-selector 'fun))
+        (idlwave-complete-in-buffer
+         'function (if class-selector 'method 'routine)
+         (idlwave-routines) 'idlwave-selector
+         (format "Select a %s name%s"
+                 isa
+                 (if class-selector
+                     (format " (class is %s)" class-selector)
+                   ""))
+         isa
+         'idlwave-attach-method-classes)))
+
+     ((eq what 'procedure-keyword)
+      ;; Complete a procedure keyword
+      (let* ((where (nth 3 where-list))
+             (name  (car where))
+             (method-selector name)
+             (type-selector 'pro)
+             (class (idlwave-determine-class where 'pro))
+             (class-selector class)
+             (isa (format "procedure%s-keyword" (if class "-method" "")))
+             (entry (idlwave-rinfo-assq
+                     name 'pro class (idlwave-routines)))
+             (list (nth 5 entry)))
+        (unless (or entry (eq class t))
+          (error "Nothing known about procedure %s"
+                 (idlwave-make-full-name class name)))
+        (setq list (idlwave-fix-keywords name 'pro class list))
+        (unless list (error (format "No keywords available for procedure %s"
+                                    (idlwave-make-full-name class name))))
+        (idlwave-complete-in-buffer
+         'keyword 'keyword list nil
+         (format "Select keyword for procedure %s%s"
+                 (idlwave-make-full-name class name)
+                 (if (member '("_EXTRA") list) " (note _EXTRA)" ""))
+         isa
+         'idlwave-attach-keyword-classes)))
+
+     ((eq what 'function-keyword)
+      ;; Complete a function keyword
+      (let* ((where (nth 3 where-list))
+             (name  (car where))
+             (method-selector name)
+             (type-selector 'fun)
+             (class (idlwave-determine-class where 'fun))
+             (class-selector class)
+             (isa (format "function%s-keyword" (if class "-method" "")))
+             (entry (idlwave-rinfo-assq
+                     name 'fun class (idlwave-routines)))
+             (list (nth 5 entry)))
+        (unless (or entry (eq class t))
+          (error "Nothing known about function %s"
+                 (idlwave-make-full-name class name)))
+        (setq list (idlwave-fix-keywords name 'fun class list))
+        (unless list (error (format "No keywords available for function %s"
+                                    (idlwave-make-full-name class name))))
+        (idlwave-complete-in-buffer
+         'keyword 'keyword list nil
+         (format "Select keyword for function %s%s"
+                 (idlwave-make-full-name class name)
+                 (if (member '("_EXTRA") list) " (note _EXTRA)" ""))
+         isa
+         'idlwave-attach-keyword-classes)))
+                 
+     (t (error "This should not happen (idlwave-complete)")))))
+
+(defun idlwave-make-force-complete-where-list (what &optional module class)
+  ;; Return an artificial WHERE specification to force the completion
+  ;; routine to complete a specific item independent of context.
+  ;; WHAT is the prefix arg of `idlwave-complete', see there for details.
+  ;; MODULE and CLASS can be used to specify the routine name and class.
+  ;; The class name will also be found in MODULE if that is like "class::mod".
+  (let* ((what-list '(("procedure") ("procedure-keyword")
+                      ("function") ("function-keyword")
+                      ("procedure-method") ("procedure-method-keyword")
+                      ("function-method") ("function-method-keyword")
+                      ("class")))
+         (module (idlwave-sintern-routine-or-method module class))
+         (class (idlwave-sintern-class class))
+         (what (cond 
+                ((equal what 0)
+                 (setq what
+                       (intern (completing-read 
+                                "Complete what? " what-list nil t))))
+                ((integerp what)
+                 (setq what (intern (car (nth (1- what) what-list)))))
+                ((and what
+                      (symbolp what)
+                      (assoc (symbol-name what) what-list))
+                 what)
+                (t (error "Illegal WHAT"))))
+         (nil-list '(nil nil nil nil))
+         (class-list (list nil nil (or class t) nil)))
+
+    (cond
+
+     ((eq what 'procedure)
+      (list nil-list nil-list 'procedure nil-list nil))
+
+     ((eq what 'procedure-keyword)
+      (let* ((class-selector nil)
+             (type-selector 'pro)
+             (pro (or module
+                      (idlwave-completing-read 
+                       "Procedure: " (idlwave-routines) 'idlwave-selector))))
+        (setq pro (idlwave-sintern-routine pro))
+        (list nil-list nil-list 'procedure-keyword
+              (list pro nil nil nil) nil)))
+
+     ((eq what 'function)
+      (list nil-list nil-list 'function nil-list nil))
+
+     ((eq what 'function-keyword)
+      (let* ((class-selector nil)
+             (type-selector 'fun)
+             (func (or module
+                       (idlwave-completing-read 
+                        "Function: " (idlwave-routines) 'idlwave-selector))))
+        (setq func (idlwave-sintern-routine func))
+        (list nil-list nil-list 'function-keyword
+              (list func nil nil nil) nil)))
+
+     ((eq what 'procedure-method)
+      (list nil-list nil-list 'procedure class-list nil))
+
+     ((eq what 'procedure-method-keyword)
+      (let* ((class (idlwave-determine-class class-list 'pro))
+             (class-selector class)
+             (type-selector 'pro)
+             (pro (or module
+                      (idlwave-completing-read
+                       (format "Procedure in %s class: " class-selector)
+                       (idlwave-routines) 'idlwave-selector))))
+        (setq pro (idlwave-sintern-method pro))
+        (list nil-list nil-list 'procedure-keyword
+              (list pro nil class nil) nil)))
+
+     ((eq what 'function-method)
+      (list nil-list nil-list 'function class-list nil))
+
+     ((eq what 'function-method-keyword)
+      (let* ((class (idlwave-determine-class class-list 'fun))
+             (class-selector class)
+             (type-selector 'fun)
+             (func (or module
+                       (idlwave-completing-read
+                        (format "Function in %s class: " class-selector)
+                        (idlwave-routines) 'idlwave-selector))))
+        (setq func (idlwave-sintern-method func))
+        (list nil-list nil-list 'function-keyword
+              (list func nil class nil) nil)))
+
+     ((eq what 'class)
+      (list nil-list nil-list 'class nil-list nil))
+     
+     (t (error "Illegal value for WHAT")))))
+
+(defun idlwave-completing-read (&rest args)
+  ;; Completing read, case insensitive
+  (let ((old-value (default-value 'completion-ignore-case)))
+    (unwind-protect
+        (progn
+          (setq-default completion-ignore-case t)
+          (apply 'completing-read args))
+      (setq-default completion-ignore-case old-value))))
+
+(defun idlwave-make-full-name (class name)
+  ;; Make a fully qualified module name including the class name
+  (concat (if class (format "%s::" class) "") name))
+
+(defun idlwave-rinfo-assq (name type class list)
+  ;; Works like assq, but also checks type and class
+  (catch 'exit
+    (let (match)
+      (while (setq match (assq name list))
+        (and (or (eq type t)
+                 (eq (nth 1 match) type))
+             (eq (nth 2 match) class)
+             (throw 'exit match))
+        (setq list (cdr (memq match list)))))))
+
+(defun idlwave-all-assq (key list)
+  "Return a list of all associations of Key in LIST."
+  (let (rtn elt)
+    (while (setq elt (assq key list))
+      (push elt rtn)
+      (setq list (cdr (memq elt list))))
+    (nreverse rtn)))
+
+(defun idlwave-all-method-classes (method &optional type)
+  "Return all classes which have a method METHOD.  TYPE is 'fun or 'pro.
+When TYPE is not specified, both procedures and functions will be considered."
+  (if (null method)
+      (mapcar 'car idlwave-class-alist)
+    (let (rtn)
+      (mapcar (lambda (x)
+                (and (nth 2 x)
+                     (or (not type)
+                         (eq type (nth 1 x)))
+                     (push (nth 2 x) rtn)))
+              (idlwave-all-assq method (idlwave-routines)))
+      (idlwave-uniquify rtn))))
+
+(defun idlwave-all-method-keyword-classes (method keyword &optional type)
+  "Return all classes which have a method METHOD with keyword KEYWORD.
+TYPE is 'fun or 'pro.
+When TYPE is not specified, both procedures and functions will be considered."
+  (if (or (null method)
+          (null keyword))
+      nil
+    (let (rtn)
+      (mapcar (lambda (x)
+                (and (nth 2 x)
+                     (or (not type)
+                         (eq type (nth 1 x)))
+                     (assoc keyword (nth 5 x))
+                     (push (nth 2 x) rtn)))
+              (idlwave-all-assq method (idlwave-routines)))
+      (idlwave-uniquify rtn))))
+
+(defun idlwave-determine-class (info type)
+  ;; Determine the class of a routine call.  INFO is the structure returned
+  ;; `idlwave-what-function' or `idlwave-what-procedure'.
+  ;; The third element in this structure is the class.  When nil, we return nil.
+  ;; When t, try to get the class from text properties at the arrow,
+  ;; otherwise prompt the user for a class name.  Also stores the selected
+  ;; class as a text property at the arrow.
+  ;; TYPE is 'fun or 'pro.
+  (let* ((class (nth 2 info))
+         (apos (nth 3 info))
+         (nassoc (assoc (if (stringp (car info))
+                            (upcase (car info))
+                          (car info))
+                        idlwave-query-class))
+         (dassoc (assq (if (car info) 'keyword-default 'method-default)
+                       idlwave-query-class))
+         (query (cond (nassoc (cdr nassoc))
+                      (dassoc (cdr dassoc))
+                      (t t)))
+         (arrow (and apos (string= (buffer-substring apos (+ 2 apos)) "->")))
+         (force-query idlwave-force-class-query)
+         store class-alist)
+    (cond
+     ((null class) nil)
+     ((eq t class)
+      ;; There is an object which would like to know its class
+      (if (and arrow (get-text-property apos 'idlwave-class)
+               idlwave-store-inquired-class
+               (not force-query))
+          (setq class (get-text-property apos 'idlwave-class)
+                class (idlwave-sintern-class class)))
+      (when (and (eq class t)
+                 (or force-query query))
+        (setq class-alist 
+              (mapcar 'list (idlwave-all-method-classes (car info) type)))
+        (setq class
+              (idlwave-sintern-class
+               (cond
+                ((and (= (length class-alist) 0) (not force-query))
+                 (error "No classes available with method %s" (car info)))
+                ((and (= (length class-alist) 1) (not force-query))
+                 (car (car class-alist)))
+                (t 
+                 (setq store idlwave-store-inquired-class)
+                 (idlwave-completing-read 
+                  (format "Class%s: " (if (stringp (car info))
+                                          (format " for %s method %s"
+                                                  type (car info))
+                                        ""))
+                  class-alist nil nil nil 'idlwave-class-history))))))
+      (when (and class (not (eq t class)))
+        ;; We have a real class here
+        (when (and store arrow)
+          (put-text-property apos (+ apos 2) 'idlwave-class class)
+          (put-text-property apos (+ apos 2) 'face idlwave-class-arrow-face))
+        (setf (nth 2 info) class))
+      ;; Return the class
+      class)
+     ;; Default as fallback
+     (t class))))
+
+(defvar type-selector)
+(defvar class-selector)
+(defvar method-selector)
+(defun idlwave-selector (a)
+  (and (eq (nth 1 a) type-selector)
+       (or (and (nth 2 a) (eq class-selector t))
+           (eq (nth 2 a) class-selector))))
+
+(defun idlwave-where ()
+  "Find out where we are.
+The return value is a list with the following stuff:
+(PRO-LIST FUNC-LIST COMPLETE-WHAT CW-LIST LAST-CHAR)
+
+PRO-LIST       (PRO POINT CLASS ARROW)
+FUNC-LIST      (FUNC POINT CLASS ARROW)
+COMPLETE-WHAT  a symbol indicating what kind of completion makes sense here
+CW-LIST        Like PRO-LIST, for what can be copmpleted here.
+LAST-CHAR      last relevant character before point (non-white non-comment,
+               not part of current identifier or leading slash).
+
+In the lists, we have these meanings:
+PRO:    Procedure name
+FUNC:   Function name
+POINT:  Where is this
+CLASS:  What class has the routine (nil=no, t=is method, but class unknown)
+ARROW:  Where is the arrow?"
+  (idlwave-routines)
+  (let* ((bos (save-excursion (idlwave-beginning-of-statement) (point)))
+         (func-entry (idlwave-what-function bos))
+         (func (car func-entry))
+         (func-class (nth 1 func-entry))
+         (func-arrow (nth 2 func-entry))
+         (func-point (or (nth 3 func-entry) 0))
+         (func-level (or (nth 4 func-entry) 0))
+         (pro-entry (idlwave-what-procedure bos))
+         (pro (car pro-entry))
+         (pro-class (nth 1 pro-entry))
+         (pro-arrow (nth 2 pro-entry))
+         (pro-point (or (nth 3 pro-entry) 0))
+         (last-char (idlwave-last-valid-char))
+         (case-fold-search t)
+         cw cw-mod cw-arrow cw-class cw-point)
+    (if (< func-point pro-point) (setq func nil))
+    (cond
+     ((string-match 
+       "\\`[ \t]*\\([a-zA-Z][a-zA-Z0-9$_]*\\)?\\'" 
+       (buffer-substring (if (> pro-point 0) pro-point bos) (point)))
+      (setq cw 'procedure cw-class pro-class cw-point pro-point
+            cw-arrow pro-arrow))
+     ((string-match "\\`[ \t]*\\(pro\\|function\\)\\>"
+                    (buffer-substring bos (point)))
+      nil)
+     ((string-match "OBJ_NEW([ \t]*'\\([a-zA-Z][a-zA-Z0-9$_]*\\)?\\'"
+                    (buffer-substring bos (point)))
+      (setq cw 'class))                    
+     ((and func 
+           (> func-point pro-point)
+           (= func-level 1)
+           (memq last-char '(?\( ?,)))
+      (setq cw 'function-keyword cw-mod func cw-point func-point
+            cw-class func-class cw-arrow func-arrow))
+     ((and pro (eq last-char ?,))
+      (setq cw 'procedure-keyword cw-mod pro cw-point pro-point
+            cw-class pro-class cw-arrow pro-arrow))
+;     ((member last-char '(?\' ?\) ?\] ?!))
+;      ;; after these chars, a function makes no sense
+;      ;; FIXME: I am sure there can be more in this list
+;      ;; FIXME: Do we want to do this at all?
+;      nil)
+     ;; Everywhere else we try a function.
+     (t
+      (setq cw 'function)
+      (save-excursion
+        (if (re-search-backward "->[ \t]*\\(\\([$a-zA-Z0-9_]+\\)::\\)?[$a-zA-Z0-9_]*\\=" bos t)
+            (setq cw-arrow (match-beginning 0)
+                  cw-class (if (match-end 2)
+                               (idlwave-sintern-class (match-string 2))
+                              t))))))
+    (list (list pro pro-point pro-class pro-arrow)
+          (list func func-point func-class func-arrow)
+          cw
+          (list cw-mod cw-point cw-class cw-arrow)
+          last-char)))
+
+(defun idlwave-this-word (&optional class)
+  ;; Grab the word around point.  CLASS is for the `skip-chars=...' functions
+  (setq class (or class "a-zA-Z0-9$_"))
+  (save-excursion
+    (buffer-substring-no-properties
+     (progn (skip-chars-backward class) (point))
+     (progn (skip-chars-forward  class) (point)))))
+
+(defvar idlwave-find-symbol-syntax-table)
+(defun idlwave-what-function (&optional bound)
+  ;; Find out if point is within the argument list of a function.
+  ;; The return value is ("function-name" (point) level).
+  ;; Level is 1 on the to level parenthesis, higher further down.
+
+  ;; If the optional BOUND is an integer, bound backwards directed
+  ;;    searches to this point.
+
+  (catch 'exit
+    (let (pos 
+          func-point
+          (old-syntax (syntax-table))
+          (cnt 0)
+          func arrow-start class)
+      (unwind-protect
+          (save-restriction
+            (save-excursion
+              (set-syntax-table idlwave-find-symbol-syntax-table)
+              (narrow-to-region (max 1 (or bound 0)) (point-max))
+              ;; move back out of the current parenthesis
+              (while (condition-case nil
+                         (progn (up-list -1) t)
+                       (error nil))
+                (setq pos (point))
+                (incf cnt)
+                (when (and (= (following-char) ?\()
+                           (re-search-backward 
+                            "\\(::\\|\\<\\)\\([a-zA-Z][a-zA-Z0-9$_]*\\)\\="
+                                               bound t))
+                  (setq func (match-string 2)
+                        func-point (goto-char (match-beginning 2))
+                        pos func-point)
+                  (if (re-search-backward 
+                       "->[ \t]*\\(\\([a-zA-Z][a-zA-Z0-9$_]*\\)::\\)?\\=" bound t)
+                      (setq arrow-start (match-beginning 0)
+                            class (or (match-string 2) t)))
+                  (throw 
+                   'exit 
+                   (list
+                    (idlwave-sintern-routine-or-method func class)
+                    (idlwave-sintern-class class)
+                    arrow-start func-point cnt)))
+                (goto-char pos))
+              (throw 'exit nil)))
+        (set-syntax-table old-syntax)))))
+
+(defun idlwave-what-procedure (&optional bound)
+  ;; Find out if point is within the argument list of a procedure.
+  ;; The return value is ("procedure-name" class arrow-pos (point)).
+
+  ;; If the optional BOUND is an integer, bound backwards directed
+  ;;    searches to this point.
+  (let ((pos (point)) pro-point
+        pro class arrow-start string)
+    (save-excursion 
+      (idlwave-beginning-of-statement)
+      (setq string (buffer-substring (point) pos))
+      (if (string-match 
+           "\\`[ \t]*\\([a-zA-Z][a-zA-Z0-9$_]*\\)[ \t]*\\(,\\|\\'\\)" string)
+          (setq pro (match-string 1 string)
+                pro-point (+ (point) (match-beginning 1)))
+        (if (and (idlwave-skip-object)
+                 (setq string (buffer-substring (point) pos))
+                 (string-match 
+                  "\\`[ \t]*\\(->\\)[ \t]*\\(\\([a-zA-Z][a-zA-Z0-9$_]*\\)::\\)?\\([a-zA-Z][a-zA-Z0-9$_]*\\)?[ \t]*\\(,\\|\\'\\)" string))
+            (setq pro (if (match-beginning 4)
+                          (match-string 4 string))
+                  pro-point (if (match-beginning 4)
+                                (+ (point) (match-beginning 4))
+                        pos)
+                  arrow-start (+ (point) (match-beginning 1))
+                  class (or (match-string 3 string) t)))))
+    (list (idlwave-sintern-routine-or-method pro class)
+          (idlwave-sintern-class class)
+          arrow-start
+          pro-point)))
+
+(defun idlwave-skip-object ()
+  ;; If there is an object at point, move over it and return t.
+  (let ((pos (point)))
+    (if (catch 'exit
+          (save-excursion
+            (skip-chars-forward "       ")  ; white space
+            (skip-chars-forward "*")        ; de-reference
+            (cond
+             ((looking-at idlwave-identifier)
+              (goto-char (match-end 0)))
+             ((eq (following-char) ?\()
+              nil)
+             (t (throw 'exit nil)))
+            (catch 'endwhile
+              (while t
+                (cond ((eq (following-char) ?.)
+                       (forward-char 1)
+                       (if (not (looking-at idlwave-identifier))
+                           (throw 'exit nil))
+                       (goto-char (match-end 0)))
+                      ((memq (following-char) '(?\( ?\[))
+                       (condition-case nil
+                           (forward-list 1)
+                         (error (throw 'exit nil))))
+                      (t (throw 'endwhile t)))))
+            (if (looking-at "[ \t]*->")
+                (throw 'exit (setq pos (match-beginning 0)))
+              (throw 'exit nil))))
+        (goto-char pos)
+      nil)))
+  
+
+(defun idlwave-last-valid-char ()
+  "Return the last character before point which is not white or a comment
+and also not part of the current identifier.  Since we do this in
+order to identify places where keywords are, we consider the initial
+`/' of a keyword as part of the identifier.
+This function is not general, can only be used for completion stuff."
+  (catch 'exit
+    (save-excursion
+      ;; skip the current identifier
+      (skip-chars-backward "a-zA-Z0-9_$")
+      ;; also skip a leading slash which might be belong to the keyword
+      (if (eq (preceding-char) ?/)
+          (backward-char 1))
+      ;; FIXME: does not check if this is a valid identifier
+      (while t
+        (skip-chars-backward " \t")
+        (cond
+         ((memq (preceding-char) '(?\; ?\$)) (throw 'exit nil))
+         ((eq (preceding-char) ?\n)
+          (beginning-of-line 0)
+          (if (looking-at "\\([^;]\\)*\\$[ \t]*\\(;.*\\)?\n")
+              ;; continuation line
+              (goto-char (match-end 1))
+            (throw 'exit nil)))
+         (t (throw 'exit (preceding-char))))))))
+
+(defvar idlwave-complete-after-success-form nil
+  "A form to evaluate after successful completion.")
+(defvar idlwave-complete-after-success-form-force nil
+  "A form to evaluate after completion selection in *Completions* buffer.")
+(defconst idlwave-completion-mark (make-marker)
+  "A mark pointing to the beginning of the completion string.")
+
+(defun idlwave-complete-in-buffer (type stype list selector prompt isa
+                                        &optional prepare-display-function)
+  "Perform TYPE completion of word before point against LIST.
+SELECTOR is the PREDICATE argument for the completion function.
+Show PROMPT in echo area.  TYPE is one of 'function, 'procedure or 'keyword."
+  (let* ((completion-ignore-case t)
+         beg (end (point)) slash part spart completion all-completions
+         dpart dcompletion)
+
+    (unless list
+      (error (concat prompt ": No completions available")))
+
+    ;; What is already in the buffer?
+    (save-excursion
+      (skip-chars-backward "a-zA-Z0-9_$")
+      (setq slash (eq (preceding-char) ?/)
+            beg (point)
+            idlwave-complete-after-success-form
+            (list 'idlwave-after-successful-completion
+                  (list 'quote type) slash beg)
+            idlwave-complete-after-success-form-force
+            (list 'idlwave-after-successful-completion
+                  (list 'quote type) slash (list 'quote 'force))))
+
+    ;; Try a completion
+    (setq part (buffer-substring beg end)
+          dpart (downcase part)
+          spart (idlwave-sintern stype part)
+          completion (try-completion part list selector)
+          dcompletion (if (stringp completion) (downcase completion)))
+    (cond
+     ((null completion)
+      ;; nothing available.
+      (error "Can't find %s completion for \"%s\"" isa part))
+     ((and (not (equal dpart dcompletion))
+           (not (eq t completion)))
+      ;; We can add something
+      (delete-region beg end)
+      (if (and (string= part dpart)
+               (or (not (string= part ""))
+                   idlwave-complete-empty-string-as-lower-case)
+               (not idlwave-completion-force-default-case))
+          (insert dcompletion)
+        (insert completion))
+      (if (eq t (try-completion completion list selector))
+          ;; Now this is a unique match
+          (idlwave-after-successful-completion type slash beg))
+      t)
+     ((or (eq completion t)
+          (and (equal dpart dcompletion)
+               (= 1 (length (setq all-completions
+                                  (idlwave-uniquify
+                                   (all-completions part list selector)))))))
+      ;; This is already complete
+      (idlwave-after-successful-completion type slash beg)
+      (message "%s is already the complete %s" part isa)
+      nil)
+     (t
+      ;; We cannot add something - offer a list.
+      (message "Making completion list...")
+      (let* ((list all-completions)
+             (complete (memq spart all-completions))
+             (completion-highlight-first-word-only t) ; XEmacs
+             (completion-fixup-function               ; Emacs
+              (lambda () (and (eq (preceding-char) ?>)
+                              (re-search-backward " <" beg t)))))
+        (setq list (sort list (lambda (a b)
+                                (string< (downcase a) (downcase b)))))
+        (if prepare-display-function
+            (setq list (funcall prepare-display-function list)))
+        (if (and (string= part dpart)
+                 (or (not (string= part ""))
+                     idlwave-complete-empty-string-as-lower-case)
+                 (not idlwave-completion-force-default-case))
+            (setq list (mapcar (lambda (x)
+                                 (if (listp x) 
+                                     (setcar x (downcase (car x)))
+                                   (setq x (downcase x)))
+                                 x)
+                               list)))
+        (idlwave-display-completion-list list prompt beg complete))
+      t))))
+
+(defun idlwave-complete-class ()
+  "Complete a class at point."
+  (interactive)
+  ;; Call `idlwave-routines' to make sure the class list will be available
+  (idlwave-routines)
+  ;; Now do the completion
+  (idlwave-complete-in-buffer 'class 'class idlwave-class-alist nil 
+                              "Select a class" "class"))
+
+
+(defun idlwave-attach-classes (list is-kwd show-classes)
+  ;; attach the proper class list to a LIST of completion items.
+  ;; IS-KWD, when non-nil, shows its keywords - otherwise its methods
+  ;; SHOW-CLASSES is the value of `idlwave-completion-show-classes'.
+  (catch 'exit
+    (if (or (null show-classes)         ; don't wnat to see classes
+            (null class-selector)       ; not a method call
+            (stringp class-selector))   ; the class is already known
+        ;; In these cases, we do not have to do anything
+        (throw 'exit list))
+    
+    ;; The property and dots stuff currently only make sense with XEmacs
+    ;; because Emacs drops text properties when filling the *Completions*
+    ;; buffer.
+    (let* ((do-prop (and (featurep 'xemacs) (>= show-classes 0)))
+           (do-buf (not (= show-classes 0)))
+           (do-dots (featurep 'xemacs))
+           (max (abs show-classes))
+           (lmax (if do-dots (apply 'max (mapcar 'length list))))
+          classes nclasses class-info space)
+      (mapcar 
+       (lambda (x)
+         ;; get the classes
+         (setq classes
+               (if is-kwd 
+                   (idlwave-all-method-keyword-classes
+                    method-selector x type-selector)
+                 (idlwave-all-method-classes x type-selector)))
+         (setq nclasses (length classes))
+         ;; Make the separator between item and class-info
+         (if do-dots
+             (setq space (concat " " (make-string (- lmax (length x)) ?.)))
+           (setq space " "))
+         (if  do-buf
+             ;; We do want info in the buffer
+             (if (<= nclasses max)
+                 (setq class-info (concat
+                                   space
+                                   "<" (mapconcat 'identity classes ",") ">"))
+               (setq class-info (format "%s<%d classes>" space nclasses)))
+           (setq class-info nil))
+         (when do-prop
+           ;; We do want properties
+           (setq x (copy-sequence x))
+           (put-text-property 0 (length x)
+                              'help-echo (mapconcat 'identity classes " ")
+                              x))
+         (if class-info
+             (list x class-info)
+           x))
+       list))))
+
+(defun idlwave-attach-method-classes (list)
+  ;; Call idlwave-attach-classes with method parameters
+  (idlwave-attach-classes list nil idlwave-completion-show-classes))
+(defun idlwave-attach-keyword-classes (list)
+  ;; Call idlwave-attach-classes with keyword parameters
+  (idlwave-attach-classes list t idlwave-completion-show-classes))
+
+;;----------------------------------------------------------------------
+;;----------------------------------------------------------------------
+;;----------------------------------------------------------------------
+;;----------------------------------------------------------------------
+;;----------------------------------------------------------------------
+
+(defun idlwave-scroll-completions (&optional message)
+  "Scroll the completion window on this frame."
+  (let ((cwin (get-buffer-window "*Completions*" 'visible))
+        (win (selected-window)))
+    (unwind-protect
+        (progn
+          (select-window cwin)
+          (condition-case nil
+              (scroll-up)
+            (error (if (and (listp last-command)
+                            (nth 2 last-command))
+                       (progn
+                         (select-window win)
+                         (eval idlwave-complete-after-success-form))
+                     (set-window-start cwin (point-min)))))
+          (and message (message message)))
+      (select-window win))))
+
+(defun idlwave-display-completion-list (list &optional message beg complete)
+  "Display the completions in LIST in the completions buffer and echo MESSAGE."
+  (unless (and (get-buffer-window "*Completions*")
+               (idlwave-local-value 'idlwave-completion-p "*Completions*"))
+    (move-marker idlwave-completion-mark beg)
+    (setq idlwave-before-completion-wconf (current-window-configuration)))
+
+  (if (featurep 'xemacs)
+      (idlwave-display-completion-list-xemacs list)
+    (idlwave-display-completion-list-emacs list))
+
+  ;; Store a special value in `this-command'.  When `idlwave-complete'
+  ;; finds this in `last-command', it will scroll the *Completions* buffer.
+  (setq this-command (list 'idlwave-display-completion-list message complete))
+
+  ;; Mark the completions buffer as created by cib
+  (idlwave-set-local 'idlwave-completion-p t "*Completions*")
+
+  ;; Fontify the classes
+  (if (and idlwave-completion-fontify-classes
+           (consp (car list)))
+      (idlwave-completion-fontify-classes))
+
+  ;; Display the message
+  (message (or message "Making completion list...done")))
+
+(defun idlwave-choose (function &rest args)
+  "Call FUNCTION as a completion chooser and pass ARGS to it."
+  (let ((completion-ignore-case t))         ; install correct value
+    (apply function args))
+  (eval idlwave-complete-after-success-form-force))
+
+(defun idlwave-restore-wconf-after-completion ()
+  "Restore the old (before completion) window configuration."
+  (and idlwave-completion-restore-window-configuration
+       idlwave-before-completion-wconf
+       (set-window-configuration idlwave-before-completion-wconf)))
+
+(defun idlwave-set-local (var value &optional buffer)
+  "Set the buffer-local value of VAR in BUFFER to VALUE."
+  (save-excursion
+    (set-buffer (or buffer (current-buffer)))
+    (set (make-local-variable var) value)))
+
+(defun idlwave-local-value (var &optional buffer)
+  "Return the value of VAR in BUFFER, but only if VAR is local to BUFFER."
+  (save-excursion
+    (set-buffer (or buffer (current-buffer)))
+    (and (local-variable-p var (current-buffer))
+         (symbol-value var))))
+
+;; In XEmacs, we can use :activate-callback directly
+
+(defun idlwave-display-completion-list-xemacs (list)
+  (with-output-to-temp-buffer "*Completions*"
+    (display-completion-list list :activate-callback 
+                             'idlwave-default-choose-completion)))
+
+(defun idlwave-default-choose-completion (&rest args)
+  "Execute `default-choose-completion' and then restore the win-conf."
+  (apply 'idlwave-choose 'default-choose-completion args))
+
+;; In Emacs we have to replace the keymap in the *Completions* buffer
+;; in order to install our wrappers.
+
+(defvar idlwave-completion-map nil
+  "Keymap for completion-list-mode with idlwave-complete.")
+
+(defun idlwave-display-completion-list-emacs (list)
+  "Display completion list and install the choose wrappers."
+  (with-output-to-temp-buffer "*Completions*"
+    (display-completion-list list))
+  (save-excursion
+    (set-buffer "*Completions*")
+    (use-local-map
+     (or idlwave-completion-map
+         (setq idlwave-completion-map
+               (idlwave-make-modified-completion-map (current-local-map)))))))
+  
+(defun idlwave-make-modified-completion-map (old-map)
+  "Replace `choose-completion' and `mouse-choose-completion' in OLD-MAP."
+  (let ((new-map (copy-keymap old-map)))
+    (substitute-key-definition 
+     'choose-completion 'idlwave-choose-completion new-map)
+    (substitute-key-definition
+     'mouse-choose-completion 'idlwave-mouse-choose-completion new-map)
+    new-map))
+
+(defun idlwave-choose-completion (&rest args)
+  "Choose the completion that point is in or next to."
+  (interactive)
+  (apply 'idlwave-choose 'choose-completion args))
+
+(defun idlwave-mouse-choose-completion (&rest args)
+  "Click on an alternative in the `*Completions*' buffer to choose it."
+  (interactive "e")
+  (apply 'idlwave-choose 'mouse-choose-completion args))
+
+;;----------------------------------------------------------------------
+;;----------------------------------------------------------------------
+
+(defun idlwave-completion-fontify-classes ()
+  "Goto the *Completions* buffer and fontify the class info."
+  (when (featurep 'font-lock)
+    (save-excursion
+      (set-buffer "*Completions*")
+      (save-excursion
+        (goto-char (point-min))
+        (while (re-search-forward "\\.*<[^>]+>" nil t)
+          (put-text-property (match-beginning 0) (match-end 0)
+                             'face 'font-lock-string-face))))))
+
+(defun idlwave-uniquify (list)
+  (let (nlist)
+    (loop for x in list do
+      (add-to-list 'nlist x))
+    nlist))
+
+(defun idlwave-after-successful-completion (type slash &optional verify)
+  "Add `=' or `(' after successful completion of keyword and function.
+Restore the pre-completion window configuration if possible."
+  (cond
+   ((eq type 'procedure)
+    nil)
+   ((eq type 'function)
+    (cond
+     ((equal idlwave-function-completion-adds-paren nil) nil)
+     ((or (equal idlwave-function-completion-adds-paren t)
+          (equal idlwave-function-completion-adds-paren 1))
+      (insert "("))
+     ((equal idlwave-function-completion-adds-paren 2)
+      (insert "()")
+      (backward-char 1))
+     (t nil)))
+   ((eq type 'keyword)
+    (if (and idlwave-keyword-completion-adds-equal
+             (not slash))
+        (progn (insert "=") t)
+      nil)))
+
+  ;; Restore the pre-completion window configuration if this is safe.
+  
+  (if (or (eq verify 'force)                                    ; force 
+          (and 
+           (get-buffer-window "*Completions*")                  ; visible
+           (idlwave-local-value 'idlwave-completion-p 
+                                "*Completions*")                ; cib-buffer
+           (eq (marker-buffer idlwave-completion-mark)
+               (current-buffer))                                ; buffer OK
+           (equal (marker-position idlwave-completion-mark)
+                  verify)))                                     ; pos OK
+      (idlwave-restore-wconf-after-completion))
+  (move-marker idlwave-completion-mark nil)
+  (setq idlwave-before-completion-wconf nil))
+
+(defun idlwave-routine-info-from-idlhelp (&optional arg)
+  "Make IDLHELP display the online documentation about the routine at point.
+Sends the command `? MODULE' to the IDLWAVE-Shell.  Shell must be running,
+it does not autostart for this task."
+  (interactive "P")
+  (idlwave-routine-info arg 'external))
+
+(defun idlwave-routine-info (&optional arg external)
+  "Display a routines calling sequence and list of keywords.
+When point is on the name a function or procedure, or in the argument
+list of a function or procedure, this command displays a help buffer
+with the information.  When called with prefix arg, enforce class
+query.
+
+When point is on an object operator `->', display the class stored in
+this arrow, if any (see `idlwave-store-inquired-class').  With a
+prefix arg, the class property is cleared out."
+
+  (interactive "P")
+  (idlwave-routines)
+  (if (string-match "->" (buffer-substring
+                          (max (point-min) (1- (point)))
+                          (min (+ 2 (point)) (point-max))))
+      ;; Cursor is on an arrow
+      (if (get-text-property (point) 'idlwave-class)
+          ;; arrow has class property
+          (if arg
+              ;; Remove property
+              (save-excursion
+                (backward-char 1)
+                (when (looking-at ".?\\(->\\)")
+                  (remove-text-properties (match-beginning 1) (match-end 1)
+                                          '(idlwave-class nil face nil))
+                  (message "Class property removed from arrow")))
+            ;; Echo class property
+            (message "Arrow has text property identifying object to be class %s"
+                     (get-text-property (point) 'idlwave-class)))
+        ;; No property found
+        (message "Arrow has no class text property"))
+
+    ;; Not on an arrow...
+    (let* ((idlwave-query-class nil)
+           (idlwave-force-class-query (equal arg '(4)))
+           (module (idlwave-what-module)))
+      (cond ((car module)
+             (if external
+                 (apply 'idlwave-search-online-help module)
+               (apply 'idlwave-display-calling-sequence module)))
+            (t
+             (error "Don't know which calling sequence to show."))))))
+
+(defun idlwave-search-online-help (name &optional type class olh)
+  "Tell IDL to lookup CLASS::NAME with type TYPE in the online help.
+If TYPE and CLASS are both nil, just look up NAME in the default help file."
+  ;; If only the IDLHELP application was better designed, so that
+  ;; we could make it open the right thing right away.  As things are,
+  ;; we need to pipe the stuff through the help search engine, and we
+  ;; cannot enter a space.
+  (let* (extra book full string cmd)
+
+    ;; Try to find a clue for the right help book
+    (if (and type (not olh))
+        (setq olh (or (nth 6 (idlwave-rinfo-assq
+                              name type class idlwave-builtin-routines))
+                      (nth 6 (idlwave-rinfo-assq 
+                              name type class idlwave-routines)))))
+
+    ;; Sometimes the book is given as a symbol - make it a string
+    (if (and olh (symbolp olh)) (setq olh (symbol-name olh)))
+    (setq book (or olh "idl"))   ; We need a default
+    ;; Add the FULL_PATH keyword if appropriate
+    (if (and (file-name-absolute-p book)
+             (file-exists-p book))
+        (setq full ",/FULL_PATH")
+      (setq full ""))
+
+    ;; We would like to add "Method" or so, but stupid IDL online help
+    ;; command treats a space as a separator and interprets the next thing as
+    ;; the book name.
+    ;; (setq extra (cond ((eq type 'kwd) " keyword")
+    ;;                (class          " method")
+    ;;                ((eq type 'pro) " procedure")
+    ;;                ((eq type 'fun) " function")
+    ;;                (t "")))
+    (setq extra "")
+
+    ;; Methods are subitems of classes, the separator is a single `:'
+    (if (and name class (not (eq type 'kwd)))
+        (setq name (concat class ":" name)))
+    ;; FIXME:  We used to use book, but in idl5.3, all help is in idl.hlp
+    (setq string (concat name extra)
+          cmd (format "ONLINE_HELP,'%s',BOOK='%s'%s" string "idl" full))
+;         cmd (format "ONLINE_HELP,'%s',BOOK='%s'%s" string book full))
+    (message "Sending to IDL: %s" cmd) (sit-for 2)
+    (idlwave-shell-send-command cmd)))
+
+(defun idlwave-resolve (&optional arg)
+  "Call RESOLVE on the module name at point.
+Like `idlwave-routine-info', this looks for a routine call at point.
+After confirmation in the minibuffer, it will use the shell to issue
+a RESOLVE call for this routine, to attempt to make it defined and its
+routine info available for IDLWAVE.  If the routine is a method call,
+both `class__method' and `class__define' will be tried.
+With ARG, enforce query for the class of object methods."
+  (interactive "P")
+  (let* ((idlwave-query-class nil)
+         (idlwave-force-class-query (equal arg '(4)))
+         (module (idlwave-what-module))
+         (name (idlwave-make-full-name (nth 2 module) (car module)))
+         (type (if (eq (nth 1 module) 'pro) "pro" "function"))
+         (resolve (read-string "Resolve: " (format "%s %s" type name)))
+         (kwd "")
+         class)
+    (if (string-match "\\(pro\\|function\\)[ \t]+\\(\\(.*\\)::\\)?\\(.*\\)"
+                      resolve)
+        (setq type (match-string 1 resolve)
+              class (if (match-beginning 2) 
+                        (match-string 3 resolve)
+                      nil)
+              name (match-string 4 resolve)))
+    (if (string= (downcase type) "function")
+        (setq kwd ",/is_function"))
+
+    (cond
+     ((null class)
+      (idlwave-shell-send-command 
+       (format "resolve_routine,'%s'%s" (downcase name) kwd)
+       'idlwave-update-routine-info
+       nil t))
+     (t
+      (idlwave-shell-send-command 
+       (format "resolve_routine,'%s__define'%s" (downcase class) kwd)
+       (list 'idlwave-shell-send-command 
+             (format "resolve_routine,'%s__%s'%s" 
+                     (downcase class) (downcase name) kwd)
+             '(idlwave-update-routine-info)
+             nil t))))))
+
+(defun idlwave-find-module (&optional arg)
+  "Find the source code of an IDL module.
+Works for modules for which IDLWAVE has routine info available.
+The function offers as default the module name `idlwave-routine-info' would
+use.  With ARG force class query for object methods."
+  (interactive "P")
+  (let* ((idlwave-query-class nil)
+         (idlwave-force-class-query (equal arg '(4)))
+         (module (idlwave-what-module))
+         (default (concat (idlwave-make-full-name (nth 2 module) (car module))
+                          (if (eq (nth 1 module) 'pro) "<p>" "<f>")))
+         (list 
+          (delq nil
+                (mapcar (lambda (x) 
+                          (if (eq 'system (car-safe (nth 3 x)))
+                              ;; Take out system routines with no source.
+                              nil
+                            (cons
+                             (concat (idlwave-make-full-name (nth 2 x) (car x))
+                                     (if (eq (nth 1 x) 'pro) "<p>" "<f>"))
+                             (cdr x))))
+                        (idlwave-routines))))
+         (name (idlwave-completing-read
+                (format "Module (Default %s): " 
+                        (if default default "none"))
+                list))
+         type class)
+    (if (string-match "\\`\\s-*\\'" name)
+        ;; Nothing, use the default.
+        (setq name default))
+    (if (string-match "<[fp]>" name)
+        (setq type (substring name -2 -1)
+              name (substring name 0 -3)))
+    (if (string-match "\\(.*\\)::\\(.*\\)" name)
+        (setq class (match-string 1 name)
+              name (match-string 2 name)))
+    (setq name (idlwave-sintern-routine-or-method name class)
+          class (idlwave-sintern-class class)
+          type (cond ((equal type "f") 'fun)
+                     ((equal type "p") 'pro)
+                     (t t)))
+    (idlwave-do-find-module name type class)))
+
+(defun idlwave-do-find-module (name type class)
+  (let ((name1 (idlwave-make-full-name class name))
+        source buf1 entry
+        (buf (current-buffer))
+        (pos (point)))
+    (setq entry (idlwave-rinfo-assq name type class (idlwave-routines))
+          source (nth 3 entry))
+    (cond
+     ((or (null name) (equal name ""))
+      (error "Abort"))
+     ((null entry)
+      (error "Nothing known about a module %s" name1))
+     ((eq (car source) 'system)
+      (error "Source code for system routine %s is not available." 
+             name1))
+     ((equal (cdr source) "")
+      (error "Source code for routine %s is not available."
+             name1))
+     ((memq (car source) '(buffer lib compiled))
+      (setq buf1 
+            (if (eq (car source) 'lib)
+                (idlwave-find-lib-file-noselet 
+                 (or (cdr source)
+                     (format "%s.pro" (downcase name))))
+              (idlwave-find-file-noselect (cdr source))))
+      (pop-to-buffer buf1)
+      (goto-char 1)
+      (let ((case-fold-search t))
+        (if (re-search-forward
+             (concat "^[ \t]*\\<"
+                     (cond ((equal type "f") "function")
+                           ((equal type "p") "pro")
+                           (t "\\(pro\\|function\\)"))
+                     "\\>[ \t]+" 
+                     (regexp-quote (downcase name1))
+                     "[^a-zA-Z0-9_$]")
+             nil t)
+            (goto-char (match-beginning 0))
+          (pop-to-buffer buf)
+          (goto-char pos)
+          (error "Could not find routine %s" name1)))))))
+
+(defun idlwave-what-module ()
+  "Return a default module for stuff near point.
+Used by `idlwave-routine-info' and `idlwave-find-module'."
+  (idlwave-routines)
+  (let* ((where (idlwave-where))
+         (cw (nth 2 where))
+         (pro (car (nth 0 where)))
+         (func (car (nth 1 where)))
+         (this-word (idlwave-this-word "a-zA-Z0-9$_"))
+         (next-char (save-excursion (skip-chars-forward "a-zA-Z0-9$_")
+                                    (following-char)))
+         )
+    (cond
+     ((and (eq cw 'procedure)
+           (not (equal this-word "")))
+      (setq this-word (idlwave-sintern-routine-or-method 
+                       this-word (nth 2 (nth 3 where))))
+      (list this-word 'pro
+            (idlwave-determine-class 
+             (cons this-word (cdr (nth 3 where)))
+             'pro)))
+     ((and (eq cw 'function) 
+           (not (equal this-word ""))
+           (eq next-char ?\())              ; exclude arrays, vars.
+      (setq this-word (idlwave-sintern-routine-or-method 
+                       this-word (nth 2 (nth 3 where))))
+      (list this-word 'fun
+            (idlwave-determine-class
+             (cons this-word (cdr (nth 3 where)))
+             'fun)))
+     (func
+      (list func 'fun (idlwave-determine-class (nth 1 where) 'fun)))
+     (pro
+      (list pro 'pro (idlwave-determine-class (nth 0 where) 'pro)))
+     (t nil))))
+
+(defun idlwave-fix-keywords (name type class keywords)
+  ;; This fixes the list of keywords.
+  (let ((case-fold-search t)
+        name1 type1)
+
+    ;; If this is the OBJ_NEW function, try to figure out the class and use
+    ;; the keywords from the corresponding INIT method.
+    (if (and (equal name "OBJ_NEW")
+             (eq major-mode 'idlwave-mode))
+        (let* ((bos (save-excursion (idlwave-beginning-of-statement) (point)))
+               (string (buffer-substring bos (point)))
+               (case-fold-search t)
+               class)
+          (and (string-match "obj_new([^'\"]*['\"]\\([a-zA-Z0-9_]+\\)"
+                             string)
+               (setq class (idlwave-sintern-class (match-string 1 string)))
+               (setq keywords 
+                     (append keywords 
+                             (nth 5 (idlwave-rinfo-assq
+                                     (idlwave-sintern-method "INIT")
+                                     'fun
+                                     class
+                                     (idlwave-routines))))))))
+
+    ;; If the class is `t', combine all keywords of all methods NAME
+    (when (eq class t)
+      (loop for x in (idlwave-routines) do
+        (and (nth 2 x)                         ; non-nil class
+             (or (and (eq (nth 1 x) type)      ; default type
+                      (eq (car x) name))       ; default name
+                 (and (eq (nth 1 x) type1)     ; backup type
+                      (eq (car x) name1)))     ; backup name
+             (mapcar (lambda (k) (add-to-list 'keywords k))
+                     (nth 5 x))))
+      (setq keywords (idlwave-uniquify keywords)))
+    ;; Return the final list
+    keywords))
+
+(defvar idlwave-rinfo-map (make-sparse-keymap))
+(define-key idlwave-rinfo-map 
+  (if (featurep 'xemacs) [button2] [mouse-2])
+  'idlwave-mouse-active-rinfo)
+(define-key idlwave-rinfo-map 
+  (if (featurep 'xemacs) [button3] [mouse-3])
+  'idlwave-mouse-active-rinfo-right)
+(defvar idlwave-popup-source)
+
+(defun idlwave-display-calling-sequence (name type class)
+  ;; Display the calling sequence of module NAME, type TYPE in class CLASS.
+  (let* ((entry (idlwave-rinfo-assq
+                 name type class (idlwave-routines)))
+         (name (or (car entry) name))
+         (class (or (nth 2 entry) class))
+         (source (nth 3 entry))
+         ;;(system (eq (car source) 'system))
+         (calling-seq (nth 4 entry))
+         (keywords (nth 5 entry))
+         (olh (nth 6 entry))
+         (help-echo3  "                                     Button3: IDL Online Help")
+         (help-echo23 "Button2: Pop to source and back.     Button3: IDL Online Help")
+         (col 0)
+         (data (list name type class (current-buffer) olh))
+         (km-prop (if (featurep 'xemacs) 'keymap 'local-map))
+         beg props win)
+    (setq keywords (idlwave-fix-keywords name type class keywords))
+    (cond
+     ((null entry)
+      (error "No %s %s known" type name))
+     ((or (null name) (equal name ""))
+      (error "No function or procedure call at point."))
+     ((null calling-seq)
+      (error "Calling sequence of %s %s is not available" type name))
+     (t
+      (save-excursion
+        (set-buffer (get-buffer-create "*Help*"))
+        (setq buffer-read-only nil)
+        (erase-buffer)
+        (set (make-local-variable 'idlwave-popup-source) nil)
+        (setq props (list 'mouse-face 'highlight
+                          km-prop idlwave-rinfo-map
+                          'help-echo help-echo23
+                          'data (cons 'usage data)))
+        (insert "Usage:    ")
+        (setq beg (point))
+        (insert (if class
+                    (format calling-seq class name)
+                  (format calling-seq name))
+                "\n")
+        (add-text-properties beg (point) props)
+
+        (insert "Keywords:")
+        (if (null keywords)
+            (insert " No keywords accepted.")
+          (setq col 9)
+          (mapcar
+           (lambda (x)
+             (if (>= (+ col 1 (length (car x))) 
+                     (window-width))
+                 (progn
+                   (insert "\n         ")
+                   (setq col 9)))
+             (insert " ")
+             (setq beg (point)
+                   props (list 'mouse-face 'highlight
+                               km-prop idlwave-rinfo-map
+                               'data (cons 'keyword data)
+                               'help-echo help-echo3
+                               'keyword (car x)))
+             (insert (car x))
+             (add-text-properties beg (point) props)
+             (setq col (+ col 1 (length (car x)))))
+           keywords))
+        (insert "\n")
+
+        (insert "Origin:   ")
+        (setq beg (point)
+              props (list 'mouse-face 'highlight
+                          km-prop idlwave-rinfo-map
+                          'help-echo help-echo23
+                          'data (cons 'origin data)))
+        (cond
+         ((eq (car source) 'system)
+          (insert "system routine"))
+         ((equal source '(lib))
+          (insert (format "library file %s.pro" (downcase name))))
+         ((eq (car source) 'lib)
+          (insert "library file ")
+          (insert (cdr source)))
+         ((eq (car source) 'buffer)
+          (insert "buffer visiting ")
+          (insert (abbreviate-file-name (cdr source))))
+         ((eq (car source) 'compiled)
+          (insert "compiled from ")
+          (insert (cdr source))))
+        (add-text-properties beg (point) props)
+        (setq buffer-read-only t))
+      (display-buffer "*Help*")
+      (if (and (setq win (get-buffer-window "*Help*"))
+               idlwave-resize-routine-help-window)
+          (progn
+            (let ((ww (selected-window)))
+              (unwind-protect
+                  (progn
+                    (select-window win)
+                    (enlarge-window (- (/ (frame-height) 2) 
+                                       (window-height)))
+                    (shrink-window-if-larger-than-buffer))
+                (select-window ww)))))))))
+
+(defun idlwave-mouse-active-rinfo-right (ev)
+  (interactive "e")
+  (idlwave-mouse-active-rinfo ev 'right))
+
+(defun idlwave-mouse-active-rinfo (ev &optional right)
+  (interactive "e")
+  (mouse-set-point ev)
+  (let (data id name type class buf keyword olh bufwin)
+    (setq data (get-text-property (point) 'data)
+          keyword (get-text-property (point) 'keyword)
+          id (car data)
+          name (nth 1 data)
+          type (nth 2 data)
+          class (nth 3 data)
+          buf (nth 4 data)
+          olh (nth 5 data)
+          bufwin (get-buffer-window buf t))
+    (cond ((or (eq id 'usage) (eq id 'origin))
+           (if right
+               (idlwave-search-online-help name type class)
+             (setq idlwave-popup-source (not idlwave-popup-source))
+             (if idlwave-popup-source
+                 (condition-case err
+                     (idlwave-do-find-module name type class)
+                   (error
+                    (setq idlwave-popup-source nil)
+                    (if (window-live-p bufwin) (select-window bufwin))
+                    (error (nth 1 err))))
+               (if bufwin
+                   (select-window bufwin)
+                 (pop-to-buffer buf)))))
+          ((eq id 'keyword)
+           (if right
+               (idlwave-search-online-help keyword 'kwd class olh)
+             (error "Button2 not active for keywords"))))))
+
+;; ----------------------------------------------------------------------------
+;;
+;; Additions for use with imenu.el and func-menu.el
+;; (pop-up a list of IDL units in the current file).
+;;
+
+(defun idlwave-prev-index-position ()
+  "Search for the previous procedure or function.
+Return nil if not found.  For use with imenu.el."
+  (save-match-data
+    (cond
+     ((idlwave-find-key "\\<\\(pro\\|function\\)\\>" -1 'nomark))
+     ;;   ((idlwave-find-key idlwave-begin-unit-reg 1 'nomark)
+     (t nil))))
+
+(defun idlwave-unit-name ()
+  "Return the unit name.
+Assumes that point is at the beginning of the unit as found by
+`idlwave-prev-index-position'."
+  (forward-sexp 2)
+  (forward-sexp -1)
+  (let ((begin (point)))
+    (re-search-forward "[a-zA-Z][a-zA-Z0-9$_]+\\(::[a-zA-Z][a-zA-Z0-9$_]+\\)?")
+    (if (fboundp 'buffer-substring-no-properties)
+        (buffer-substring-no-properties begin (point))
+      (buffer-substring begin (point)))))
+
+(defun idlwave-function-menu ()
+  "Use `imenu' or `function-menu' to jump to a procedure or function."
+  (interactive)
+  (if (string-match "XEmacs" emacs-version)
+      (progn
+        (require 'func-menu)
+        (function-menu))
+    (require 'imenu)
+    (imenu (imenu-choose-buffer-index))))
+
+;; Here we kack func-menu.el in order to support this new mode.
+;; The latest versions of func-menu.el already have this stuff in, so
+;; we hack only if it is not already there.
+(when (fboundp 'eval-after-load)
+  (eval-after-load "func-menu"
+    '(progn
+       (or (assq 'idlwave-mode fume-function-name-regexp-alist)
+           (not (boundp 'fume-function-name-regexp-idl))      ; avoid problems
+           (setq fume-function-name-regexp-alist
+                 (cons '(idlwave-mode . fume-function-name-regexp-idl)
+                       fume-function-name-regexp-alist)))
+       (or (assq 'idlwave-mode fume-find-function-name-method-alist)
+           (not (fboundp 'fume-find-next-idl-function-name))  ; avoid problems
+           (setq fume-find-function-name-method-alist
+                 (cons '(idlwave-mode . fume-find-next-idl-function-name)
+                       fume-find-function-name-method-alist))))))
+
+(defun idlwave-edit-in-idlde ()
+  "Edit the current file in IDL Development environment."
+  (interactive)
+  (start-process "idldeclient" nil
+                 idlwave-shell-explicit-file-name "-c" "-e"
+                 (buffer-file-name) "&"))
+                
+(defun idlwave-launch-idlhelp ()
+  "Start the IDLhelp application."
+  (interactive)
+  (start-process "idlhelp" nil idlwave-help-application))
+ 
+;; Menus - using easymenu.el
+(defvar idlwave-mode-menu-def
+  `("IDLWAVE"
+    ["PRO/FUNC menu" idlwave-function-menu t]
+    ("Motion"
+     ["Subprogram Start" idlwave-beginning-of-subprogram t]
+     ["Subprogram End" idlwave-end-of-subprogram t]
+     ["Block Start" idlwave-beginning-of-block t]
+     ["Block End" idlwave-end-of-block t]
+     ["Up Block" idlwave-backward-up-block t]
+     ["Down Block" idlwave-down-block t]
+     ["Skip Block Backward" idlwave-backward-block t]
+     ["Skip Block Forward" idlwave-forward-block t])
+    ("Mark"
+     ["Subprogram" idlwave-mark-subprogram t]
+     ["Block" idlwave-mark-block t]
+     ["Header" idlwave-mark-doclib t])
+    ("Format"
+     ["Indent Subprogram" idlwave-indent-subprogram t]
+     ["(Un)Comment Region" idlwave-toggle-comment-region "C-c ;"]
+     ["Continue/Split line" idlwave-split-line t]
+     "--"
+     ["Toggle Auto Fill" idlwave-auto-fill-mode :style toggle
+      :selected (symbol-value idlwave-fill-function)])
+    ("Templates"
+     ["Procedure" idlwave-procedure t]
+     ["Function" idlwave-function t]
+     ["Doc Header" idlwave-doc-header t]
+     ["Log" idlwave-doc-modification t]
+     "--"
+     ["Case" idlwave-case t]
+     ["For" idlwave-for t]
+     ["Repeat" idlwave-repeat t]
+     ["While" idlwave-while t]
+     "--"
+     ["Close Block" idlwave-close-block t])
+    ("Completion / RInfo"
+     ["Complete" idlwave-complete t]
+     ("Complete Special"
+      ["1 Procedure Name" (idlwave-complete 'procedure) t]
+      ["2 Procedure Keyword" (idlwave-complete 'procedure-keyword) t]
+      "--"
+      ["3 Function Name" (idlwave-complete 'function) t]
+      ["4 Function Keyword" (idlwave-complete 'function-keyword) t]
+      "--"
+      ["5 Procedure Method Name" (idlwave-complete 'procedure-method) t]
+      ["6 Procedure Method Keyword" (idlwave-complete 'procedure-method-keyword) t]
+      "--"
+      ["7 Function Method Name" (idlwave-complete 'function-method) t]
+      ["8 Function Method Keyword" (idlwave-complete 'function-method-keyword) t]
+      "--"
+      ["9 Class Name"  idlwave-complete-class t])
+     "--"
+     ["Show Routine Info" idlwave-routine-info t]
+     ["Show Routine Doc with IDLHELP" idlwave-routine-info-from-idlhelp t]
+     "--"
+     ["Find Routine Source" idlwave-find-module t]
+     "--"
+     ["Update Routine Info" idlwave-update-routine-info t]
+     "--"
+     "IDL Library Routine Info"
+     ["Select Library Directories" idlwave-create-libinfo-file t]
+     ["Scan Directories" (idlwave-update-routine-info '(16)) idlwave-scanned-lib-directories])
+     "--"
+    ("External"
+     ["Generate IDL tags" idlwave-make-tags t]
+     ["Start IDL shell" idlwave-shell t]
+     ["Edit file in IDLDE" idlwave-edit-in-idlde t]
+     ["Launch IDL Help" idlwave-launch-idlhelp t])
+    "--"
+    ("Customize"
+     ["Browse IDLWAVE Group" idlwave-customize t]
+     "--"
+     ["Build Full Customize Menu" idlwave-create-customize-menu 
+      (fboundp 'customize-menu-create)])
+    ("Documentation"
+     ["Describe Mode" describe-mode t]
+     ["Abbreviation List" idlwave-list-abbrevs t]
+     "--"
+     ["Commentary in idlwave.el" idlwave-show-commentary t]
+     ["Commentary in idlwave-shell.el" idlwave-shell-show-commentary t]
+     "--"
+     ["Info" idlwave-info t]
+     "--"
+     ["Launch IDL Help" idlwave-launch-idlhelp t])))
+
+(defvar idlwave-mode-debug-menu-def
+  '("Debug"
+    ["Start IDL shell" idlwave-shell t]
+    ["Save and .RUN buffer" idlwave-shell-save-and-run
+     (and (boundp 'idlwave-shell-automatic-start) 
+          idlwave-shell-automatic-start)]))
+
+(if (or (featurep 'easymenu) (load "easymenu" t))
+    (progn
+      (easy-menu-define idlwave-mode-menu idlwave-mode-map 
+                        "IDL and WAVE CL editing menu" 
+                        idlwave-mode-menu-def)
+      (easy-menu-define idlwave-mode-debug-menu idlwave-mode-map 
+                        "IDL and WAVE CL editing menu" 
+                        idlwave-mode-debug-menu-def)))
+
+(defun idlwave-customize ()
+  "Call the customize function with idlwave as argument."
+  (interactive)
+  ;; Try to load the code for the shell, so that we can customize it 
+  ;; as well.
+  (or (featurep 'idlwave-shell)
+      (load "idlwave-shell" t))
+  (customize-browse 'idlwave))
+
+(defun idlwave-create-customize-menu ()
+  "Create a full customization menu for IDLWAVE, insert it into the menu."
+  (interactive)
+  (if (fboundp 'customize-menu-create)
+      (progn
+        ;; Try to load the code for the shell, so that we can customize it 
+        ;; as well.
+        (or (featurep 'idlwave-shell)
+            (load "idlwave-shell" t))
+        (easy-menu-change 
+         '("IDLWAVE") "Customize"
+         `(["Browse IDLWAVE group" idlwave-customize t]
+           "--"
+           ,(customize-menu-create 'idlwave)
+           ["Set" Custom-set t]
+           ["Save" Custom-save t]
+           ["Reset to Current" Custom-reset-current t]
+           ["Reset to Saved" Custom-reset-saved t]
+           ["Reset to Standard Settings" Custom-reset-standard t]))
+        (message "\"IDLWAVE\"-menu now contains full customization menu"))
+    (error "Cannot expand menu (outdated version of cus-edit.el)")))
+
+(defun idlwave-show-commentary ()
+  "Use the finder to view the file documentation from `idlwave.el'."
+  (interactive)
+  (require 'finder)
+  (finder-commentary "idlwave.el"))
+
+(defun idlwave-shell-show-commentary ()
+  "Use the finder to view the file documentation from `idlwave-shell.el'."
+  (interactive)
+  (require 'finder)
+  (finder-commentary "idlwave-shell.el"))
+
+(defun idlwave-info ()
+  "Read documentation for IDLWAVE in the info system."
+  (interactive)
+  (require 'info)
+  (Info-goto-node "(idlwave)"))
+
+(defun idlwave-list-abbrevs (arg)
+  "Show the code abbreviations define in IDLWAVE mode.
+This lists all abbrevs where the replacement text differs from the input text.
+These are the ones the users want to learn to speed up their writing.
+
+The function does *not* list abbrevs which replace a word with itself
+to call a hook.  These hooks are used to change the case of words or
+to blink the matching `begin', and the user does not need to know them.
+
+With arg, list all abbrevs with the corresponding hook.
+
+This function was written since `list-abbrevs' looks terrible for IDLWAVE mode."
+
+  (interactive "P")
+  (let ((table (symbol-value 'idlwave-mode-abbrev-table))
+        abbrevs
+        str rpl func fmt (len-str 0) (len-rpl 0))
+    (mapatoms 
+     (lambda (sym)
+       (if (symbol-value sym)
+           (progn
+             (setq str (symbol-name sym)
+                   rpl (symbol-value sym)
+                   func (symbol-function sym))
+             (if arg
+                 (setq func (prin1-to-string func))
+               (if (and (listp func) (stringp (nth 2 func)))
+                   (setq rpl (concat "EVAL: " (nth 2 func))
+                         func "")
+                 (setq func "")))
+             (if (or arg (not (string= rpl str)))
+                 (progn
+                   (setq len-str (max len-str (length str)))
+                   (setq len-rpl (max len-rpl (length rpl)))
+                   (setq abbrevs (cons (list str rpl func) abbrevs)))))))
+     table)
+    ;; sort the list
+    (setq abbrevs (sort abbrevs (lambda (a b) (string< (car a) (car b)))))
+    ;; Make the format
+    (setq fmt (format "%%-%ds   %%-%ds   %%s\n" len-str len-rpl))
+    (with-output-to-temp-buffer "*Help*"
+      (if arg
+          (progn
+            (princ "Abbreviations and Actions in IDLWAVE-Mode\n") 
+            (princ "=========================================\n\n")
+            (princ (format fmt "KEY" "REPLACE" "HOOK"))
+            (princ (format fmt "---" "-------" "----")))
+        (princ "Code Abbreviations and Templates in IDLWAVE-Mode\n")
+        (princ "================================================\n\n")
+        (princ (format fmt "KEY" "ACTION" ""))
+        (princ (format fmt "---" "------" "")))
+      (mapcar
+       (lambda (list)
+         (setq str (car list)
+               rpl (nth 1 list)
+               func (nth 2 list))
+         (princ (format fmt str rpl func)))
+       abbrevs)))
+  ;; Make sure each abbreviation uses only one display line
+  (save-excursion
+    (set-buffer "*Help*")
+    (setq truncate-lines t)))
+
+(run-hooks 'idlwave-load-hook)
+
+(provide 'idlwave)
+
+;;; idlwave.el ends here
+