Gecko [ 122.154.134.11 ]

Name	Size	Permission
ada-mode.elc	107.46 KB	-rw-r--r--
ada-prj.elc	17.96 KB	-rw-r--r--
ada-stmt.elc	36.03 KB	-rw-r--r--
ada-xref.elc	54.99 KB	-rw-r--r--
antlr-mode.elc	77.63 KB	-rw-r--r--
asm-mode.elc	6.08 KB	-rw-r--r--
autoconf.elc	3.37 KB	-rw-r--r--
bug-reference.elc	5.83 KB	-rw-r--r--
cap-words.elc	3.54 KB	-rw-r--r--
cc-align.elc	35.43 KB	-rw-r--r--
cc-awk.elc	20.23 KB	-rw-r--r--
cc-bytecomp.elc	10.45 KB	-rw-r--r--
cc-cmds.elc	92.26 KB	-rw-r--r--
cc-compat.elc	2.97 KB	-rw-r--r--
cc-defs.elc	46.7 KB	-rw-r--r--
cc-engine.elc	143.05 KB	-rw-r--r--
cc-fonts.elc	140.72 KB	-rw-r--r--
cc-langs.elc	70.29 KB	-rw-r--r--
cc-menus.elc	7.32 KB	-rw-r--r--
cc-mode.elc	144.75 KB	-rw-r--r--
cc-styles.elc	16.11 KB	-rw-r--r--
cc-subword.elc	6.99 KB	-rw-r--r--
cc-vars.elc	71.07 KB	-rw-r--r--
cfengine.elc	8.09 KB	-rw-r--r--
cmacexp.elc	6.58 KB	-rw-r--r--
compile.elc	69.45 KB	-rw-r--r--
cperl-mode.elc	215.39 KB	-rw-r--r--
cpp.elc	21.52 KB	-rw-r--r--
cwarn.elc	12.8 KB	-rw-r--r--
dcl-mode.elc	49.31 KB	-rw-r--r--
delphi.elc	50.03 KB	-rw-r--r--
ebnf-abn.elc	7.39 KB	-rw-r--r--
ebnf-bnf.elc	7.99 KB	-rw-r--r--
ebnf-dtd.elc	13.82 KB	-rw-r--r--
ebnf-ebx.elc	8.77 KB	-rw-r--r--
ebnf-iso.elc	8.14 KB	-rw-r--r--
ebnf-otz.elc	8.51 KB	-rw-r--r--
ebnf-yac.elc	7.53 KB	-rw-r--r--
ebnf2ps.elc	121.25 KB	-rw-r--r--
ebrowse.elc	202.93 KB	-rw-r--r--
etags.elc	54.14 KB	-rw-r--r--
executable.elc	7.6 KB	-rw-r--r--
f90.elc	82.59 KB	-rw-r--r--
flymake.elc	61.25 KB	-rw-r--r--
fortran.elc	60.13 KB	-rw-r--r--
gdb-ui.elc	138.61 KB	-rw-r--r--
glasses.elc	10.15 KB	-rw-r--r--
grep.elc	27.75 KB	-rw-r--r--
gud.elc	93.94 KB	-rw-r--r--
hideif.elc	26.67 KB	-rw-r--r--
hideshow.elc	24.54 KB	-rw-r--r--
icon.elc	16.23 KB	-rw-r--r--
idlw-complete-structtag.elc	4.75 KB	-rw-r--r--
idlw-help.elc	35.31 KB	-rw-r--r--
idlw-shell.elc	134.39 KB	-rw-r--r--
idlw-toolbar.elc	28.34 KB	-rw-r--r--
idlwave.elc	254.7 KB	-rw-r--r--
inf-lisp.elc	18.43 KB	-rw-r--r--
ld-script.elc	4.91 KB	-rw-r--r--
m4-mode.elc	4.91 KB	-rw-r--r--
make-mode.elc	58.79 KB	-rw-r--r--
mantemp.elc	3.77 KB	-rw-r--r--
meta-mode.elc	27.42 KB	-rw-r--r--
mixal-mode.elc	35.32 KB	-rw-r--r--
modula2.elc	14.23 KB	-rw-r--r--
octave-inf.elc	11.87 KB	-rw-r--r--
octave-mod.elc	44.6 KB	-rw-r--r--
pascal.elc	40.31 KB	-rw-r--r--
perl-mode.elc	22.42 KB	-rw-r--r--
prolog.elc	12.7 KB	-rw-r--r--
ps-mode.elc	33.38 KB	-rw-r--r--
python.elc	86.23 KB	-rw-r--r--
ruby-mode.elc	34.59 KB	-rw-r--r--
scheme.elc	15.94 KB	-rw-r--r--
sh-script.elc	94.73 KB	-rw-r--r--
simula.elc	44.81 KB	-rw-r--r--
sql.elc	101.34 KB	-rw-r--r--
sym-comp.elc	7.15 KB	-rw-r--r--
tcl.elc	38.58 KB	-rw-r--r--
vera-mode.elc	44.5 KB	-rw-r--r--
verilog-mode.elc	331.76 KB	-rw-r--r--
vhdl-mode.elc	510.47 KB	-rw-r--r--
which-func.elc	9.72 KB	-rw-r--r--
xscheme.elc	37.76 KB	-rw-r--r--

Code Editor : idlwave.elc

;ELC���
;;; Compiled by mockbuild@c6b8.bsys.dev.centos.org on Thu Feb 19 13:05:09 2015
;;; from file /builddir/build/BUILD/emacs-23.1/lisp/progmodes/idlwave.el
;;; in Emacs version 23.1.1
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.
(if (and (boundp 'emacs-version)
	 (< (aref emacs-version (1- (length emacs-version))) ?A)
	 (or (and (boundp 'epoch::version) epoch::version)
	     (string-lessp emacs-version "19.29")))
    (error "`idlwave.el' was compiled for Emacs 19.29 or later"))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(byte-code "\300\301!\210\302\303!\204�\304\303\305\"\210\302\306!\204�\304\306\307\"\210\302\310!\204%�\304\310\311\"\210\302\312!\2040�\304\312\313\"\210\302\314!\204;�\315\316\317\217\210\320\321\315\322\323\324\325\326\325\327\325\330\325\331\332\333\334\335&\210\320\336\315\337\334\321%\207" [require idlw-help fboundp line-beginning-position defalias point-at-bol line-end-position point-at-eol char-valid-p characterp match-string-no-properties match-string cancel-timer nil (byte-code "\300\301!\207" [require timer] 2) ((error)) custom-declare-group idlwave "Major mode for editing IDL .pro files." :tag "IDLWAVE" :link (url-link :tag "Home Page" "http://idlwave.org") (emacs-commentary-link :tag "Commentary in idlw-shell.el" "idlw-shell.el") (emacs-commentary-link :tag "Commentary in idlwave.el" "idlwave.el") (custom-manual "(idlwave)Top") :prefix "idlwave" :group languages idlwave-code-formatting "Indentation and formatting options for IDLWAVE mode."] 18)
#@146 *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.
(custom-declare-variable 'idlwave-main-block-indent '2 '(#$ . -1592) :group 'idlwave-code-formatting :type 'integer)
#@119 *Extra indentation applied to block lines.
If you change this, you probably also want to change `idlwave-end-offset'.
(custom-declare-variable 'idlwave-block-indent '3 '(#$ . -1861) :group 'idlwave-code-formatting :type 'integer)
#@153 *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.
(custom-declare-variable 'idlwave-end-offset '-3 '(#$ . -2098) :group 'idlwave-code-formatting :type 'integer)
#@185 *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.
(custom-declare-variable 'idlwave-continuation-indent '3 '(#$ . -2368) :group 'idlwave-code-formatting :type 'integer)
#@606 *Maximum additional indentation for special continuation indent.
Several special indentations are tried to help line up continuation
lines in routine calls or definitions, other statements with
parentheses, or assignment statements.  This variable specifies a
maximum amount by which this special indentation can exceed the
standard continuation indentation, otherwise defaulting to a fixed
offset.  Set to 0 to effectively disable all special continuation
indentation, or to a large number (like 100) to enable it in all
cases.  See also `idlwave-indent-to-open-paren', which can override
this variable.
(custom-declare-variable 'idlwave-max-extra-continuation-indent '40 '(#$ . -2678) :group 'idlwave-code-formatting :type 'integer)
#@737 *Non-nil means, indent continuation lines to innermost open
parenthesis.  This indentation occurs even if otherwise disallowed by
`idlwave-max-extra-continuation-indent'.  Matching parens and the
interleaving args are lined up.  Example:

x = function_a(function_b(function_c( a, b, [1,2,3, $
                                               4,5,6 $
                                              ], $
                                        c, d $
                                      )))

When this variable is nil, paren alignment may still occur, based on
the value of `max-extra-continuation-indent', which, if zero, would
yield:

x = function_a(function_b(function_c( a, b, [1,2,3, $
     4,5,6 $
     ], $
     c, d $
     )))
(custom-declare-variable 'idlwave-indent-to-open-paren 't '(#$ . -3420) :group 'idlwave-code-formatting :type 'boolean)
#@104 *Non-nil means, indent continuation lines with parens by nesting
lines at consecutively deeper levels.
(custom-declare-variable 'idlwave-indent-parens-nested 'nil '(#$ . -4283) :group 'idlwave-code-formatting :type 'boolean)
#@159 *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.
(custom-declare-variable 'idlwave-hanging-indent 't '(#$ . -4515) :group 'idlwave-code-formatting :type 'boolean)
#@190 *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.
(custom-declare-variable 'idlwave-hang-indent-regexp '"- " '(#$ . -4794) :group 'idlwave-code-formatting :type 'regexp)
#@70 *If non-nil then use last match on line for `idlwave-indent-regexp'.
(custom-declare-variable 'idlwave-use-last-hang-indent 'nil '(#$ . -5109) :group 'idlwave-code-formatting :type 'boolean)
#@64 *If non-nil then auto fill will only operate on comment lines.
(custom-declare-variable 'idlwave-fill-comment-line-only 't '(#$ . -5306) :group 'idlwave-code-formatting :type 'boolean)
#@405 *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.
(custom-declare-variable 'idlwave-auto-fill-split-string 't '(#$ . -5498) :group 'idlwave-code-formatting :type 'boolean)
#@263 *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.
(custom-declare-variable 'idlwave-split-line-string 't '(#$ . -6031) :group 'idlwave-code-formatting :type 'boolean)
#@177 *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.
(custom-declare-variable 'idlwave-no-change-comment '";;;" '(#$ . -6417) :group 'idlwave-code-formatting :type 'string)
#@273 *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 "^".
(custom-declare-variable 'idlwave-begin-line-comment 'nil '(#$ . -6720) :group 'idlwave-code-formatting :type '(choice (const :tag "Any line beginning with `;'" nil) 'regexp))
#@192 *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.
(custom-declare-variable 'idlwave-code-comment '";;[^;]" '(#$ . -7175) :group 'idlwave-code-formatting :type 'regexp)
(custom-declare-group 'idlwave-routine-info nil "Routine Info options for IDLWAVE mode." :group 'idlwave)
#@296 *Non-nil means search the IDL path for library catalog files.

These files, named .idlwave_catalog, document routine information for
individual directories and libraries of IDL .pro files.  Many popular
libraries come with catalog files by default, so leaving this on is a
usually a good idea..
(custom-declare-variable 'idlwave-use-library-catalogs 't '(#$ . -7597) :group 'idlwave-routine-info :type 'boolean)
#@874 *Seconds of idle time before routine info is automatically
initialized.  Initializing the routine info can take a long time, in
particular if a large number of library catalogs are involved.  When
Emacs is idle for more than the number of seconds specified by this
variable, it starts the initialization.  The process is split into
five steps, in order to keep work interruption as short as possible.
If one of the steps finishes, and no user input has arrived in the
mean time, initialization proceeds immediately to the next step.  A
good value for this variable is about 1/3 of the time initialization
take in your setup.  So if you have a fast machine and no problems
with a slow network connection, don't hesitate to set this to 2
seconds.  A Value of 0 means, don't initialize automatically, but
instead wait until routine information is needed, and initialize
then.
(custom-declare-variable 'idlwave-init-rinfo-when-idle-after '10 '(#$ . -8016) :group 'idlwave-routine-info :type 'number)
#@337 *Non-nil means, scan buffers for IDL programs when updating info.
The scanning is done by the command `idlwave-update-routine-info'.
The following values are allowed:

nil       Don't scan any buffers.
t         Scan all idlwave-mode buffers in the current editing session.
current   Scan only the current buffer, but no other buffers.
(custom-declare-variable 'idlwave-scan-all-buffers-for-routine-info 't '(#$ . -9019) :group 'idlwave-routine-info :type '(choice (const :tag "No buffer" nil) (const :tag "All buffers" t) (const :tag "Current buffer only" 'current)))
#@242 *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.
(custom-declare-variable 'idlwave-query-shell-for-routine-info 't '(#$ . -9595) :group 'idlwave-routine-info :type 'boolean)
#@465 *Controls under what circumstances routine info is updated automatically.
Possible values:
nil       Never
t         All available
(...)     A list of circumstances. Allowed members are:
           find-file       Add info for new IDLWAVE buffers.
           save-buffer     Update buffer info when buffer is saved
           kill-buffer     Remove buffer info when buffer gets killed
           compile-buffer  Update shell info after `idlwave-shell-save-and...'
(custom-declare-variable 'idlwave-auto-routine-info-updates ''(find-file save-buffer kill-buffer compile-buffer) '(#$ . -9968) :group 'idlwave-routine-info :type '(choice (const :tag "Never" nil) (const :tag "As often as possible" t) (set :tag "Checklist" :greedy t (const :tag "When visiting a file" find-file) (const :tag "When saving a buffer" save-buffer) (const :tag "After a buffer was killed" kill-buffer) (const :tag "After a buffer was compiled successfully, update shell info" compile-buffer))))
#@174 *Maximum number of source files displayed in the Routine Info window.
When an integer, it is the maximum number of source files displayed.
t means to show all source files.
(custom-declare-variable 'idlwave-rinfo-max-source-lines '5 '(#$ . -10945) :group 'idlwave-routine-info :type 'integer)
#@692 Library path for Windows and MacOS (OS9).  Not needed under UNIX.
When selecting the directories to scan for IDL user catalog routine
info, IDLWAVE can, under UNIX, query the shell for the exact search
path (the value of !PATH).  However, under Windows and MacOS
(pre-OSX), the IDLWAVE shell does not work.  In this case, this
variable can be set to specify the paths where IDLWAVE can find PRO
files.  The shell will only be asked for a list of paths when this
variable is nil.  The value is a list of directories.  A directory
preceeded by a `+' will be searched recursively.  If you set this
variable on a UNIX system, the shell will not be queried.  See also
`idlwave-system-directory'.
(custom-declare-variable 'idlwave-library-path 'nil '(#$ . 11245) :group 'idlwave-routine-info :type '(repeat (directory)))
#@465 The IDL system directory for Windows and MacOS.  Not needed under
UNIX.  Set this to the value of the `!DIR' system variable in IDL.
IDLWAVE uses this to find out which of the library routines belong to
the official system library.  All files inside the `lib' subdirectory
are considered system library files - so don't install private stuff
in this directory.  On UNIX systems, IDLWAVE queries the shell for the
value of `!DIR'.  See also `idlwave-library-path'.
(custom-declare-variable 'idlwave-system-directory '"" '(#$ . 12067) :group 'idlwave-routine-info :type 'directory)
#@62 *Directory for configuration files and user-library catalog.
(custom-declare-variable 'idlwave-config-directory '(convert-standard-filename "~/.idlwave") '(#$ . -12653) :group 'idlwave-routine-info :type 'file)
(byte-code "\301B\302\301!\204�\303\301\304\"\210\305B\302\305!\204�\303\305\306\"\210\307B\302\307!\204-�\303\307\310\"\210\301\207" [current-load-list idlwave-user-catalog-file default-boundp set-default "idlusercat.el" idlwave-xml-system-rinfo-converted-file "idl_xml_rinfo.el" idlwave-path-file "idlpath.el"] 3)
#@37 *Obsolete variable, no longer used.
(defvar idlwave-libinfo-file nil (#$ . -13194))
#@524 Alist of regular expressions matching special library directories.
When listing routine source locations, IDLWAVE gives a short hint where
the file defining the routine is located.  By default it lists `SystemLib'
for routines in the system library `!DIR/lib' and `Library' for anything
else.  This variable can define additional types.  The car of each entry
is a regular expression matching the file name (they normally will match
on the path).  The cdr is the string to be used as identifier.  Max 10
chars are allowed.
(custom-declare-variable 'idlwave-special-lib-alist 'nil '(#$ . 13285) :group 'idlwave-routine-info :type '(repeat (cons regexp string)))
#@298 Write out path (!PATH) and system directory (!DIR) info automatically.
Path info is needed to locate library catalog files.  If non-nil,
whenever the path-list changes as a result of shell-query, etc., it is
written to file.  Otherwise, the menu option "Write Paths" can be
used to force a write.
(custom-declare-variable 'idlwave-auto-write-paths 't '(#$ . 13953) :group 'idlwave-routine-info :type 'boolean)
(byte-code "\301\302\303\304\305\306\307\310&\210\311B\312\313!\207" [current-load-list custom-declare-group idlwave-completion nil "Completion options for IDLWAVE mode." :prefix "idlwave" :group idlwave idlwave-tmp (lambda (#1=#:defconst-tmp-var) (defconst idlwave-tmp #1#)) (choice :tag "by applying the function" (const upcase) (const downcase) (const capitalize) (const preserve) (symbol :tag "Other"))] 8)
#@1571 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.
(custom-declare-variable 'idlwave-completion-case ''((routine . upcase) (keyword . upcase) (class . preserve) (method . preserve)) '(#$ . 14785) :group 'idlwave-completion :type (byte-code "\301\302\303ED\207" [idlwave-tmp repeat cons (symbol :tag "Derive completion case for")] 4))
#@287 *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.
(custom-declare-variable 'idlwave-completion-force-default-case 'nil '(#$ . -16646) :group 'idlwave-completion :type 'boolean)
#@319 *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.
(custom-declare-variable 'idlwave-complete-empty-string-as-lower-case 'nil '(#$ . -17066) :group 'idlwave-completion :type 'boolean)
#@102 Obsolete variable.  See `idlwave-complete-empty-string-as-lower-case' and
`idlwave-completion-case'.
(defvar idlwave-default-completion-case-is-down nil (#$ . 17524))
#@313 *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.
(custom-declare-variable 'idlwave-buffer-case-takes-precedence 'nil '(#$ . -17698) :group 'idlwave-completion :type 'boolean)
#@187 *Non-nil means, highlight completions for which system help is available.
Help can then be accessed with mouse-3.
This option is only effective when the online help system is installed.
(custom-declare-variable 'idlwave-highlight-help-links-in-completion 't '(#$ . -18143) :group 'idlwave-completion :type 'boolean)
#@169 Non-nil means, treat inheritance with completion, online help etc.
When nil, IDLWAVE only knows about the native methods and tags of a class,
not about inherited ones.
(custom-declare-variable 'idlwave-support-inheritance 't '(#$ . 18466) :group 'idlwave-routine-info :type 'boolean)
#@386 List of regular expressions for class-driven keyword inheritance.
Keyword inheritance is often tied to class inheritance by "chaining"
up the class tree.  While it cannot be assumed that the presence of an
_EXTRA or _REF_EXTRA symbol guarantees such chaining will occur, for
certain methods this assumption is almost always true.  The methods
for which to assume this can be set here.
(custom-declare-variable 'idlwave-keyword-class-inheritance ''("^[gs]etproperty$" "^init$") '(#$ . 18757) :group 'idlwave-routine-info :type '(repeat (regexp :tag "Match method:")))
#@673 *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 valid 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.
(custom-declare-variable 'idlwave-completion-show-classes '1 '(#$ . -19331) :group 'idlwave-completion :type '(choice (const :tag "Don't show" nil) (integer :tag "Number of classes shown" 1)))
#@191 *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'.
(custom-declare-variable 'idlwave-completion-fontify-classes 't '(#$ . -20203) :group 'idlwave-completion :type 'boolean)
#@2145 Association list governing specification of object classes for completion.

When IDLWAVE tries to complete object-oriented methods, 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
needs to determine the appropriate class.  IDLWAVE has two ways of
doing this (well, three ways if you count the shell... see
`idlwave-shell-query-for-class'):

1. Combine the items of all available classes which contain this
   method for the purpose of completion.  So when completing a method,
   all methods of all known classes are available, and when completing
   a keyword, all keywords allowed for this method in any class are
   shown.  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 you to configure IDLWAVE's method and
method-keyword completion behavior.  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 found 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.
(custom-declare-variable 'idlwave-query-class ''((method-default) (keyword-default)) '(#$ . 20523) :group 'idlwave-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")))))
#@1048 *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.
(custom-declare-variable 'idlwave-store-inquired-class 't '(#$ . -23137) :group 'idlwave-completion :type 'boolean)
#@288 *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.
(custom-declare-variable 'idlwave-class-arrow-face ''bold '(#$ . -24307) :group 'idlwave-completion :type 'symbol)
#@75 *Non-nil means, resize the Routine-info *Help* window to fit the content.
(custom-declare-variable 'idlwave-resize-routine-help-window 't '(#$ . -24715) :group 'idlwave-completion :type 'boolean)
#@77 *Non-nil means, completion automatically adds `=' after completed keywords.
(custom-declare-variable 'idlwave-keyword-completion-adds-equal 't '(#$ . -24917) :group 'idlwave-completion :type 'boolean)
#@200 *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.
(custom-declare-variable 'idlwave-function-completion-adds-paren 't '(#$ . -25125) :group 'idlwave-completion :type '(choice (const :tag "Nothing" nil) (const :tag "(" t) (const :tag "()" 2)))
#@279 *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.
(custom-declare-variable 'idlwave-completion-restore-window-configuration 't '(#$ . -25524) :group 'idlwave-completion :type 'boolean)
(custom-declare-group 'idlwave-abbrev-and-indent-action nil "IDLWAVE performs actions when expanding abbreviations or indenting lines.\nThe variables in this group govern this." :group 'idlwave)
#@128 *Non-nil means performs actions when indenting.
The actions that can be performed are listed in `idlwave-indent-action-table'.
(custom-declare-variable 'idlwave-do-actions 'nil '(#$ . -26139) :group 'idlwave-abbrev-and-indent-action :type 'boolean)
#@394 *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.
(custom-declare-variable 'idlwave-abbrev-start-char '"\\" '(#$ . -26395) :group 'idlwave-abbrev-and-indent-action :type 'string)
#@477 *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'.
(custom-declare-variable 'idlwave-surround-by-blank 'nil '(#$ . -26924) :group 'idlwave-abbrev-and-indent-action :type 'boolean)
#@307 *Non-nil means pad '=' in keywords (routine calls or defs) like assignment.
Whenever `idlwave-surround' is non-nil then this affects how '=' is
padded for keywords and for variables.  If t, pad the same as for
assignments.  If nil then spaces are removed.  With any other value,
spaces are left unchanged.
(custom-declare-variable 'idlwave-pad-keyword 't '(#$ . -27536) :group 'idlwave-abbrev-and-indent-action :type '(choice (const :tag "Pad like assignments" t) (const :tag "Remove space near `='" nil) (const :tag "Keep space near `='" 'keep)))
#@74 *Non-nil means point blinks to block beginning for `idlwave-show-begin'.
(custom-declare-variable 'idlwave-show-block 't '(#$ . -28090) :group 'idlwave-abbrev-and-indent-action :type 'boolean)
#@66 *Non-nil means expand generic END to ENDIF/ENDELSE/ENDWHILE etc.
(custom-declare-variable 'idlwave-expand-generic-end 'nil '(#$ . -28289) :group 'idlwave-abbrev-and-indent-action :type 'boolean)
#@52 *Non-nil means re-indent line after END was typed.
(custom-declare-variable 'idlwave-reindent-end 't '(#$ . -28490) :group 'idlwave-abbrev-and-indent-action :type 'boolean)
#@311 *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'.
(custom-declare-variable 'idlwave-abbrev-move 't '(#$ . -28670) :group 'idlwave-abbrev-and-indent-action :type 'boolean)
#@347 *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.
(custom-declare-variable 'idlwave-abbrev-change-case 'nil '(#$ . -29108) :group 'idlwave-abbrev-and-indent-action :type 'boolean)
#@190 *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.
(custom-declare-variable 'idlwave-reserved-word-upcase 'nil '(#$ . -29591) :group 'idlwave-abbrev-and-indent-action :type 'boolean)
#@380 *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-action-table nil (#$ . -29919))
#@394 *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.
(defvar idlwave-indent-expand-table nil (#$ . -30360))
(custom-declare-group 'idlwave-documentation nil "Options for documenting IDLWAVE files." :group 'idlwave)
#@328 *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.
(defvar idlwave-file-header (list nil ";+\n; NAME:\n;\n;\n;\n; PURPOSE:\n;\n;\n;\n; CATEGORY:\n;\n;\n;\n; CALLING SEQUENCE:\n;\n;\n;\n; INPUTS:\n;\n;\n;\n; OPTIONAL INPUTS:\n;\n;\n;\n; KEYWORD PARAMETERS:\n;\n;\n;\n; OUTPUTS:\n;\n;\n;\n; OPTIONAL OUTPUTS:\n;\n;\n;\n; COMMON BLOCKS:\n;\n;\n;\n; SIDE EFFECTS:\n;\n;\n;\n; RESTRICTIONS:\n;\n;\n;\n; PROCEDURE:\n;\n;\n;\n; EXAMPLE:\n;\n;\n;\n; MODIFICATION HISTORY:\n;\n;-\n") (#$ . -30922))
#@221 *Non-nil means, the documentation header will always be at start of file.
When nil, the header is positioned between the PRO/FUNCTION line of
the current routine and the code, allowing several routine headers in
a file.
(custom-declare-variable 'idlwave-header-to-beginning-of-file 't '(#$ . -31695) :group 'idlwave-documentation :type 'boolean)
#@64 *The hook function used to update the timestamp of a function.
(custom-declare-variable 'idlwave-timestamp-hook ''idlwave-default-insert-timestamp '(#$ . -32047) :group 'idlwave-documentation :type 'function)
#@209 *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.
(custom-declare-variable 'idlwave-doc-modifications-keyword '"HISTORY" '(#$ . -32263) :group 'idlwave-documentation :type 'string)
#@58 *Regexp matching the start of a document library header.
(custom-declare-variable 'idlwave-doclib-start '"^;+\\+" '(#$ . -32608) :group 'idlwave-documentation :type 'regexp)
#@56 *Regexp matching the end of a document library header.
(custom-declare-variable 'idlwave-doclib-end '"^;+-" '(#$ . -32788) :group 'idlwave-documentation :type 'regexp)
(custom-declare-group 'idlwave-external-programs nil "Path locations of external commands used by IDLWAVE." :group 'idlwave)
#@374 *If non-nil, this is the command to run IDL.
Should be an absolute file path or path relative to the current environment
execution search path.  If you want to specify command line switches
for the idl program, use `idlwave-shell-command-line-options'.

I know the name of this variable is badly chosen, but I cannot change
it without compromizing backwards-compatibility.
(custom-declare-variable 'idlwave-shell-explicit-file-name '"idl" '(#$ . -33088) :group 'idlwave-external-programs :type 'string)
#@373 *A list of command line options for calling the IDL program.
Since IDL is executed directly without going through a shell like /bin/sh,
this should be a list of strings like '("-rt=file" "-nw") with a separate
string for each argument.  But you may also give a single string which
contains the options whitespace-separated.  Emacs will be kind enough to
split it for you.
(custom-declare-variable 'idlwave-shell-command-line-options 'nil '(#$ . -33598) :type '(choice string (repeat (string :value ""))) :group 'idlwave-external-programs)
#@124 *The external application providing reference help for programming.
Obsolete, if the IDL Assistant is being used for help.
(custom-declare-variable 'idlwave-help-application '"idlhelp" '(#$ . -34144) :group 'idlwave-external-programs :type 'string)
#@470 List of modifiers to be used for the debugging commands.
Will be used to bind debugging commands in the shell buffer and in all
source buffers.  These are additional convenience bindings, the debugging
commands are always available with the `C-c C-d' prefix.
If you set this to '(control shift), this means setting a breakpoint will
be on `C-S-b', compiling a source file on `C-S-c' etc.  Possible modifiers
are `control', `meta', `super', `hyper', `alt', and `shift'.
(custom-declare-variable 'idlwave-shell-debug-modifiers ''nil '(#$ . 34400) :group 'idlwave-shell-general-setup :type '(set :tag "Specify modifiers" (const control) (const meta) (const super) (const hyper) (const alt) (const shift)))
#@143 *If non-nil attempt invoke idlwave-shell if not already running.
This is checked when an attempt to send a command to an
IDL process is made.
(custom-declare-variable 'idlwave-shell-automatic-start 'nil '(#$ . -35110) :group 'idlwave-shell-general-setup :type 'boolean)
(custom-declare-group 'idlwave-misc nil "Miscellaneous options for IDLWAVE mode." :link '(custom-group-link :tag "Font Lock Faces group" font-lock-faces) :group 'idlwave)
#@74 *Non-nil displays a startup message when `idlwave-mode' is first called.
(custom-declare-variable 'idlwave-startup-message 't '(#$ . -35557) :group 'idlwave-misc :type 'boolean)
#@795 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
idlwave-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
(custom-declare-variable 'idlwave-default-font-lock-items ''(pros-and-functions batch-files idlwave-idl-keywords label goto common-blocks class-arrows) '(#$ . 35742) :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)" idlwave-idl-keywords) (const :tag "Statement Labels" label) (const :tag "Goto Statements" goto) (const :tag "Tags in Structure Definition" structtag) (const :tag "Structure Name" structname) (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)))
#@66 Normal hook.  Executed when a buffer is put into `idlwave-mode'.
(custom-declare-variable 'idlwave-mode-hook 'nil '(#$ . 37350) :group 'idlwave-misc :type 'hook)
#@51 Normal hook.  Executed when idlwave.el is loaded.
(custom-declare-variable 'idlwave-load-hook 'nil '(#$ . 37518) :group 'idlwave-misc :type 'hook)
#@202 Non-nil means turn on a few experimental features.
This variable is only for the maintainer, to test difficult stuff,
while still distributing stable releases.
As a user, you should not set this to t.
(defvar idlwave-experimental nil (#$ . 37672))
(byte-code "\306B\307\306!\204�\310\306\311\"\210\312\313\314\315\316\317$\320%\321&\322'\323(\324)\325*\326+\327B\330\327\331\332#\210\333	D!\210\334B\330\334\331\335#\210\336\337\340,\"!\210\341B\330\341\331\342#\210\343	
$%&\n'(+\257!\210.
\306\207" [current-load-list pros-and-functions common-blocks batch-files fixme label idlwave-idl-keywords default-boundp set-default "\\<\$&&\\|and\\|b\\(egin\\|reak\$\\|c\$ase\\|o\\(mpile_opt\\|ntinue\$\\)\\|do\\|e\$lse\\|nd\\(case\\|else\\|for\\|if\\|rep\\|switch\\|while\$?\\|q\\)\\|for\$ward_function\$?\\|g\$oto\\|[et]\$\\|i\$f\\|nherits\$\\|l[et]\\|mod\\|n\$e\\|ot\$\\|o\$n_\\(error\\|ioerror\$\\|[fr]\\)\\|re\$peat\\|turn\$\\|switch\\|then\\|until\\|while\\|xor\\|||\\)\\>" ("\\<\$function\\|pro\$\\>[ 	]+\$\\sw+\\(::\\sw+\$?\\)" (1 font-lock-keyword-face) (2 font-lock-function-name-face nil t)) ("\\<\$common\$\\>[ 	]*\$\\sw+\$?[ 	]*,?" (1 font-lock-keyword-face) (2 font-lock-reference-face nil t) ("[ 	]*\$\\sw+\$[ ,]*" (goto-char (match-end 0)) nil (1 font-lock-variable-name-face))) ("^[ 	]*\$@[^ 	\n]+\$" (1 font-lock-string-face)) ("\\<FIXME:" (0 font-lock-warning-face t)) ("^[ 	]*\$[a-zA-Z]\\sw*:\$" (1 font-lock-reference-face)) ("\$goto\$[ 	]*,[ 	]*\$[a-zA-Z]\\sw*\$" (1 font-lock-keyword-face) (2 font-lock-reference-face)) ("\\<\$[a-zA-Z][a-zA-Z0-9_]*:\$[^:]" (1 font-lock-reference-face)) ("\${\\|\\<inherits\\s-\$\\s-*\$[a-zA-Z][a-zA-Z0-9_]*\$[},	 \n]" (2 font-lock-function-name-face)) ("\$,\\|[a-zA-Z0-9_](\$[ 	]*\$\\$[ 	]*\\(;.*\$?\n\$[ 	]*\\(;.*\$?\n\\)*[ 	]*\\)?\$/[a-zA-Z_]\\sw*\\|[a-zA-Z_]\\sw*[ 	]*=\$" (6 font-lock-reference-face)) ("\$![a-zA-Z_0-9]+\\(\\.\\sw+\$?\\)" (1 font-lock-variable-name-face)) ("[<>#]" (0 font-lock-keyword-face)) ("[-*^#+<>/]" (0 font-lock-keyword-face)) (idlwave-match-class-arrows (0 idlwave-class-arrow-face)) idlwave-font-lock-keywords-1 put variable-documentation "Subdued level highlighting for IDLWAVE mode." (lambda (#1=#:defconst-tmp-var) (defconst idlwave-font-lock-keywords-1 #1#)) idlwave-font-lock-keywords-2 "Medium level highlighting for IDLWAVE mode." (lambda (#2=#:defconst-tmp-var) (defconst idlwave-font-lock-keywords-2 #2#)) mapcar symbol-value idlwave-font-lock-keywords-3 "Gaudy level highlighting for IDLWAVE mode." (lambda (#3=#:defconst-tmp-var) (defconst idlwave-font-lock-keywords-3 #3#)) goto structtag structname keyword-parameters system-variables special-operators all-operators class-arrows idlwave-default-font-lock-items] 12)
(defalias 'idlwave-match-class-arrows #[(limit) "\205�\302\303	\301#\205�\304\305\224\306\"\207" [idlwave-store-inquired-class limit re-search-forward "->" get-text-property 0 idlwave-class] 4])
#@51 Default expressions to highlight in IDLWAVE mode.
(defvar idlwave-font-lock-keywords idlwave-font-lock-keywords-2 (#$ . 40673))
(byte-code "\301B\302\301!\204�\303\301\304\"\210\305\306\307	#\207" [current-load-list idlwave-font-lock-defaults default-boundp set-default ((idlwave-font-lock-keywords idlwave-font-lock-keywords-1 idlwave-font-lock-keywords-2 idlwave-font-lock-keywords-3) nil t ((36 . "w") (95 . "w") (46 . "w") (124 . "w") (38 . "w")) beginning-of-line) put idlwave-mode font-lock-defaults] 4)
#@149 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-comment-line-start-skip "^[ 	]*;" (#$ . 41193))
#@118 Regular expression to find the beginning of a block. The case does
not matter. The search skips matches in comments.
(defconst idlwave-begin-block-reg "\\<\$pro\\|function\\|begin\\|case\\|switch\$\\>" (#$ . 41414))
#@79 Regular expression to find the beginning of a unit. The case does
not matter.
(defconst idlwave-begin-unit-reg "^\\s-*\$pro\\|function\$\\>\\|\\`" (#$ . 41638))
#@194 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-end-unit-reg "^\\s-*\$pro\\|function\$\\>\\|\\'" (#$ . 41808))
#@47 Regular expression to match a continued line.
(defconst idlwave-continue-line-reg "\\<\\$" (#$ . 42090))
#@118 Regular expression to find the end of a block. The case does
not matter. The search skips matches found in comments.
(defconst idlwave-end-block-reg "\\<end\$\\|case\\|switch\\|else\\|for\\|if\\|rep\\|while\$\\>" (#$ . 42202))
#@373 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-matches '(("pro" . "end") ("function" . "end") ("case" . "endcase") ("else" . "endelse") ("for" . "endfor") ("then" . "endif") ("repeat" . "endrep") ("switch" . "endswitch") ("while" . "endwhile")) (#$ . 42438))
#@167 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-block-match-regexp "\\<\$else\\|for\\|then\\|repeat\\|while\$\\>" (#$ . 43053))
#@48 Regular expression matching an IDL identifier.
(defconst idlwave-identifier "[a-zA-Z_][a-zA-Z0-9$_]*" (#$ . 43325))
#@51 Regular expression matching IDL system variables.
(defconst idlwave-sysvar (concat "!" idlwave-identifier) (#$ . 43447))
#@49 Regular expression matching IDL variable names.
(defconst idlwave-variable (concat idlwave-identifier "\\|" idlwave-sysvar) (#$ . 43574))
#@41 Regular expression matching IDL labels.
(defconst idlwave-label (concat idlwave-identifier ":") (#$ . 43718))
(byte-code "\302B\303	\304\305	\306\260!\207" [current-load-list idlwave-identifier idlwave-method-call (lambda (#1=#:defconst-tmp-var) (defconst idlwave-method-call #1#)) "\\s *->" "\$\\s *" "::\$?"] 6)
#@800 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 an equal sign.
(defconst idlwave-statement-match (byte-code "\304\305\306DB\307\310\311\312\313\314\315\316\317\320\321	\322\321\n\323\324\260\306DB\320\321\n\323\325\260\306DB\326\321	\327Q\306DB\257\207" [idlwave-end-block-reg idlwave-variable idlwave-method-call idlwave-identifier (endelse "end\$\\|if\$\\s +else" "end\$\\|if\$\\s +else") end 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) (switch "switch\\>" nil) call "\$" "\$ *= *" "\\s *\\)?" "\\s *(" "\$ *\\($\\|\\$\$\\|\\s *,\\)" assign "\\) *="] 20) (#$ . 44044))
#@30 IDL mode auto fill function.
(defvar idlwave-fill-function 'auto-fill-function (#$ . 45524))
#@35 IDL mode comment indent function.
(defvar idlwave-comment-indent-function 'comment-indent-function (#$ . 45623))
#@73 Character to be inserted for IDL comment indentation.
Normally a space.
(defvar idlwave-comment-indent-char -1 (#$ . 45742))
#@137 Character which is inserted as a last character on previous line by
   \[idlwave-split-line] to begin a continuation line.  Normally $.
(defconst idlwave-continuation-char 36 (#$ . 45874))
(byte-code "\301B\302\303!\207" [current-load-list idlwave-mode-version (lambda (#1=#:defconst-tmp-var) (defconst idlwave-mode-version #1#)) "6.1_em22"] 2)
#@79 Creates a function for abbrev hooks to call `idlwave-check-abbrev' with args.
(defalias 'idlwave-keyword-abbrev '(macro . #[(&rest args) "\301\302\303\304\305\"ED\207" [args quote lambda nil append (idlwave-check-abbrev)] 6 (#$ . 46227)]))
#@193 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.
(defalias 'idlwave-code-abbrev '(macro . #[(&rest args) "\301\302\303\304!\305\306\307\310!FFD\207" [args quote lambda nil prin1-to-string if (idlwave-quoted) (progn (unexpand-abbrev) nil) append] 9 (#$ . 46475)]))
#@26 Keymap used in IDL mode.
(defvar idlwave-mode-map (make-sparse-keymap) (#$ . 46890))
#@48 Syntax table in use in `idlwave-mode' buffers.
(defvar idlwave-mode-syntax-table (make-syntax-table) (#$ . 46981))
(byte-code "\301\302\303#\210\301\304\303#\210\301\305\303#\210\301\306\303#\210\301\307\303#\210\301\310\303#\210\301\311\303#\210\301\312\303#\210\301\313\303#\210\301\314\303#\210\301\315\316#\210\301\317\316#\210\301\320\303#\210\301\321\322#\210\301\323\324#\210\301\325\326#\210\301\327\322#\210\301\330\303#\210\301\331\332#\210\301\333\334#\210\301\335\334#\207" [idlwave-mode-syntax-table modify-syntax-entry 43 "." 45 42 47 94 35 61 37 60 62 39 "\"" 34 92 95 "_" 123 "(}" 125 "){" 36 46 59 "<" 10 ">" 12] 4)
#@64 Syntax table that treats symbol characters as word characters.
(defvar idlwave-find-symbol-syntax-table (copy-syntax-table idlwave-mode-syntax-table) (#$ . 47641))
(byte-code "\301\302\303#\210\301\304\303#\210\301\305\303#\210\301\306\303#\207" [idlwave-find-symbol-syntax-table modify-syntax-entry 36 "w" 95 33 46] 4)
#@45 Execute BODY with a different syntax table.
(defalias 'idlwave-with-special-syntax '(macro . #[(&rest body) "\301\302\303\304\305BB\306BBE\207" [body let ((saved-syntax (syntax-table))) unwind-protect progn (set-syntax-table idlwave-find-symbol-syntax-table) ((set-syntax-table saved-syntax))] 6 (#$ . 47971)]))
#@1291 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)
(defalias 'idlwave-action-and-binding #[(key cmd &optional select) "\306\232\2043�\203�\307\202�\310\311\n!\312\313	!\"\211\203&�\f
\241\210\2022�	\314\313	!
BC\"L\210+\204>�\nG\315U\204J�\306\232\204J�\316\232\205^�\317\n\314\320
<\203Y�
\202[�
CC\"#\207" [select table key table-key cell cmd noaction idlwave-indent-action-table idlwave-indent-expand-table regexp-quote assoc eval append 1 both define-key (lambda nil (interactive) (self-insert-command 1)) idlwave-mode-map] 7 (#$ . 48292)])
(byte-code "\304\305 M\210\306\307\310#\210\306\311\310#\210\306\312\313#\210\306\314\313#\210\306\315\316#\210\306\317\320#\210\306\321\322#\210\306\323\324#\210\306\325\326#\210\306\327\330#\210\306\331\332#\210\306\333\334#\210\306\335\336#\210\306\337\340#\210\306\341\342#\210\306\343\344#\210\306\345\346#\210\306\347\350#\210\306\351\352#\210\306\353\354#\210\306\355\356#\210\306\357\360#\210\306\361\362#\210\306\363\364#\210\306\365\366#\210\306\367\370#\210\306\371\372#\210\306\373\304#\210\374\301!\203$	<\203$	\375\232\204$\303	>\376\303\377	!\"\306\201@�\201A�\n\203\334�\201B�\202\337�\201C�C\"!\201D�#\210\306\201@�\201A�\n\203\372�\201E�\202\375�\201F�C\"!\201G�#\210\306\201@�\201A�\n\203\201H�\202\201I�C\"!\201J�#\210*\306\201K�\201D�#\210\306\201L�\201G�#\210\306\201M�\201J�#\210\306\201N�\201O�#\210\306\201P�\201Q�#\210\306\201R�\201S�#\210\306\201T�\201U�#\210\306\201V�\201W�#\210\306\201X�\201Y�#\210\306\201Z�\201[�#\207" [idlwave-mode-map idlwave-shell-debug-modifiers mods-noshift shift idlwave-debug-map make-sparse-keymap define-key " " idlwave-hard-tab [(control tab)] "'" idlwave-show-matching-quote "\"" "" idlwave-keyboard-quit ";" idlwave-toggle-comment-region "\201" idlwave-beginning-of-subprogram "\205" idlwave-end-of-subprogram "{" idlwave-beginning-of-block "}" idlwave-end-of-block "]" idlwave-close-block [(meta control h)] idlwave-mark-subprogram "\216" idlwave-forward-block "\220" idlwave-backward-block "\204" idlwave-down-block "\225" idlwave-backward-up-block "\215" idlwave-split-line "\221" idlwave-indent-subprogram "" idlwave-previous-statement "" idlwave-next-statement [(shift iso-lefttab)] idlwave-indent-statement "" idlwave-auto-fill-mode "\361" idlwave-fill-paragraph "\363" idlwave-edit-in-idlde "" idlwave-doc-header "
" idlwave-doc-modification "" idlwave-case "" boundp nil delq copy-sequence vector append 67 99 idlwave-shell-save-and-run 66 98 idlwave-shell-break-here 69 101 idlwave-shell-run-region "" "" "" "" idlwave-for "" idlwave-repeat "" idlwave-while "" idlwave-kill-autoloaded-buffers "" idlwave-shell "\f" idlwave-shell-recenter-shell-window "" idlwave-list-buffer-load-path-shadows] 6)
#@72 Run an inferior IDL, with I/O through buffer `(idlwave-shell-buffer)'.
(autoload 'idlwave-shell "idlw-shell" '(#$ . 52356) t)
(autoload 'idlwave-shell-send-command "idlw-shell")
#@55 Run `idlwave-shell' and switch back to current window
(autoload 'idlwave-shell-recenter-shell-window "idlw-shell" '(#$ . 52540) t)
#@38 Save and run buffer under the shell.
(autoload 'idlwave-shell-save-and-run "idlw-shell" '(#$ . 52677) t)
#@33 Set breakpoint in current line.
(autoload 'idlwave-shell-break-here "idlw-shell" '(#$ . 52788) t)
#@29 Compile and run the region.
(autoload 'idlwave-shell-run-region "idlw-shell" '(#$ . 52892) t)
(byte-code "\301\302\303#\210\301\304\305#\210\301\306\307#\210\301\310\311#\210\301\312\313#\210\301\314\315#\210\301\316\315#\210\301\317\315#\210\301\320\321#\210\301\322\323#\210\301\324\325#\210\326\327\330\"\210\326\331\332\"\210\326\333\334\"\210\326\335\336\"\210\326\337\340\"\207" [idlwave-mode-map define-key "" idlwave-find-module "" idlwave-find-module-this-file "?" idlwave-routine-info "\277" idlwave-context-help [(control meta 63)] idlwave-help-assistant-help-with-topic [(meta tab)] idlwave-complete [27 9] "\211" "	" idlwave-update-routine-info "=" idlwave-resolve [(shift mouse-3)] idlwave-mouse-context-help idlwave-action-and-binding "&" idlwave-custom-ampersand-surround "=" (idlwave-expand-equal -1 -1) "<" (idlwave-custom-ltgtr-surround nil) ">" (idlwave-custom-ltgtr-surround 'gtr) "," (idlwave-surround 0 -1 1)] 4)
#@42 Abbreviation table used for IDLWAVE mode
(defvar idlwave-mode-abbrev-table nil (#$ . 53852))
(define-abbrev-table 'idlwave-mode-abbrev-table nil)
#@167 Define-abbrev with backward compatibility.

If NOPREFIX is non-nil, don't prepend prefix character.  Installs into
idlwave-mode-abbrev-table unless TABLE is non-nil.
(defalias 'idlwave-define-abbrev #[(name expansion hook &optional noprefix table) "\306\206�	\n\203�\202�\fP
	F\n\306\307\310\217*\207" [table idlwave-mode-abbrev-table noprefix name idlwave-abbrev-start-char expansion nil (byte-code "\301\302\303\304\"\"\207" [args apply define-abbrev append (0 t)] 5) ((error (byte-code "\301\302\"\207" [args apply define-abbrev] 3))) hook args abbrevs-changed] 5 (#$ . 54005)])
(byte-code "\300\301\302\217\210\303\304\305\306#\210\303\307\305\310#\210\303\311\305\312#\210\303\313\305\314#\210\303\315\305\316#\210\303\317\305\320#\210\303\321\305\322#\210\303\323\305\324#\210\303\325\305\326#\210\303\327\330\331#\210\303\332\333\334#\210\303\335\336\337#\210\303\340\341\342#\210\303\343\344\345#\210\303\346\347\350#\210\303\351\352\353#\210\303\354\355\356#\210\303\357\360\361#\210\303\362\363\364#\210\303\365\366\367#\210\303\370\371\372#\210\303\373\374\372#\210\303\375\376\372#\210\303\377\201@�\372#\210\303\201A�\201B�\372#\210\303\201C�\201D�\372#\210\303\201E�\201F�\372#\210\303\201G�\201H�\372#\210\303\201I�\201J�\372#\210\303\201K�\201L�\201M�#\210\303\201N�\201O�\201P�#\210\303\201Q�\201R�\201S�#\210\303\201T�\201U�\201V�#\210\303\201W�\201X�\201Y�#\210\303\201Z�\201[�\201\\�#\210\303\201]�\201^�\201_�#\210\303\201`�\201a�\201b�#\210\303\201c�\201d�\201e�#\210\303\201f�\201g�\201h�#\210\303\201i�\201j�\201k�#\210\303\201l�\201m�\201n�#\210\303\201o�\201p�\201q�#\210\303\201r�\201s�\201t�#\210\303\201u�\201v�\201w�#\210\303\201x�\201y�\201z�#\210\303\201{�\201|�\201}�#\210\303\201~�\201�\201\200�#\210\303\201\201�\201\202�\201\203�#\210\303\201\204�\201\205�\201\206�#\210\303\201\207�\201\210�\201\211�#\210\303\201\212�\201\213�\201\214�#\210\303\201\215�\201\216�\201\217�#\210\303\201\220�\201\221�\201\222�#\210\303\201\223�\201\224�\201\225�#\210\303\201\226�\201\227�\201\230�#\210\303\201\231�\201\232�\201\233�#\210\303\201\234�\201\235�\201\236�#\210\303\201\237�\201\240�\201\241�#\210\303\201\242�\201\243�\201\244�#\210\303\201\245�\201\246�\201\247�#\210\303\201\250�\201\251�\201\252�#\210\303\201\253�\201\254�\201\255�#\210\303\201\256�\201\257�\201\260�#\210\303\201\261�\201\262�\201\263�#\210\303\201\264�\201\265�\201\266�#\210\303\201\267�\211\201\270�\201\271�$\210\303\333\211\201\272�\201\271�$\210\303\201\273�\211\201\274�\201\271�$\210\303\201\275�\211\201\276�\201\271�$\210\303\336\211\201\277�\201\271�$\210\303\201\300�\211\201\301�\201\271�$\210\303\201\302�\211\201\303�\201\271�$\210\303\366\211\201\304�\201\271�$\210\303\201\305�\211\201\306�\201\271�$\210\303\371\211\201\306�\201\271�$\210\303\376\211\201\306�\201\271�$\210\303\201@�\211\201\306�\201\271�$\210\303\201F�\211\201\306�\201\271�$\210\303\201H�\211\201\306�\201\271�$\210\303\374\211\201\306�\201\271�$\210\303\201\307�\211\201\306�\201\271�$\210\303\201J�\211\201\306�\201\271�$\210\303\201\310�\211\201\311�\201\271�$\210\303\201\312�\211\201\313�\201\271�$\210\303\201\314�\211\201\315�\201\271�$\210\303\201\316�\211\201\317�\201\271�$\210\303\201\320�\211\201\321�\201\271�$\210\303\201\322�\211\201\323�\201\271�$\210\303\201\324�\211\201\325�\201\271�$\210\303\201\326�\211\201\327�\201\271�$\210\303\201\330�\211\201\331�\201\271�$\210\303\201\332�\211\201\333�\201\271�$\210\303\201\334�\211\201\335�\201\271�$\210\303\201\336�\211\201\337�\201\271�$\210\303\201\340�\211\201\341�\201\271�$\210\303\201\342�\211\201\343�\201\271�$\210\303\201`�\211\201\344�\201\271�$\210\303\201\345�\211\201\346�\201\271�$\210\303\201\347�\211\201\350�\201\271�$\210\303\201\351�\211\201\352�\201\271�$\210\303\201\221�\211\201\353�\201\271�$\210\303\201\224�\211\201\354�\201\271�$\210\303\201\355�\211\201\356�\201\271�$\210\303\201\357�\211\201\360�\201\271�$\207" [nil (byte-code "\302\303!\304	#\207" [idlwave-abbrev-start-char idlwave-mode-syntax-table modify-syntax-entry string-to-char "w"] 4) ((error)) idlwave-define-abbrev "c" "" (lambda nil "(idlwave-case)" (if #1=(idlwave-quoted) #2=(progn (unexpand-abbrev) nil) (idlwave-case))) "sw" (lambda nil "(idlwave-switch)" (if #1# #2# (idlwave-switch))) "f" (lambda nil "(idlwave-for)" (if #1# #2# (idlwave-for))) "fu" (lambda nil "(idlwave-function)" (if #1# #2# (idlwave-function))) "pr" (lambda nil "(idlwave-procedure)" (if #1# #2# (idlwave-procedure))) "r" (lambda nil "(idlwave-repeat)" (if #1# #2# (idlwave-repeat))) "w" (lambda nil "(idlwave-while)" (if #1# #2# (idlwave-while))) "i" (lambda nil "(idlwave-if)" (if #1# #2# (idlwave-if))) "elif" (lambda nil "(idlwave-elif)" (if #1# #2# (idlwave-elif))) "ap" "arg_present()" (lambda nil (idlwave-check-abbrev 1)) "b" "begin" (lambda nil (idlwave-check-abbrev 0 t)) "co" "common" (lambda nil (idlwave-check-abbrev 0 t)) "cb" "byte()" (lambda nil (idlwave-check-abbrev 1)) "cx" "fix()" (lambda nil (idlwave-check-abbrev 1)) "cl" "long()" (lambda nil (idlwave-check-abbrev 1)) "cf" "float()" (lambda nil (idlwave-check-abbrev 1)) "cs" "string()" (lambda nil (idlwave-check-abbrev 1)) "cc" "complex()" (lambda nil (idlwave-check-abbrev 1)) "cd" "double()" (lambda nil (idlwave-check-abbrev 1)) "e" "else" (lambda nil (idlwave-check-abbrev 0 t)) "ec" "endcase" idlwave-show-begin "es" "endswitch" "ee" "endelse" "ef" "endfor" "ei" "endif else if" "el" "endif else" "en" "endif" "er" "endrep" "ew" "endwhile" "g" "goto," (lambda nil (idlwave-check-abbrev 0 t)) "h" "help," (lambda nil (idlwave-check-abbrev 0)) "k" "keyword_set()" (lambda nil (idlwave-check-abbrev 1)) "n" "n_elements()" (lambda nil (idlwave-check-abbrev 1)) "on" "on_error," (lambda nil (idlwave-check-abbrev 0)) "oi" "on_ioerror," (lambda nil (idlwave-check-abbrev 0 1)) "ow" "openw," (lambda nil (idlwave-check-abbrev 0)) "or" "openr," (lambda nil (idlwave-check-abbrev 0)) "ou" "openu," (lambda nil (idlwave-check-abbrev 0)) "p" "print," (lambda nil (idlwave-check-abbrev 0)) "pt" "plot," (lambda nil (idlwave-check-abbrev 0)) "re" "read," (lambda nil (idlwave-check-abbrev 0)) "rf" "readf," (lambda nil (idlwave-check-abbrev 0)) "ru" "readu," (lambda nil (idlwave-check-abbrev 0)) "rt" "return" (lambda nil (idlwave-check-abbrev 0)) "sc" "strcompress()" (lambda nil (idlwave-check-abbrev 1)) "sn" "strlen()" (lambda nil (idlwave-check-abbrev 1)) "sl" "strlowcase()" (lambda nil (idlwave-check-abbrev 1)) "su" "strupcase()" (lambda nil (idlwave-check-abbrev 1)) "sm" "strmid()" (lambda nil (idlwave-check-abbrev 1)) "sp" "strpos()" (lambda nil (idlwave-check-abbrev 1)) "st" "strput()" (lambda nil (idlwave-check-abbrev 1)) "sr" "strtrim()" (lambda nil (idlwave-check-abbrev 1)) "t" "then" (lambda nil (idlwave-check-abbrev 0 t)) "u" "until" (lambda nil (idlwave-check-abbrev 0 t)) "wu" "writeu," (lambda nil (idlwave-check-abbrev 0)) "iap" "if arg_present() then" (lambda nil (idlwave-check-abbrev 6)) "ik" "if keyword_set() then" (lambda nil (idlwave-check-abbrev 6)) "ine" "if n_elements() eq 0 then" (lambda nil (idlwave-check-abbrev 11)) "inn" "if n_elements() ne 0 then" (lambda nil (idlwave-check-abbrev 11)) "np" "n_params()" (lambda nil (idlwave-check-abbrev 0)) "s" "size()" (lambda nil (idlwave-check-abbrev 1)) "wi" "widget_info()" (lambda nil (idlwave-check-abbrev 1)) "wc" "widget_control," (lambda nil (idlwave-check-abbrev 0)) "pv" "ptr_valid()" (lambda nil (idlwave-check-abbrev 1)) "ipv" "if ptr_valid() then" (lambda nil (idlwave-check-abbrev 6)) "and" (lambda nil (idlwave-check-abbrev 0 t)) t (lambda nil (idlwave-check-abbrev 0 t)) "break" (lambda nil (idlwave-check-abbrev 0 t)) "case" (lambda nil (idlwave-check-abbrev 0 t)) (lambda nil (idlwave-check-abbrev 0 t)) "continue" (lambda nil (idlwave-check-abbrev 0 t)) "do" (lambda nil (idlwave-check-abbrev 0 t)) (lambda nil (idlwave-check-abbrev 0 t)) "end" idlwave-show-begin-check "endwhi" "eq" (lambda nil (idlwave-check-abbrev 0 t)) "for" (lambda nil (idlwave-check-abbrev 0 t)) "function" (lambda nil (idlwave-check-abbrev 0 t)) "ge" (lambda nil (idlwave-check-abbrev 0 t)) "goto" (lambda nil (idlwave-check-abbrev 0 t)) "gt" (lambda nil (idlwave-check-abbrev 0 t)) "if" (lambda nil (idlwave-check-abbrev 0 t)) "le" (lambda nil (idlwave-check-abbrev 0 t)) "lt" (lambda nil (idlwave-check-abbrev 0 t)) "mod" (lambda nil (idlwave-check-abbrev 0 t)) "ne" (lambda nil (idlwave-check-abbrev 0 t)) "not" (lambda nil (idlwave-check-abbrev 0 t)) "of" (lambda nil (idlwave-check-abbrev 0 t)) "on_ioerror" (lambda nil (idlwave-check-abbrev 0 t)) (lambda nil (idlwave-check-abbrev 0 t)) "pro" (lambda nil (idlwave-check-abbrev 0 t)) "repeat" (lambda nil (idlwave-check-abbrev 0 t)) "switch" (lambda nil (idlwave-check-abbrev 0 t)) (lambda nil (idlwave-check-abbrev 0 t)) (lambda nil (idlwave-check-abbrev 0 t)) "while" (lambda nil (idlwave-check-abbrev 0 t)) "xor" (lambda nil (idlwave-check-abbrev 0 t))] 5)
#@4858 Major mode for editing IDL source files (version 6.1_em22).

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.

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.  It also makes use of pre-compiled or custom-scanned
   user and library catalogs many popular libraries ship with by
   default.  Use \[idlwave-update-routine-info] to update this
   information, which is also used for completion (see item 4).

3. Online IDL Help
   ---------------

\[idlwave-context-help] displays the IDL documentation relevant
   for the system variable, keyword, or routines at point.  A single
   key stroke gets you directly to the right place in the docs.  See
   the manual to configure where and how the HTML help is displayed.

4. Completion
   ----------
   \[idlwave-complete] completes the names of procedures, functions
   class names, keyword parameters, system variables and tags, class
   tags, structure tags, filenames and much more.  It is context
   sensitive and figures out what is expected at point.  Lower case
   strings are completed in lower case, other strings in mixed or
   upper case.

5. 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
   \sw        SWITCH 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].

6. Automatic Case Conversion
   -------------------------
   The case of reserved words and some abbrevs is controlled by
   `idlwave-reserved-word-upcase' and `idlwave-abbrev-change-case'.

7. 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.

8. Hooks
   -----
   Loading idlwave.el runs `idlwave-load-hook'.
   Turning on `idlwave-mode' runs `idlwave-mode-hook'.

9. 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, PDF, and HTML versions of the
   documentation, check IDLWAVE's homepage at `http://idlwave.org'.
   IDLWAVE has customize support - see the group `idlwave'.

10.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}
(defalias 'idlwave-mode #[nil "\306 \210\203\f�\307\310	\"\210\311\n\312\f!\210\313\305!\210\314\313@!\210@\315L\210\313\316!\210\317\313\320!\210\321\313\322!\210\323\313\324!\210\325\313\326!\210\325\313\327!\210\311\313\330!\210\325\331A!\210\332\333!\203n�\334BA\"\210\334CA\"\210\335D\336E\325F\313G!\337L\210\340H\313\341!\210\311!\313\342!\210\343\"\313\344!\210\345$\313\346!\210\311&\313\347!\210\325'\313\350!\210\351(\352\353!\203\266�\354\353\355\"\210\313\356!\210I.\313\357!\210\360/\313\361!\210\3621\313\363!\210\3643\313\365!\210\3665\313\367!\210\3707\354\371\336JK\321\372\311\257\"\210\373\374\375\311\376$\210\373\377\201L�\311\376$\210\373\201M�\201N�\311\376$\210\373\201M�\201O�\311\376$\210\201P� \210\201Q� \210\201R� \210\201S�\201T�!\207" [idlwave-startup-message idlwave-mode-version idlwave-mode-abbrev-table local-abbrev-table idlwave-mode-syntax-table indent-line-function kill-all-local-variables message "Emacs IDLWAVE mode version %s." nil set-syntax-table make-local-variable idlwave-indent-and-action idlwave-comment-hook comment-start-skip ";+[ 	]*" comment-start ";" comment-add 1 require-final-newline t abbrev-all-caps indent-tabs-mode completion-ignore-case use-local-map featurep easymenu easy-menu-add "IDLWAVE" idlwave-mode idlwave-auto-fill "" comment-multi-line paragraph-separate "[ 	\f]*$\\|[ 	]*;+[ 	]*$\\|;+[+=-_*]+$" paragraph-start "[ 	\f]\\|[ 	]*;+[ 	]" paragraph-ignore-fill-prefix parse-sexp-ignore-comments add-log-current-defun-function idlwave-current-routine-fullname boundp tag-table-alist add-to-list ("\\.pro$" . "IDLTAGS") font-lock-defaults font-lock-mark-block-function idlwave-mark-subprogram font-lock-fontify-region-function idlwave-font-lock-fontify-region imenu-create-index-function imenu-default-create-index-function imenu-extract-index-name-function idlwave-unit-name imenu-prev-index-position-function idlwave-prev-index-position hs-special-modes-alist idlwave-forward-block add-hook post-command-hook idlwave-command-hook local kill-buffer-hook idlwave-comment-indent-function idlwave-mode-map idlwave-mode-menu idlwave-mode-debug-menu mode-name major-mode abbrev-mode idlwave-fill-function comment-end idlwave-font-lock-defaults idlwave-begin-block-reg idlwave-end-block-reg idlwave-kill-buffer-update after-save-hook idlwave-save-buffer-update idlwave-revoke-license-to-kill idlwave-setup idlwave-new-buffer-update idlwave-help-check-locations run-mode-hooks idlwave-mode-hook] 8 (#$ . 62913) nil])
(byte-code "\301B\302\301!\204�\303\301\304\"\210\304\207" [current-load-list idlwave-setup-done default-boundp set-default nil] 3)
(defalias 'idlwave-setup #[nil "?\205$�\305	!\204�\306	!\210\307\n	\"\307	\"\307\f	\"\310 \210\311\211\207" [idlwave-setup-done idlwave-config-directory idlwave-user-catalog-file idlwave-xml-system-rinfo-converted-file idlwave-path-file file-directory-p make-directory expand-file-name idlwave-read-paths t] 3])
#@39 Fontify continuation lines correctly.
(defalias 'idlwave-font-lock-fontify-region #[(beg end &optional verbose) "\304\212	b\210\305y\210\306 \211\203�b\210\307 \210`*\310	\n#\207" [pos beg end verbose nil -1 idlwave-is-continuation-line idlwave-beginning-of-statement font-lock-default-fontify-region] 4 (#$ . 70754)])
#@44 Inserts TAB in buffer in current position.
(defalias 'idlwave-hard-tab #[nil "\300c\207" ["	"] 1 (#$ . 71085) nil])
#@156 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'.
(defvar idlwave-command-hook nil (#$ . 71208))
#@143 Command run after every command.
Evaluates a non-nil value of the *variable* `idlwave-command-hook' and
sets the variable to zero afterwards.
(defalias 'idlwave-command-hook #[nil "\203�<\203�\301\302\303\217\210\301\211\207" [idlwave-command-hook nil (eval idlwave-command-hook) ((error))] 3 (#$ . 71417)])
#@527 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.
(defalias 'idlwave-check-abbrev #[(arg &optional reserved) "\306 \203\n�\307 \210\310\207\203�	\203�\311\n`\"\210\2021�\312\232\203(�\313\n`\"\210\2021�\2031�\311\n`\"\210\f\203N�
\314V\203N�\315\316!\203J�\317
TD\202N�
[u\210\320\207" [reserved idlwave-reserved-word-upcase last-abbrev-location idlwave-abbrev-change-case idlwave-abbrev-move arg idlwave-quoted unexpand-abbrev nil upcase-region down downcase-region 0 boundp post-command-hook backward-char t idlwave-command-hook] 3 (#$ . 71737)])
#@56 Returns t if point is inside a comment, nil otherwise.
(defalias 'idlwave-in-comment #[nil "\212`\301 \205�`V*\207" [here idlwave-goto-comment] 2 (#$ . 72775)])
#@197 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.
(defalias 'idlwave-goto-comment #[nil "\304\210`\305 \304\306 \210\307\n\310#\211\203&�\311 \203&�\307\n\310#\211\204�\312	!\210\2058�\311 ?\2058�\313u\210`+\207" [found data eos comment-start nil match-data beginning-of-line search-forward lim idlwave-in-quote store-match-data -1] 5 (#$ . 72946)])
#@40 Should we operate on an active region?
(defalias 'idlwave-region-active-p #[nil "\300\301!\203	�\301 \207\302 \207" [fboundp use-region-p region-active-p] 2 (#$ . 73458)])
#@66 Insert quote and show matching quote if this is end of a string.
(defalias 'idlwave-show-matching-quote #[nil "\304 \211\203&�\305 \204&�\nf	c\210	=\205\"�\212\nb\210\306\307!))\202(�	c*\207" [last-command-event inq bq delim idlwave-in-quote idlwave-in-comment sit-for 1] 3 (#$ . 73636) nil])
#@117 Ensure that the previous word was a token before `idlwave-show-begin'.
An END token must be preceded by whitespace.
(defalias 'idlwave-show-begin-check #[nil "\300 ?\205�\212\301v\210\301u\210\302\303!)\205�\304 \207" [idlwave-quoted -1 looking-at "[ 	\n\f]" idlwave-show-begin] 2 (#$ . 73941)])
#@121 Finds the start of current block and blinks to it for a second.
Also checks if the correct end statement has been used.
(defalias 'idlwave-show-begin #[nil "\306 \307	!\212\310\210`)\310\211\310\211\203 �\311 \210\312\n!\313\314\315\"\205\267� \205\267�\212\nb\210\316\317\320\"\210`\316\321\320\"\210`\211V\203J�
b\210\322\310x\210`
{\fb\210\323 A\211\205\266�?\206\266�\227\227\230\203x�\324\321!\202\266�\227\325\230\203\250�!\203\242�\212b\210\326u\210\327\230\203\231�\226\202\233�c\210\330\331!\210)\324\321!\202\266�\332 \210\333\334#\210\324\321!).\207" [pos last-abbrev-location last-abbrev-marker eol-pos begin-pos end-pos point-marker copy-marker nil idlwave-indent-line marker-position idlwave-check-abbrev 0 t idlwave-block-jump-out -1 nomark 1 "a-zA-Z" idlwave-block-master sit-for "end" -3 "END" delete-char 3 beep message "Warning: Shouldn't this be \"%s\" instead of \"%s\"?" end end1 idlwave-reindent-end idlwave-show-block idlwave-expand-generic-end] 5 (#$ . 74246)])
(defalias 'idlwave-block-master #[nil "\304\212\305\306!\203�\307\310\311!\227	\"\202D�\305\312!\203C�\212\313 \210`)\314\315\n\304#\203,�\316\202?�\314\n\304#\203>�\307\310\317!\227	\"\202?�\320)\202D�\321*\207" [case-fold-search idlwave-block-matches limit idlwave-block-match-regexp t looking-at "pro\\|case\\|switch\\|function\\>" assoc match-string 0 "begin\\>" idlwave-beginning-of-statement re-search-backward ":[ 	]*\\=" ("begin" . "end") 1 ("begin" . "end") nil] 4])
#@61 Terminate the current block with the correct END statement.
(defalias 'idlwave-close-block #[nil "\212\302\303x\210n)\204�\303\304 \210)`\305c\210\306 )\207" [idlwave-show-block last-abbrev-location " 	" nil newline-and-indent "end" idlwave-show-begin] 2 (#$ . 75763) nil])
#@60 Surround &, leaving room for && (which surrround as well).
(defalias 'idlwave-custom-ampersand-surround #[(&optional is-action) "`\306Zf`f\307=	\307=\n\203�\306\202�\310?\205,�\311\312
\204)�\n\205*�\312\f#-\207" [prev-char next-char amp-left amp-right len is-action 2 38 1 idlwave-surround -1] 4 (#$ . 76046)])
#@77 Surround > and < by blanks, leaving room for >= and <=, and considering ->.
(defalias 'idlwave-custom-ltgtr-surround #[(gtr &optional is-action) "`\306Zf`f\n\205�\307=\211\203�\306\202�\310	\311=?\205.�\312\313
\204+�\205,�\313\f#,\207" [prev-char next-char gtr method-invoke len is-action 2 45 1 61 idlwave-surround -1] 5 (#$ . 76373)])
#@514 Surround the LENGTH characters before point with blanks.
LENGTH defaults to 1.
Optional arguments BEFORE and AFTER affect the behavior before and
after the characters (see also description of `idlwave-make-space'):

nil            do nothing
0              force no spaces
integer > 0    force exactly n spaces
integer < 0    at least |n| spaces

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
(defalias 'idlwave-surround #[(&optional before after length is-action) "\205T�\306 ?\205T�	\206�\307\211[u\210\214`\310\311x\210n\2031�\312\313 !\210`\nX\203.�`\n}\210\nb\210\314!\210)\310\311w\210)	u\210\314\f!\210`Sf\315\232\205S�i
V\205S� )\207" [idlwave-surround-by-blank length here before after fill-column idlwave-quoted 1 " 	" nil move-to-column idlwave-calculate-indent idlwave-make-space 32 auto-fill-function] 3 (#$ . 76727)])
#@436 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.
> 0   - exactly N spaces.
< 0   - a minimum of -N spaces, i.e., do not change if there are
        already -N spaces.
0     - no spaces (i.e. remove any existing space).
(defalias 'idlwave-make-space #[(n) "\250\205:�\304\305x\210i`\304\305w\210i\306 \210\307V\203)�\310\\!\210\n\\b\2029�\307W\2059�\310	[\"\210\nZb+\207" [n end-col left start-col " 	" nil delete-horizontal-space 0 idlwave-indent-to] 4 (#$ . 77693)])
#@62 Inserts a newline and indents the current and previous line.
(defalias 'idlwave-newline #[nil "\300 \204�\301 \203�\302 \210\303\304!\210\305 \210\306\307!\210\310 \210\311y\210\310 \207" [idlwave-in-comment idlwave-in-quote beep message "Warning: unbalanced quotes?" newline beginning-of-line 0 idlwave-indent-line nil] 2 (#$ . 78394) nil])
#@64 Compute indent for the beginning of the IDL comment delimiter.
(defalias 'idlwave-comment-hook #[nil "\305!\204�	\203�\305	!\202�\305\306!\203�i\207\305\n!\203:�\212\307\310x\210n)\2038�\311 \211<\2035�@\2026�)\207i\207\307\310x\210n\203F�\312\202H�iT\f]\207" [idlwave-no-change-comment idlwave-begin-line-comment idlwave-code-comment tem comment-column looking-at "^;" " 	" nil idlwave-calculate-indent 0] 3 (#$ . 78744)])
#@289 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.
(defalias 'idlwave-split-line #[nil "\203�\304 \210\305\306 \204R�\307 \211\203>�\n\203/�	f\211\310	\261\210\311u\210\312 \210\313u\210\202U�\314 \210\315\316!\210\317\261\210\202U�`Sf\320\235\204I�\317c\210c\210\312 \210\202U�\321 \210d`Z\311y\210\322 \210d	Zb\210\322 )\207" [abbrev-mode beg idlwave-split-line-string idlwave-continuation-char expand-abbrev nil idlwave-in-comment idlwave-in-quote " + " -1 newline-and-indent 1 beep message "Warning: continuation inside string!!" " " (32 9) indent-new-comment-line idlwave-indent-line] 4 (#$ . 79183) nil])
#@99 Moves point to the beginning of the current program unit.
If NOMARK is non-nil, do not push mark.
(defalias 'idlwave-beginning-of-subprogram #[(&optional nomark) "\302\303	#\207" [idlwave-begin-unit-reg nomark idlwave-find-key -1] 4 (#$ . 80048) nil])
#@92 Moves point to the start of the next program unit.
If NOMARK is non-nil, do not push mark.
(defalias 'idlwave-end-of-subprogram #[(&optional nomark) "\302 \210\303\304	#\207" [idlwave-end-unit-reg nomark idlwave-end-of-statement idlwave-find-key 1] 4 (#$ . 80307) nil])
#@29 Mark current IDL statement.
(defalias 'idlwave-mark-statement #[nil "\301 \210`\302 \210\303\304\305#)\207" [end idlwave-end-of-statement idlwave-beginning-of-statement push-mark nil t] 4 (#$ . 80584) nil])
#@24 Mark containing block.
(defalias 'idlwave-mark-block #[nil "\301 \210\302\303!\210\301 \210`\304 \210\305 \210\306\307\310#)\207" [end idlwave-end-of-statement idlwave-backward-up-block -1 idlwave-backward-block idlwave-beginning-of-statement push-mark nil t] 4 (#$ . 80799) nil])
#@71 Put mark at beginning of program, point at end.
The marks are pushed.
(defalias 'idlwave-mark-subprogram #[nil "\301 \210\302 \210`\303 \210\304\305\306#\210)\307 \207" [beg idlwave-end-of-statement idlwave-beginning-of-subprogram idlwave-forward-block push-mark nil t exchange-point-and-mark] 4 (#$ . 81088) nil])
#@118 Move to beginning of enclosing block if prefix ARG >= 0.
If prefix ARG < 0 then move forward to enclosing block end.
(defalias 'idlwave-backward-up-block #[(&optional arg) "\301[\302\"\207" [arg idlwave-block-jump-out nomark] 3 (#$ . 81412) "p"])
#@43 Go to the beginning of the current block.
(defalias 'idlwave-beginning-of-block #[nil "\300\301\302\"\210\303v\207" [idlwave-block-jump-out -1 nomark 1] 3 (#$ . 81666) nil])
#@43 Go to the beginning of the current block.
(defalias 'idlwave-end-of-block #[nil "\300\301\302\"\210\303v\207" [idlwave-block-jump-out 1 nomark -1] 3 (#$ . 81846) nil])
#@32 Move across next nested block.
(defalias 'idlwave-forward-block #[(&optional arg) "\206�\301\302!\205�\303\304\")\207" [arg 1 idlwave-down-block idlwave-block-jump-out nomark] 3 (#$ . 82020) nil])
#@45 Move backward across previous nested block.
(defalias 'idlwave-backward-block #[nil "\300\301!\205\n�\302\301\303\"\207" [idlwave-down-block -1 idlwave-block-jump-out nomark] 3 (#$ . 82229) nil])
#@104 Go down a block.
With ARG: ARG >= 0 go forwards, ARG < 0 go backwards.
Returns non-nil if successfull.
(defalias 'idlwave-down-block #[(&optional arg) "\305	\306W\203*�\212\307\310\311\"\210`)\312\310\311\n$\211\203\"�\313 \210\202&�\314\315!\210)\202I�\212\307\316\311\"\210`)\312\f\316\311\n$\211\203D�\317 \210\202H�\314\320!\210))\207" [status arg eos idlwave-end-block-reg idlwave-begin-block-reg nil 0 idlwave-block-jump-out -1 nomark idlwave-find-key idlwave-beginning-of-statement message "No nested block before beginning of containing block." 1 idlwave-end-of-statement "No nested block before end of containing block."] 5 (#$ . 82432) "p"])
#@82 Put point at beginning of doc library header, mark at end.
The marks are pushed.
(defalias 'idlwave-mark-doclib #[nil "\304`db\210\305\n\304\306#\205/�\307 \210`\310\304\306#\203)�\311y\210\312	\304\306#\210\313\314!\210\313\315!\210b*\207" [here beg idlwave-doclib-start idlwave-doclib-end nil re-search-backward t beginning-of-line re-search-forward 1 push-mark message "Could not find end of doc library header." "Could not find doc library header start."] 4 (#$ . 83097) nil])
(defalias 'idlwave-current-routine-fullname #[nil "\301 \302\3038@\")\207" [name idlwave-current-routine idlwave-make-full-name 2] 3])
#@46 Return (NAME TYPE CLASS) of current routine.
(defalias 'idlwave-current-routine #[nil "\303 \210\212\304\305!\210\306\307!\205/�\310\311!\227\312\230\203�\313\202�\314\315\310\316!!\317\310\320!	\"\211	E+)\207" [type class name idlwave-routines idlwave-beginning-of-subprogram nomark looking-at "[ 	]*\\<\$pro\\|function\$\\>\\s-+\$\\([a-zA-Z0-9$_]+\$::\\)?\$[a-zA-Z0-9$_]+\$" match-string 1 "pro" pro function idlwave-sintern-class 3 idlwave-sintern-routine-or-method 4] 4 (#$ . 83727)])
#@175 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.
(defalias 'idlwave-beginning-of-statement #[nil "\302=\203�\303	\304\305#\205!�\306\225b\207\212\307y\210\310 )\203�\311 \207\312 \207" [major-mode idlwave-shell-prompt-pattern idlwave-shell-mode re-search-backward nil t 0 -1 idlwave-is-continuation-line idlwave-previous-statement beginning-of-line] 4 (#$ . 84235) nil])
#@181 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.
(defalias 'idlwave-previous-statement #[nil "\303\304y\305U\204
�\306\202C�\307	!\206%�\307\310!\206%�\307\311\n\310Q!\206%�\307\312!\211\2031�\304y\305U\204
�\212\304y\210\313 )\203B�\304y\305U\2041�)\207" [first-statement idlwave-comment-line-start-skip idlwave-label nil -1 0 t looking-at "[ 	]*$" "[ 	]*" "^@" idlwave-is-continuation-line] 4 (#$ . 84741) nil])
#@122 Moves point to the end of the current IDL statement.
If not in a statement just moves to end of line.  Returns position.
(defalias 'idlwave-end-of-statement #[nil "\300 \203�\301y\302U\203�\303 \203��\301y\302U\204\f�\202��\304\210`\207" [idlwave-is-continuation-line 1 0 idlwave-is-comment-or-empty-line nil] 2 (#$ . 85296) nil])
#@121 Moves point to the end of the current IDL statement.
If not in a statement just moves to end of line. Returns position.
(defalias 'idlwave-end-of-statement0 #[nil "\300 \203\f�\301y\302U\204��\303\210`\207" [idlwave-is-continuation-line 1 0 nil] 2 (#$ . 85637) nil])
#@153 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.
(defalias 'idlwave-next-statement #[nil "\303\304 \210\305y\306U\203)�\307	!\206$�\307\310!\206$�\307\311\n\310Q!\206$�\307\312!\211\204�)\207" [last-statement idlwave-comment-line-start-skip idlwave-label nil idlwave-end-of-statement 1 0 looking-at "[ 	]*$" "[ 	]*" "^@"] 4 (#$ . 85912) nil])
#@51 Skip past multiple commands on a line (with `&').
(defalias 'idlwave-skip-multi-commands #[(&optional lim) "`\302\303	\304#\203%�\305\225b\210\306 \203�b\210\202%�`\307Zf\310=\203%�b\210`)\207" [save-point lim re-search-forward ".*&" t 0 idlwave-quoted 2 38] 4 (#$ . 86368)])
#@130 Skip label or case statement element.
Returns position after label.
If there is no label point is not moved and nil is returned.
(defalias 'idlwave-skip-label-or-case #[nil "`\212\303 \210`)\304\305\306\307	$\211\2037�\310\n\"@\311U\2037�\312\313\n{\"\2047�\312\314\n	{\"\2047�\315u\210`\202;�b\210\315+\207" [start eos end idlwave-end-of-statement idlwave-find-key ":" 1 nomark parse-partial-sexp 0 string-match "\\?" "^::" nil] 6 (#$ . 86655)])
#@323 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.
(defalias 'idlwave-start-of-substatement #[(&optional pre) "`\306 \307\310\211\211\311 \210\312 \210`
W\203�\313
!\210``
X\203s�m\204s�`\314 @\211AA@\n@\315\232\203>�T	\203R�\316	\317\320\f$\203R�\307\225b\210\202�\307V\203k�\316\321\317\320\f$\203k�S\307\225b\210\202�\307\322 \210\202�\203{�b\210\323\324!\203\205�\325\326!\210`.\207" [last nst st ifnest eos orig idlwave-end-of-statement 0 nil idlwave-beginning-of-statement idlwave-skip-label-or-case idlwave-skip-multi-commands idlwave-statement-type if idlwave-find-key 1 nomark "\\<else\\>" idlwave-next-statement looking-at "[ 	]*\\$\$[ 	]*\\(;\\|$\$\\)" beginning-of-line 2 pre] 6 (#$ . 87115)])
#@336 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.
(defalias 'idlwave-statement-type #[nil "\212\303\304!\203
�\305y\210\202�\306\307w\210\310\303\n@A@!\204%�\nA\211\204�\n\205.�\311\n\312\225\"+\207" [idlwave-statement-match case-fold-search st looking-at "[ 	]*\\$" 1 " 	" nil t append 0] 3 (#$ . 88125)])
#@927 Pad '=' with spaces.  Two cases: Assignment statement, and keyword
assignment.  Which 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 t then keyword assignment is treated just
like assignment statements.  When nil, spaces are removed for keyword
assignment.  Any other value keeps the current space around the `='.
Limits in for loops are treated as keyword assignment.

Starting with IDL 6.0, a number of op= assignments are available.
Since ambiguities of the form:

r and= b
rand= b

can occur, alphanumeric operator assignment will never be pre-padded,
only post-padded.  You must use a space before these to disambiguate
(not just for padding, but for proper parsing by IDL too!).  Other
operators, such as ##=, ^=, etc., will be pre-padded.

IS-ACTION is ignored.

See `idlwave-surround'.
(defalias 'idlwave-expand-equal #[(&optional before after is-action) "\205\212�\306\307\310\212\311\312u\210\313\314\311#\204 �\313\315\314\311#\203)�\316\310!GT\2027�\313\n\314\311#\2037�\316\310!GT*
\311=\203H�\317	#\202\211�\212\320\311!\210\321 )\212\322\314x\210\323\324 8)\325>\204r�\211@@)\326>\203\201�
\204}�\317\327\211\"\202\210�\311\202\210�\317	#*+\207" [idlwave-surround-by-blank len an-ops non-an-ops case-fold-search idlwave-pad-keyword "\$##\\|\\*\\|\\+\\|-\\|/\\|<\\|>\\|\\^\$\\=" "\\s-\$AND\\|EQ\\|GE\\|GT\\|LE\\|LT\\|MOD\\|NE\\|OR\\|XOR\$\\=" 1 t -1 re-search-backward nil "\$#\$\\=" match-string idlwave-surround idlwave-start-of-substatement idlwave-statement-type "= 	" 2 idlwave-where (function-keyword procedure-keyword) (for pdef) 0 before after what st x] 5 (#$ . 88730)])
#@109 Call `idlwave-indent-line' and do expand actions.
With prefix ARG non-nil, indent the entire sub-statement.
(defalias 'idlwave-indent-and-action #[(&optional arg) "\212\203(�\304\305\306`\307Z]\310#\203(�\311\312!\203(�\313\225b\210	\203%�\314 \210\202(�\315 \210)\n\2045�\2035�\316\n\203<�\317 \207\320\310!\207" [idlwave-expand-generic-end abbrev-mode arg current-prefix-arg re-search-backward "\\<\$end\$\\s-*\\=" 0 10 t looking-at "\$end\$\$[ \n	]\\|\\'\$" 1 expand-abbrev idlwave-show-begin nil idlwave-indent-statement idlwave-indent-line] 5 (#$ . 90495) "p"])
#@219 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.
(defalias 'idlwave-indent-line #[(&optional expand) "\212\306\307x\210n)\203�\306\307w\210\310 \212\311 \210\312	!\203'�\306\307w\210\313\314 !\210\202q�\n\2034�\2034�\315\316\f\"\210\203=�\315\316
\"\210\311 \210\312\317\320Q!\204U�\312\321!\204U�\313\322 !\210\307\210\323 \203q�\324\325!\203i�\326 S\202k�\327 \210))b\210\307\211\223)\207" [mloc idlwave-comment-line-start-skip expand idlwave-do-actions idlwave-indent-expand-table idlwave-indent-action-table " 	" nil point-marker beginning-of-line looking-at idlwave-indent-left-margin idlwave-comment-hook mapc idlwave-do-action "^" "[ 	]*$" "^[ 	]*@" idlwave-calculate-indent idlwave-in-comment fboundp comment-indent-new-line frame-width indent-for-comment idlwave-label fill-column] 4 (#$ . 91080) nil])
#@446 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.  FUNC is always
passed a final argument of 'is-action, so it can discriminate between
being run as an action, or a key binding
(defalias 'idlwave-do-action #[(action) "@A\303 \210\304\n!\205%�	<\203�\305\306	\307\"!\210\202	�	\310!\210\202	�*\207" [action action-routine action-key beginning-of-line idlwave-look-at eval append ('is-action) is-action] 4 (#$ . 92081)])
#@88 Indent from point with spaces until column COL.
Inserts space before markers at point.
(defalias 'idlwave-indent-to #[(col &optional min) "\204�\302\303\304	iZ]\305\"!\207" [min col 0 insert-before-markers make-string 32] 5 (#$ . 92779)])
#@146 Indent the current line to column COL.
Indents such that first non-whitespace character is at column COL
Inserts spaces before markers at point.
(defalias 'idlwave-indent-left-margin #[(col) "\212\301 \210\302 \210\303!)\207" [col beginning-of-line delete-horizontal-space idlwave-indent-to] 2 (#$ . 93029)])
#@44 Indents program unit which contains point.
(defalias 'idlwave-indent-subprogram #[nil "\212\301 \210\302 \210`\303 \210\304\305!\210\306`\307#\210)\304\310!)\207" [beg idlwave-end-of-statement idlwave-beginning-of-subprogram idlwave-forward-block message "Indenting subprogram..." indent-region nil "Indenting subprogram...done."] 4 (#$ . 93345) nil])
#@61 Indent current statement, including all continuation lines.
(defalias 'idlwave-indent-statement #[nil "\212\301 \210`\302 \210\303`\304#*\207" [beg idlwave-beginning-of-statement idlwave-end-of-statement indent-region nil] 4 (#$ . 93705) nil])
#@62 Return appropriate indentation for current line as IDL code.
(defalias 'idlwave-calculate-indent #[nil "\212\306 \210\307!\203�\310\202u�\212\311y\310U\205�\312 )\203!�\313 \202u�\314\212\315 `\203/�\310\202a�\307\316\"\203=�\317 \n\\\202a�\307\316\"\203K�\320 \f\\\202a�\307
\316\"\203_�	b\210\321\311\322\"\210\320 \202a�\317 )\307
!\203r�\\\202t�*)\207" [idlwave-begin-unit-reg beg-prev-pos idlwave-main-block-indent idlwave-begin-block-reg idlwave-block-indent idlwave-end-block-reg beginning-of-line idlwave-look-at 0 -1 idlwave-is-continuation-line idlwave-calculate-cont-indent nil idlwave-previous-statement t idlwave-current-statement-indent idlwave-min-current-statement-indent idlwave-block-jump-out nomark the-indent idlwave-end-offset] 3 (#$ . 93957)])
#@144 Calculate the continuation indent inside a paren group.
Returns a cons-cell with (open . indent), where open is the
location of the open paren
(defalias 'idlwave-calculate-paren-indent #[(beg-reg end-reg close-exp) "\306	\"A@\211\2055�\nb\210\n\203�\f\307 \\\2024�
\203\"�i\2024�\310u\210\311\312!\203/�\313\2024�\314\313w\210iB)\207" [beg-reg end-reg open idlwave-indent-parens-nested idlwave-continuation-indent close-exp parse-partial-sexp idlwave-current-indent 1 looking-at "[ 	$]*\$;.*\$?$" nil " 	"] 4 (#$ . 94745)])
#@360 Calculates the IDL continuation indent column from the previous
statement.  Note that here previous statement usually means the
beginning of the current statement if this statement is a continuation
of the previous line.  Various special types of continuations,
including assignments, routine definitions, and parenthetical
groupings, are treated separately.
(defalias 'idlwave-calculate-cont-indent #[nil "\212\306\307 \210`\212\310 \210`)\311\312!\210\313 	=\203�\nb\202 �`\314	!\f\\\315\211*+\316\315\211,-.	b\210\317\320\215\211,\205I�\321,\322\323\n$+\203c�\324\325!\203^�\326 /0\\Z\202
\326 \202
\327\315-.\317\330\215*\203w�\f\326 \\\202
	\211b\210\331\315w\210\324\332!1\3152\333\334\215+\211+\203\227�+\202
3\335V\203\fb\210\336\337!\204\241�\336\340!\210\324\341!\203\307�\335\225b\210\342 4\343\216\324\344!*?\205\353�i\202\353�\345\346\215\205\353�\347 \206\346�\324\344!\206\346�\212\nb\210\350 \2115@@*\351=?\205\353�i\211*\203\f*
Z3W\203\f+\203*\f\\\202
*\202

.\207" [case-fold-search end-reg beg-last-statement beg-reg idlwave-continuation-indent basic-indent t beginning-of-line idlwave-previous-statement idlwave-start-of-substatement pre line-beginning-position idlwave-min-current-statement-indent nil (("\\<if\\>" . "[ 	]*then") ("\\<\$if\\|end\\(if\$?\\)\\>" . "[ 	]*else") ("\\<\$for\\|while\$\\>" . "[ 	]*do") ("\\<\$repeat\\|end\\(rep\$?\\)\\>" . "[ 	]*until") ("\\<case\\>" . "[ 	]*of")) exit (byte-code "@\211\205�\302	A!\203�\303\304	@\"\210A\211\202�\207" [matchers match looking-at throw exit] 4) idlwave-find-key -1 nomark looking-at "end" idlwave-current-indent ("\\<then\\>" "\\<do\\>" "\\<repeat\\>" "\\<else\\>") (byte-code "b\210\303y\304U\204�\305\306\307\"\210	@\211\205,�\310\311\n\312\313R!\203%�\305\306\314\"\210	A\211\202�\207" [end-reg matchers match -1 0 throw exit nil looking-at ".*" "[ 	]*\\$[ 	]*" "\$;.*\$?$" t] 6) " 	" "\\s)" loop (byte-code "\306	\n#\211\205.�\f\204\"�
\204\"�A\203\"�A	Z\nW\203(�\307\310A\"\210@\202��\207" [beg-reg end-reg close-exp indent-cons idlwave-indent-to-open-paren idlwave-indent-parens-nested idlwave-calculate-paren-indent throw loop basic-indent idlwave-max-extra-continuation-indent] 4) 0 idlwave-look-at "&" "^[ 	]*\$pro\\|function\$" "[ 	]*\$[a-zA-Z0-9.$_]+[ 	]*->[ 	]*\$?[a-zA-Z][:a-zA-Z0-9$_]*[ 	]*\$,\$[ 	]*" match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) "[ 	$]*\$;.*\$?$" assign (byte-code "\301\302!\205�\303\225b\210\304!\204��\305\306\307\"\210\202��\207" [beg-reg looking-at "[^=\n
]*\$=\$[ 	]*" 0 idlwave-what-function throw assign t] 3) idlwave-in-quote idlwave-statement-type for fancy-nonparen-indent fancy-paren-indent cont-re match matchers idlwave-block-indent idlwave-end-offset close-exp indent-cons idlwave-max-extra-continuation-indent save-match-data-internal x] 6 (#$ . 95282)])
#@442 Move to next match of the regular expression KEY-RE.
Matches inside comments or string constants will be ignored.
If DIR is negative, the search will be backwards.
At a successful match, the mark is pushed unless NOMARK is non-nil.
Searches are limited to LIMIT.
Searches are case-insensitive and use a special syntax table which
treats `$' and `_' as word characters.
Return value is the beginning of the match or (in case of failure) nil.
(defalias 'idlwave-find-key #[(key-re &optional dir nomark limit) "\206�\306\307\306V\203�\310\202�\311\312\313 \314\216\315
!\210\212\316\317\215\210+	\2055�\2041�\320 \210	b\210	+\207" [dir found search-func case-fold-search saved-syntax idlwave-find-symbol-syntax-table 0 t re-search-forward re-search-backward nil syntax-table ((set-syntax-table saved-syntax)) set-syntax-table exit (byte-code "	\n\305#\2034�\306 \204�\307\310\311\224\211\"\210\202��\f\311V\203\"�m\204,�\f\311W\203��o\203��\307\310\312\"\210\202��\312\207" [search-func key-re limit found dir t idlwave-quoted throw exit 0 nil] 4) push-mark nomark] 3 (#$ . 98212)])
#@463 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.
(defalias 'idlwave-block-jump-out #[(&optional dir nomark) "\204�\306`\307\306Y\203�d\202�e\306Y\203 �\f\202!�
\310\f\311
Q\212\306W\203=�\312\307$\202G�\310\210\312\307$)\206L�\306Y\203W�\310\210\312\307$\211\203\215�\203\215�\313!\203\215�\306Y\203z�\314v\210\315\307\"\210\312\307$\211\204j�\204\226�\316	!\210\204\241�b\202\251�\306Y\205\251�\314v.\207" [dir here case-fold-search limit idlwave-begin-block-reg idlwave-end-block-reg 0 t nil "\\|" idlwave-find-key looking-at 1 idlwave-block-jump-out push-mark block-limit found block-reg idlwave-begin-unit-reg idlwave-end-unit-reg unit-limit nomark] 6 (#$ . 99314) "P"])
#@46 The minimum indent in the current statement.
(defalias 'idlwave-min-current-statement-indent #[(&optional end-reg) "\303 \210\304 \204�\305 \207\305 \306\307y\310U\2039�\311 \211\204#�\304 \2039�\n\203-�`\nW\2039�\204�	\305 ^\202�\204G�\n\203K�`\nY\203K�	\202O�	\305 ^*\207" [comm-or-empty min end-reg idlwave-beginning-of-statement idlwave-is-continuation-line idlwave-current-indent nil 1 0 idlwave-is-comment-or-empty-line] 2 (#$ . 100467)])
#@120 Return indentation of the current statement.
If in a statement, moves to beginning of statement before finding indent.
(defalias 'idlwave-current-statement-indent #[(&optional last-line) "\203\n�\301 \210\202
�\302 \210\303 \207" [last-line idlwave-end-of-statement idlwave-beginning-of-statement idlwave-current-indent] 1 (#$ . 100928)])
#@134 Return the column of the indentation of the current line.
Skips any whitespace. Returns 0 if the end-of-line follows the whitespace.
(defalias 'idlwave-current-indent #[nil "\212\300 \210\301\302w\210l\203�\303\202�i)\207" [beginning-of-line " 	" nil 0] 2 (#$ . 101275)])
#@149 Tests if current line is continuation line.
Blank or comment-only lines following regular continuation lines (with
`$') count as continuations too.
(defalias 'idlwave-is-continuation-line #[nil "\301\212\302\303!\206\f�\304\305\215*\207" [p nil idlwave-look-at "\\<\\$" loop (byte-code "\301\302!\205�\303y\304=\205�\305\306!\211\203��\307\310\"\210\202��\207" [p looking-at "^[ 	]*\$;.*\$?$" -1 0 idlwave-look-at "\\<\\$" throw loop] 3)] 2 (#$ . 101556)])
#@46 Tests if the current line is a comment line.
(defalias 'idlwave-is-comment-line #[nil "\212\300\301!\210\302\303!)\207" [beginning-of-line 1 looking-at "[ 	]*;"] 2 (#$ . 102026)])
#@46 Tests if the current line is a comment line.
(defalias 'idlwave-is-comment-or-empty-line #[nil "\212\300\301!\210\302\303!)\207" [beginning-of-line 1 looking-at "[ 	]*[;\n]"] 2 (#$ . 102212)])
#@542 Searches current line from current point for 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.
(defalias 'idlwave-look-at #[(regexp &optional cont beg) "`\306\212\203
�\307 \210\202�\310\210`)\310\311 \312\216\313!\210\203)�\314 \210\315\n\306#\211\2039�\316 \204)�*	\204A�\fb\210	,\207" [cont found eos case-fold-search here saved-syntax t idlwave-end-of-statement nil syntax-table ((set-syntax-table saved-syntax)) set-syntax-table idlwave-beginning-of-statement re-search-forward idlwave-quoted idlwave-find-symbol-syntax-table beg regexp] 4 (#$ . 102412)])
#@729 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.
(defalias 'idlwave-fill-paragraph #[(&optional nohang) "\212\306 \210\307\310w\210\311!)\205\245\312\310\211\211\211\211\211\211\211\211!\"#$%\212\313 \210`)\212\314 \210`)\315\n	\"\210`#\306 \210`\316\317\320Q\212\310\210`)\321#\210i$\322\212\306 \210`)`{!\211&\323P!
b\210\311!!\203\200�\311'!\204\200�o\204\200�\324y\210\202h�`
U\204\211�\325y\210`
b\210\311!!\203\246�\311'!\204\246�m\204\246�\325y\210\202\216�\306 \210\311!!\203\267�\311'!\203\272�\324y\210\310\210m\203\307�\326c\210\324u\210\327d`\325#(\204\")\203\"\212\nb\210\330 )\211\203\"%\306 \210`\nV\203C\316*\212\310\210`)\321#\210%iZ\211\"\331V\203#`Y\203#\"\\#\332\"\333\"c\210\324y\210\202\351�`\nV\203C\306 \210%\316*\212\310\210`)\321#\210i^%\324y\210\202\"&\332%$Z\333\"P&\316*\212\310\210`)\321#\210i%]#b\210\212\n\334\n\f\324#{\"\335\n\334\n\f\324#\333\336\310%\210\337\nd	Z\340 \310$\210\n\334\n\f\324#|\210\nb\210\"c\210)n\203\237\307P\310w\210\310\211&.\n\207" [comment-start end start hang first-indent bcl beginning-of-line " 	" nil looking-at 999 backward-paragraph forward-paragraph untabify re-search-forward "^[ 	]*" "+" t regexp-quote "[^;]" -1 1 10 - idlwave-calc-hanging-indent 0 make-string 32 + subst-char-in-region 126 fill-region-as-paragraph current-justification fill-prefix-reg diff here pre indent fill-prefix paragraph-separate nohang idlwave-hanging-indent comment-start-skip] 10 (#$ . 103441) "P"])
#@317 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.
(defalias 'idlwave-calc-hanging-indent #[nil "\203�\212\302\210\303	\212\304 \210`)\305#\205�i	G\\)\207\212\304 \210\306	\212\302\210`)\305#\205-�i)\207" [idlwave-use-last-hang-indent idlwave-hang-indent-regexp nil re-search-backward beginning-of-line t re-search-forward] 4 (#$ . 105645)])
#@296 Called to break lines in auto fill mode.
Only fills non-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.
(defalias 'idlwave-auto-fill #[nil "iX?\205\340�	\203�\212\306 \210\307\n!)\205\340�\310\311 \210\310\312\313 \205'�\f\205'�\314 \315 \210+\212\316\210\311 \210)\212\306 \210\307\n!)\203{�!\205\337�d`Z\212\317y\210\320 )\"#\"\205w�\306 \210\321$\212\310\210`)\322#\210\323 \210\324\"!\210d#Zb*\202\337�\212\316\210\325 )\203\244�\212\306 \210\326\310w\210\327\212\317y\210\330 \331\310w\210`{)\261\210)\311 \202\337�\212\316\210\313 \211\203\272�\f\203\272�\327f\332\261\210\333c\210)\203\335�\f\203\326�\212\306 \210\326\310w\210fc\210)\202\335�\334 \210\335\336!\210\311 )\207" [fill-column idlwave-fill-comment-line-only idlwave-comment-line-start-skip beg idlwave-auto-fill-split-string fill-nobreak-predicate beginning-of-line looking-at nil idlwave-indent-line "." idlwave-in-quote #[nil "iZ\301X\207" [fill-column 5] 2] do-auto-fill 0 -1 idlwave-calc-hanging-indent re-search-forward t delete-horizontal-space idlwave-indent-to idlwave-in-comment " 	" " " idlwave-goto-comment "; " " +" " $" beep message "Warning: continuation inside a string." paragraph-separate idlwave-do-actions idlwave-hanging-indent indent here comment-start-skip] 4 (#$ . 106264)])
#@211 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.
(defalias 'idlwave-auto-fill-mode #[(arg) "	\204�J?\202�\302	!\303V\205�\304L\305\306 !\210\207" [idlwave-fill-function arg prefix-numeric-value 0 idlwave-auto-fill set-buffer-modified-p buffer-modified-p] 3 (#$ . 107755) "P"])
#@211 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.
(defalias 'idlwave-doc-header #[(&optional nomark) "\204�\304 \210	\203�eb\210\202-�\305\210\306 \210\307 \210\310\311!\203-�\312 \210\313y\314V\203-�\315c\210`\203L�@\203@�\316@!\210\202L�A@;\203L�A@c\210\nb)\207" [nomark idlwave-header-to-beginning-of-file pos idlwave-file-header push-mark nil idlwave-beginning-of-subprogram beginning-of-line idlwave-look-at "\\<\$pro\\|function\$\\>" idlwave-end-of-statement 1 0 "\n" insert-file-contents] 2 (#$ . 108205) "P"])
#@38 Default timestamp insertion function
(defalias 'idlwave-default-insert-timestamp #[nil "\301 c\210\302\303 \261\210\304\300!\203�\305\306\261\210\202#�\305\307 \310\311 \306\261\210\312 \210\313c\207" [user-mail-address current-time-string ", " user-full-name boundp " <" ">" user-login-name "@" system-name idlwave-fill-paragraph "\n;\n;		"] 5 (#$ . 108901)])
#@341 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.
(defalias 'idlwave-doc-modification #[nil "\306 \210\307\211\310\n\307\311#\204�eb\210\312\n\307\311#\203_�\313\224\211\203_�\312\307\311#\203_�\313\225\211\203_�b\210\312\f\314P	\311#\203C�\307\210\202V�	b\210\315\210\316
\316\261\210
\317\f\314\261\210\320c\210\321\322!\202b�\323\324!*\207" [beg end idlwave-doclib-start idlwave-doclib-end idlwave-doc-modifications-keyword comment-start push-mark nil re-search-backward t re-search-forward 0 ":" -1 "\n" " " "\n;\n;	" run-hooks idlwave-timestamp-hook error "No valid DOCLIB header"] 5 (#$ . 109274) nil])
#@95 Expand each abbrev occurrence in the region.
Calling from a program, arguments are START END.
(defalias 'idlwave-expand-region-abbrevs #[(start end) "\212	^b\210\304\211\305	\306#+\207" [start end idlwave-abbrev-move idlwave-show-block nil expand-region-abbrevs noquery] 4 (#$ . 110190) "r"])
#@69 Returns t if point is in a comment or quoted string.
nil otherwise.
(defalias 'idlwave-quoted #[nil "\300 \206�\301 \207" [idlwave-in-comment idlwave-in-quote] 1 (#$ . 110493)])
#@245 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.
(defalias 'idlwave-in-quote #[nil "\212`\306\210`\307 \210``\310 \306\211W\203s�\311\312	\313#\203k�\314\224Tb\210`S\315h!\316
!\203?�`\317u\210\202�\320
	\313#\316
!\203Y�\317u\210\320
	\313#\202F�\203e�`S\211\202�`\211\202�``\211\202�\321\f!\210\nV\205~�\n.\207" [start eol bq endq data delim nil beginning-of-line match-data re-search-forward "[\"']" lim 0 char-to-string looking-at 1 search-forward store-match-data found] 5 (#$ . 110679)])
#@69 Determines if the character after point is a pointer dereference *.
(defalias 'idlwave-is-pointer-dereference #[(&optional limit) "`\303f\304=\205�\305 ?\205�\212\303u\210\306\307	\310Q\n\311#))\207" [pos idlwave-idl-keywords limit nil 42 idlwave-in-quote re-search-backward "\$" "\\|[[(*+-/=,^><]\$\\s-*\\*" t] 4 (#$ . 111404)])
#@607 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.  The case of S1 and S2 is
adjusted according to `idlwave-abbrev-change-case'.  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.
(defalias 'idlwave-template #[(s1 s2 &optional prompt noindent) "\306=\203�	\307=\203�\n`\232\203�c\207\310\311!\207\f\312=\203*�
\227\227\2026�\f\2036�
\226\226\212\313 \210`)\314\315\316!\204K�\317\320!\210
c\210\212c\210`)\204d�\321\314#\210;\205o�\322\323\"*\207" [major-mode this-command last-abbrev-location last-abbrev-text idlwave-abbrev-change-case s1 idlwave-shell-mode self-insert-command error "No templates in idlwave-shell" down beginning-of-line nil looking-at "\\s-*\n" open-line 1 indent-region message "%s" s2 end beg noindent prompt] 4 (#$ . 111746)])
#@71 Make STRING have the case required by `idlwave-reserved-word-upcase'.
(defalias 'idlwave-rw-case #[(string) "\203�	\226\207	\207" [idlwave-reserved-word-upcase string] 1 (#$ . 112962)])
#@35 Build skeleton IDL if-else block.
(defalias 'idlwave-elif #[nil "\300\301\302!\301\303!\304#\207" [idlwave-template idlwave-rw-case "if" " then begin\n\nendif else begin\n\nendelse" "Condition expression"] 4 (#$ . 113156) nil])
#@36 Build skeleton IDL case statement.
(defalias 'idlwave-case #[nil "\300\301\302!\301\303!\304#\207" [idlwave-template idlwave-rw-case "case" " of\n\nendcase" "Selector expression"] 4 (#$ . 113390) nil])
#@38 Build skeleton IDL switch statement.
(defalias 'idlwave-switch #[nil "\300\301\302!\301\303!\304#\207" [idlwave-template idlwave-rw-case "switch" " of\n\nendswitch" "Selector expression"] 4 (#$ . 113598) nil])
#@35 Build skeleton for loop statment.
(defalias 'idlwave-for #[nil "\300\301\302!\301\303!\304#\207" [idlwave-template idlwave-rw-case "for" " do begin\n\nendfor" "Loop expression"] 4 (#$ . 113814) nil])
#@35 Build skeleton for loop statment.
(defalias 'idlwave-if #[nil "\300\301\302!\301\303!\304#\207" [idlwave-template idlwave-rw-case "if" " then begin\n\nendif" "Scalar logical expression"] 4 (#$ . 114020) nil])
(defalias 'idlwave-procedure #[nil "\300\301\302!\301\303!\304#\207" [idlwave-template idlwave-rw-case "pro" "\n\nreturn\nend" "Procedure name"] 4 nil nil])
(defalias 'idlwave-function #[nil "\300\301\302!\301\303!\304#\207" [idlwave-template idlwave-rw-case "function" "\n\nreturn\nend" "Function name"] 4 nil nil])
(defalias 'idlwave-repeat #[nil "\300\301\302!\301\303!\304#\207" [idlwave-template idlwave-rw-case "repeat begin\n\nendrep until" "" "Exit condition"] 4 nil nil])
(defalias 'idlwave-while #[nil "\300\301\302!\301\303!\304#\207" [idlwave-template idlwave-rw-case "while" " do begin\n\nendwhile" "Entry condition"] 4 nil nil])
#@127 Return a list of substrings of STRING which are separated by PATTERN.
If PATTERN is omitted, it defaults to "[ \f\t\n\r\v]+".
(defalias 'idlwave-split-string #[(string &optional pattern) "\204�\304\305\306\307	#\203 �	\306\224O\nB\306\225\202\n�	\305O\nB\237*\207" [pattern start parts string "[ \f	\n
]+" nil 0 string-match] 4 (#$ . 114879)])
(defalias 'idlwave-replace-string #[(string replace_string replace_with) "\306	G\307\310\311
	#\211\203\"�	\fO\nQ\306\225\202	�	\nOP\211,\207" [start string last ret_string end replace_string 0 "" nil string-match replace_with] 4])
(defalias 'idlwave-get-buffer-visiting #[(file) "\302\300!\203
�\303\304	!)\207\305\306!\203�\306	!\207\307\310!\207" [find-file-compare-truenames file boundp t get-file-buffer fboundp find-buffer-visiting error "This should not happen (idlwave-get-buffer-visiting)"] 2])
#@131 List of buffer pulled up by idlwave for special reasons.
Buffers in this list may be killed by `idlwave-kill-autoloaded-buffers'.
(defvar idlwave-outlawed-buffers nil (#$ . 115762))
(defalias 'idlwave-find-file-noselect #[(file &optional why) "\303!\206�\304!\n\203�\305\306	\nB\"\210	)\207" [file buf why idlwave-get-buffer-visiting find-file-noselect add-to-list idlwave-outlawed-buffers] 4])
#@451 Kill buffers created automatically by IDLWAVE.
Function prompts for a letter to identify the buffers to kill.
Possible letters are:

f    Buffers created by the command \[idlwave-find-module] or mouse
     clicks in the routine info window.
s    Buffers created by the IDLWAVE Shell to display where execution
     stopped or an error was found.
a    Both of the above.

Buffer containing unsaved changes require confirmation before they are killed.
(defalias 'idlwave-kill-autoloaded-buffers #[nil "\204�\302\303!\207\304\305\306\307\310!\307\311!#!\210\312 \211\313\235\203#�\314\310!\202>�	\315\235\203/�\314\311!\202>�	\316\235\203;�\314\317!\202>�\302\320!)\207" [idlwave-outlawed-buffers c error "No IDLWAVE-created buffers available" princ format "Kill IDLWAVE-created buffers: [f]ind source(%d), [s]hell display(%d), [a]ll ? " idlwave-count-outlawed-buffers find shell read-char (102 6) idlwave-do-kill-autoloaded-buffers (115 19) (97 1) t "Abort"] 7 (#$ . 116169) nil])
#@41 How many outlawed buffers have tag TAG?
(defalias 'idlwave-count-outlawed-buffers #[(tag) "\301\302\303\304\"\"G\207" [idlwave-outlawed-buffers delq nil mapcar #[(x) "A	=\207" [x tag] 2]] 5 (#$ . 117157)])
#@57 Kill all buffers pulled up by IDLWAVE matching REASONS.
(defalias 'idlwave-do-kill-autoloaded-buffers #[(&rest reasons) "\305!\306\307	\211A@\211\203D�\310@!\203<�\311\f>\204&�A\f>\203�\312@!\203�\nT\211\203�\313\"\202�\313\"\202�\314\315\n\211\316U\203Q�\317\202R�\320#+\207" [idlwave-outlawed-buffers list cnt entry reasons copy-sequence 0 nil buffer-live-p t kill-buffer delq message "%d buffer%s killed" 1 "" "s"] 5 (#$ . 117371)])
#@148 Remove BUFFER from the buffers which may be killed.
Killing would be done by `idlwave-do-kill-autoloaded-buffers'.
Intended for `after-save-hook'.
(defalias 'idlwave-revoke-license-to-kill #[nil "p\211	\236\211\203�\303\n	\"\304\305\306\307#*\207" [buf idlwave-outlawed-buffers entry delq remove-hook after-save-hook idlwave-revoke-license-to-kill local] 5 (#$ . 117835)])
(defalias 'idlwave-locate-lib-file #[(file) "\304\211\305\306\215+\207" [idlwave-path-alist dirs dir efile nil exit (byte-code "\211A@@\211\205�\304\305\n	\"\211!\203��\306\307\"\210\202��\207" [dirs dir file efile file-regular-p expand-file-name throw exit] 4)] 3])
(defalias 'idlwave-expand-lib-file-name #[(file) "\204�\301\207\302!\203�\207\303!\207" [file nil file-name-absolute-p idlwave-locate-lib-file] 2])
#@366 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 /.
(defalias 'idlwave-make-tags #[nil "\306\211\211\211\211\211\211\211\211\211\211\211\211\211)*+,-./0\307\310\311\"0\3120\313\"/\314.\315-\316\211,+\316/8\211*\203\317\320*\"\203U�\321)\202X�\306))\203f�*\322*GO*\323*!*\324*!\203\f)\203\244�\325\326!\327\330\306
\306\331\332*\333Q&\210p
q\210\312\334\322d{\335\336#\313\"\fq\210\337
!\210\202\252�*\340PC\316\2118\211\203\375�\317\341	\"\204\362�\342\343\344	\345Q\"\210\325\346!,\327\330\306\306\331.-	Q&\316=\203\340�\316\202\341�\322\\,\347-\nT\2118\211\202\261�\nT\2118\211\204\264�+T\211+/8\211*\202D�+T\211+/8\211*\204G�\325\346!,\316U\203*\337!\210\342\350!.\207" [errbuf item numfiles files save_buffer buffer nil read-string "Tag Directories: " "." idlwave-split-string "[ 	]+" "etags --output=IDLTAGS --language=none --regex='/[\n\\t]*[pP][Rr][Oo][ \\t]+\$[^ \\t,]+\$/' --regex='/[\n\\t]*[Ff][Uu][Nn][Cc][Tt][Ii][Oo][Nn][ \\t]+\$[^ \\t,]+\$/' " " " 0 string-match "^[@]\$.+\$$" t 1 expand-file-name file-directory-p get-buffer-create "*idltags*" call-process "sh" "-c" "find " " -type d -print" idlwave-replace-string "\n" "/*.pro " kill-buffer "/*.pro" "^[ \\t]*$" message "%s" "Tagging " "..." "*idltags-error*" " --append " "" getsubdirs dir numdirs status append cmd directories directory] 15 (#$ . 118650) nil])
#@318 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.
(defalias 'idlwave-toggle-comment-region #[(beg end &optional n) "\203\f�\304	\n\305!#\207\212	b\210\306 \210\307\310w\210\311\312\313Q!\203;�\314\315!\203-�\315	\n\"\202?�\304	\n\316\224\316\225{G[#\202?�\304	\n\")\207" [n beg end comment-start comment-region prefix-numeric-value beginning-of-line " 	\n" nil looking-at "[ 	]*\$" "+\$" fboundp uncomment-region 1] 5 (#$ . 120379) "r\nP"])
(byte-code "\301B\302\301!\204�\303\301\304\"\210\305B\302\305!\204�\303\305\306\"\210\307B\302\307!\204-�\303\307\310\"\210\311B\302\311!\204<�\303\311\312\"\210\313B\302\313!\204K�\303\313\314\"\210\315B\302\315!\204Z�\303\315\316\"\210\301\207" [current-load-list idlwave-sint-routines default-boundp set-default (nil) idlwave-sint-keywords (nil) idlwave-sint-methods (nil) idlwave-sint-classes (nil) idlwave-sint-dirs (nil) idlwave-sint-libnames (nil)] 3)
#@27 Reset all sintern hashes.
(defalias 'idlwave-reset-sintern #[(&optional what) "\306\307!\203\f�\306\310!\204�\311\312!\210\306\310!\204�\313\310\314\"\210\315\211\316\211	:\203@�	@\211@\211J:\2049�\316CL\210	A\211\202$�+\f\317=\204R�\f\320=\204R�
A\204\211�\316\211\316:\203\202�@\211@\nA@J\321\322\323\324$\241\210A\211\202^�,\316\211\f\317=\204\233�\f\325=\204\233�
@?\205\315�\316\211\316:\203\313�@\211@\nA@J\321\322\323\324$\240\210A\211\202\247�,\316)\207" [entries #1=#:--cl-var-- entry var what idlwave-sint-routines fboundp gethash puthash require cl defalias cl-puthash ((idlwave-sint-routines 1000 10) (idlwave-sint-keywords 1000 10) (idlwave-sint-methods 100 10) (idlwave-sint-classes 10 10)) nil t syslib make-hash-table :size :test equal bufsh #2=#:--cl-var-- size idlwave-sint-dirs idlwave-sint-libnames #3=#:--cl-var--] 8 (#$ . 121572)])
(defalias 'idlwave-sintern-routine-or-method #[(name &optional class set) "\203	�\303	\n\"\207\304	\n\"\207" [class name set idlwave-sintern-method idlwave-sintern-routine] 3])
(defalias 'idlwave-sintern #[(stype &rest args) "\302\303\304\305!P!	\"\207" [stype args apply intern "idlwave-sintern-" symbol-name] 5])
(defalias 'idlwave-sintern-routine #[(name &optional set) ";\204�\207\303\227	A\"\206%�\303\227	@\"\206%�\n\203$�\304\305	\n$\207\207" [name idlwave-sint-routines set gethash idlwave-sintern-set routine] 5])
(defalias 'idlwave-sintern-keyword #[(name &optional set) ";\204�\207\303\227	A\"\206%�\303\227	@\"\206%�\n\203$�\304\305	\n$\207\207" [name idlwave-sint-keywords set gethash idlwave-sintern-set keyword] 5])
(defalias 'idlwave-sintern-method #[(name &optional set) ";\204�\207\303\227	A\"\206%�\303\227	@\"\206%�\n\203$�\304\305	\n$\207\207" [name idlwave-sint-methods set gethash idlwave-sintern-set method] 5])
(defalias 'idlwave-sintern-class #[(name &optional set) ";\204�\207\303\227	A\"\206%�\303\227	@\"\206%�\n\203$�\304\305	\n$\207\207" [name idlwave-sint-classes set gethash idlwave-sintern-set class] 5])
(defalias 'idlwave-sintern-dir #[(dir &optional set) "	\235\206�	B\211@\207" [dir idlwave-sint-dirs] 2])
(defalias 'idlwave-sintern-libname #[(name &optional set) "	\235\206�	B\211@\207" [name idlwave-sint-libnames] 2])
(defalias 'idlwave-sintern-set #[(name type tables set) "	\236A\206�\306\211\307=\203�\306\202�\n!
\310=\203#�\nA\202&�\n@\311\227\f#\210\f+\207" [type idlwave-completion-case func name iname set identity preserve sys puthash tables table] 5])
#@66 Sintern a set of keywords (file (key . link) (key2 . link2) ...)
(defalias 'idlwave-sintern-keyword-list #[(kwd-list &optional set) "\301\302A\"\210\207" [kwd-list mapc #[(x) "\302@	\"\240\207" [x set idlwave-sintern-keyword] 4]] 3 (#$ . 124145)])
#@200 Sintern all strings in the rinfo LIST.  With optional parameter
SET: also set new patterns.  Probably this will always have to be t.
If DEFAULT-DIR is passed, it is used as the base of the directory
(defalias 'idlwave-sintern-rinfo-list #[(list &optional set default-dir) "\306\211\211\211\211\211\211\211\211\203\307�@A@A@\3078\3108\3118\312\233
\203a�
9\203P�\313
!\314
\"\315\"\202i�\316\"\n@\nA@\203z�\317!\202}�\307\n8\310\n8;\203\226�\320\";\203\244�\321\"F,\322\323\f\"
\n	\257\f\244\211B\202�\237.	\207" [new call source res kwds class nil 2 3 4 5 symbol-name idlwave-sintern-class idlwave-sintern-method idlwave-sintern-routine file-name-as-directory idlwave-sintern-dir idlwave-sintern-libname mapcar #[(x) "\302	\"\207" [x set idlwave-sintern-keyword-list] 3] type name entry list set default-dir source-lib source-dir source-file source-type] 10 (#$ . 124404)])
#@149 Define a variable and a function to sintern the new type TAG.
This defines the function `idlwave-sintern-TAG' and the variable
`idlwave-sint-TAGs'.
(defalias 'idlwave-new-sintern-type #[(tag) "\305!\211\306P\307\310\nP!\307\311	P!\312L\210\f\313\314\315\316\317\320\321EDC\322\323\324\325EE\326BB\327BBBBEM,\207" [tag name names var func symbol-name "s" intern "idlwave-sint-" "idlwave-sintern-" nil lambda (name &optional set) cond ((not (stringp name)) name) cdr assoc (downcase name) set setq cons (cons (downcase name) name) (name) ((name))] 13 (#$ . 125392)])
#@49 Reset the sintern variable associated with TAG.
(defalias 'idlwave-reset-sintern-type #[(tag) "\301\302\303!\304Q!\305L\207" [tag intern "idlwave-sint-" symbol-name "s" nil] 4 (#$ . 125972)])
#@54 Holds the routine-info obtained by scanning buffers.
(defvar idlwave-system-routines nil (#$ . 126171))
#@54 Holds the routine-info obtained by scanning buffers.
(defvar idlwave-buffer-routines nil (#$ . 126281))
#@54 Holds the routine-info obtained by asking the shell.
(defvar idlwave-compiled-routines nil (#$ . 126391))
#@65 Holds the unresolved routine-info obtained by asking the shell.
(defvar idlwave-unresolved-routines nil (#$ . 126503))
#@54 Holds the procedure routine-info from the user scan.
(defvar idlwave-user-catalog-routines nil (#$ . 126628))
#@75 Holds the procedure routine-info from the .idlwave_catalog library files.
(defvar idlwave-library-catalog-routines nil (#$ . 126744))
#@61 Name of library catalog loaded from .idlwave_catalog files.
(defvar idlwave-library-catalog-libname nil (#$ . 126884))
#@150 Alist with !PATH directories and zero or more flags if the dir has
been scanned in a user catalog ('user) or discovered in a library
catalog ('lib).
(defvar idlwave-path-alist nil (#$ . 127010))
#@53 Like `idlwave-path-alist', but with true filenames.
(defvar idlwave-true-path-alist nil (#$ . 127211))
#@60 Holds the combined procedure/function/method routine-info.
(defvar idlwave-routines nil (#$ . 127320))
#@41 Holds the class names known to IDLWAVE.
(defvar idlwave-class-alist nil (#$ . 127429))
#@54 The history of classes selected with the minibuffer.
(defvar idlwave-class-history nil (#$ . 127522))
(byte-code "\301B\302\301!\204�\303\301\304\"\210\304\207" [current-load-list idlwave-force-class-query default-boundp set-default nil] 3)
#@75 The window configuration just before the completion buffer was displayed.
(defvar idlwave-before-completion-wconf nil (#$ . 127772))
#@48 The last cons cell in the system routine info.
(defvar idlwave-last-system-routine-info-cons-cell nil (#$ . 127911))
#@56 The background process currently updating the catalog.
(defvar idlwave-catalog-process nil (#$ . 128034))
#@142 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.
(defalias 'idlwave-routines #[nil "\2035�\302!\2035�\303!\304\232\203�\305\306!\210\307\310\311!\210\2025�\303!\312\232\2045�\305\313!\210\314 \210\307\315\316\217\210\307	\206=�\310 \210	\207" [idlwave-catalog-process idlwave-routines processp process-status exit message "updating........" nil idlwave-update-routine-info (4) run "Problem with catalog process" beep (kill-process idlwave-catalog-process) ((error))] 3 (#$ . 128147)])
#@126 List of functions which should run after a global rinfo update.
Does not run after automatic updates of buffer or the shell.
(defvar idlwave-update-rinfo-hook nil (#$ . 128738))
#@67 Rescan the previously selected directories. For batch processing.
(defalias 'idlwave-rescan-catalog-directories #[nil "\300\301!\207" [idlwave-update-routine-info (16)] 2 (#$ . 128922)])
#@160 Dispatch another Emacs instance to update the idlwave catalog.
After the process finishes normally, the first access to routine info
will re-read the catalog.
(defalias 'idlwave-rescan-asynchronously #[nil "\306!\203,�\307!\310=\203'�\311\312!\203 �\313\314\315\217\210\316\317!\210\202,�\316\320!\210\202,�\313\321\322\217\210	\203;�	;\203;�\323	!\204?�\316\324!\210\nP\325\326\327\330!\326\331\332\333\257\334\335\336\313\f
%\211#\337#\340\"\210\341\342!+\207" [idlwave-catalog-process idlwave-user-catalog-file invocation-directory invocation-name emacs args processp process-status run yes-or-no-p "A catalog-updating process is running.  Kill it? " nil (kill-process idlwave-catalog-process) ((error)) error "Process killed, no new process started" "Quit" (kill-process idlwave-catalog-process) ((error)) file-regular-p "No catalog has been produced yet" "-batch" "-l" expand-file-name "~/.emacs" "idlwave" "-f" "idlwave-rescan-catalog-directories" apply start-process "idlcat" set-process-sentinel #[(pro why) "\304\305\"\205�\306\211\306\307 \206�\310\311!\207" [why idlwave-routines idlwave-system-routines idlwave-catalog-process string-match "finished" nil idlwave-start-load-rinfo-timer idlwave-update-routine-info (4)] 4] message "Background job started to update catalog file" process] 8 (#$ . 129116) nil])
#@1194 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 chosen user catalog tree.
With three prefix args, dispatch asynchronous process to do the update.

If NO-CONCATENATE is non-nil, don't pre-concatenate the routine info
lists, but instead wait for the shell query to complete and
asynchronously finish updating routine info.  This is set
automatically when called interactively.  When you need routine
information updated immediately, leave NO-CONCATENATE nil.
(defalias 'idlwave-update-routine-info #[(&optional arg no-concatenate) "\306\307!\203\f�\307!\204�\306\310!\203�\310!\203�\311!\210	\312\232\203%�\313 \207	\314\232\203/�\315\316!\207	\2069�\n\2069�?	\206?�\n\317\211 !\317\"\320\321N\203X�\322\320\321\317#\210\202m�\320\f\203a�\316\202k�#\204j�\316\202k�\323!\210\n\203�\324 \210\f\203\212�\325
!\210\202\212�\f\203\207�\325
!\210\324 \210\306\326!\205\222�\326 \211$\205\232�%&	\203\262�$\203\257�\327'\330\331#\210\202\262�\332 \210&\203\274�(\204\301�\333\317\334\"\210&\205\316�\335\336!\210\337\317\316\",\207" [idlwave-load-rinfo-idle-timer arg idlwave-buffer-case-takes-precedence idlwave-routines load override-idle fboundp itimerp timerp cancel-timer (64) idlwave-rescan-asynchronously (16) idlwave-create-user-catalog-file t nil idlwave-reset-sintern done-by-idle put bufsh idlwave-update-buffer-routine-info idlwave-load-all-rinfo idlwave-shell-is-running idlwave-shell-send-command (progn (idlwave-shell-get-path-info) (idlwave-scan-library-catalogs)) hide idlwave-scan-library-catalogs idlwave-concatenate-rinfo-lists run-hooks message "Querying the shell" idlwave-shell-update-routine-info idlwave-buffer-routines idlwave-compiled-routines idlwave-unresolved-routines idlwave-system-routines shell-is-running idlwave-query-shell-for-routine-info ask-shell idlwave-shell-path-query no-concatenate] 5 (#$ . 130460) "P\np"])
(byte-code "\301B\302\301!\204�\303\301\304\305\306\"\"\210\307B\302\307!\204!�\303\307\306\"\210\306\207" [current-load-list idlwave-load-rinfo-steps-done default-boundp set-default make-vector 6 nil idlwave-load-rinfo-idle-timer] 5)
(defalias 'idlwave-start-load-rinfo-timer #[nil "\304\305!\203\f�\305!\204�\304\306!\203�\306!\203�\307!\210\310\311\312\"\312\n\205<�\n\247\205<�\n\313\232?\205<�?\205<�\312\314\315\217\207" [idlwave-load-rinfo-idle-timer idlwave-load-rinfo-steps-done idlwave-init-rinfo-when-idle-after idlwave-routines fboundp itimerp timerp cancel-timer make-vector 6 nil 0 (byte-code "\302\303\304#\211\207" [idlwave-init-rinfo-when-idle-after idlwave-load-rinfo-idle-timer run-with-idle-timer nil idlwave-load-rinfo-next-step] 4) ((error))] 3])
#@20 Obsolete variable.
(defvar idlwave-library-routines nil (#$ . 133854))
(defalias 'idlwave-load-system-routine-info #[nil "\301\302\303#\205\n�\304 ?\205�\305\306\307\217\207" [idlwave-xml-system-rinfo-converted-file load noerror nomessage idlwave-xml-system-routine-info-up-to-date nil (idlwave-convert-xml-system-routine-info) ((error (byte-code "\302\303\304#?\205!�	\203�\305\306!\207\305\307!\210\302\310\303\304#?\205!�\305\311!\207" [idlwave-xml-system-rinfo-converted-file idlwave-system-routines load noerror nomessage message "Failed to load converted routine info, using old conversion." "Failed to convert XML routine info, falling back on idlw-rinfo." "idlw-rinfo" "Could not locate any system routine information."] 4)))] 4])
(defalias 'idlwave-xml-system-routine-info-up-to-date #[nil "\303\304\305\306 \"!\304\307\"\310\n	\"*\207" [dir catalog-file idlwave-xml-system-rinfo-converted-file file-name-as-directory expand-file-name "help/online_help" idlwave-sys-dir "idl_catalog.xml" file-newer-than-file-p] 4])
(byte-code "\301B\302\301!\204�\303\301\304\"\210\304\207" [current-load-list idlwave-system-class-info default-boundp set-default nil] 3)
#@112 Alist of system variables and the associated structure tags.
Gets set in cached XML rinfo, or `idlw-rinfo.el'.
(defvar idlwave-system-variables-alist nil (#$ . 135035))
#@49 Alist of system variables and their help files.
(defvar idlwave-executive-commands-alist nil (#$ . 135210))
(byte-code "\301B\302\301!\204�\303\301\304\"\210\304\207" [current-load-list idlwave-help-special-topic-words default-boundp set-default nil] 3)
(defalias 'idlwave-shorten-syntax #[(syntax name &optional class) "\302\303\304	\237\305#)\207" [case-fold-search syntax t mapconcat #[(x) "\303	\"\203�\304\305\306\211	$\202��\n\203&�\303\n	\"\203&�\304\305\306\211	$\202�	\207" [name x class string-match replace-match "%s" t] 5] " or "] 4])
(defalias 'idlwave-xml-create-class-method-lists #[(xml-entry) "A@\306	\236A\303	\236A\211AA)\307\310\211\310\211 !\310\211\"\310\211\310\211#$\310%
\203B
@\211$<\203;$@%$A@\"%\311=\203~�\306\"\236A\303\"\236A&\211'\312\230\203s�&\312\230\204z�'#B#*\202;%\313=\203\337�\306\"\236A\303\"\236A\314\"\236A\315\230\316\"\236A\315\230\317\"\236A\315\230\f&'\f\203\275�'&DB\203\314�'&DB\203\333�'&DB-\202;%\320=\203;\306\"\236A\321\n\322P\"\203\323\324\325\307#\210\202-\321\n\326P\"\203\323\327\325\307#\210\202-\321\n\330P\"\203,\323\331\325\307#\210\202-\310!\332$\n!# \244 
A\211\204=�#\203T\n\333\334#\"\303DE\202Y\n\303DD\211 .B\207" [xml-entry nameblock class link x params name t nil SUPERCLASS "None" PROPERTY get "Yes" set init METHOD string-match "::Init" put init-props matched "::GetProperty" get-props "::SetProperty" set-props idlwave-xml-create-rinfo-list append (inherits) case-fold-search class-entry method methods-entry extra-kwds props inherits pelem ptype plink pname] 7])
(defalias 'idlwave-xml-create-rinfo-list #[(xml-entry &optional class extra-kws) "A@\302	\236A\303	\236A\211AA)\306\307\310\"\"\311#\310\211$%\310\211&'\310\211()\310\211*+\310\211,-\310.\203T�\312.\313P\n\"\203T�\n\314\225\310O
\203=
@\211)<\2036)@*)A@,*\315=\203\317�\302,\236A$\312\316$\"\203\213�\317\320\311\310$$$\321,\236A$/\"0\312\322\"\203\246�\314\202\273�\312\323\"\203\262�\324\202\273�\312\325\"\205\273�\326101/01HBI\210+\2026*\327=\2036\302,\236A%\303,\236A&\312\330%\"\203,\331\324%\"\203\370�\332\202\371�\333'%\314\225\310O%'2\3102:\203(2@\211%P&D(B(2A\2112\202*\2026%&D(B(
A\211\204X�\"\326H\203M\n\324\310OB\202\2423\203Y(3\244(\334(\"(\314\2114\324X\203\237\"4H\203\226\335\n4\314=\203~\336\202\337.\340\341\"4H\n.#\257(\"-B-4T\2114\202d)-.\207" [xml-entry nameblock name link x params make-vector 3 nil t string-match "::" 0 SYNTAX "-&gt;" replace-match "->" type "^pro" "^fun" 1 "^exec" 2 KEYWORD "^\\[XY\$Z?\$\\]" match-string ("X" "Y" "Z") ("X" "Y") idlwave-rinfo-group-keywords append pro fun (system) idlwave-shorten-syntax syntax-vec case-fold-search syntax kwd klink pref-list kwds pelem ptype entry props result class #1=#:--cl-arg1-- #2=#:--cl-var-- #3=#:--cl-var-- #4=#:--cl-var-- extra-kws idx] 11])
(defalias 'idlwave-rinfo-group-keywords #[(kwds master-link) "\306\211\211\211\211\211\n\203J�\n@\307
A@!\211A\f@
@\310\f\n\"\211\2039�	
B	AB\241\210\202A�\f
BD\nB\nA\211\n\204�\310\n\"\211\203h�\n@=\203_�\n\202o�\311\n\"B\202o�C\nB\211.\207" [master-elt block linkfiles anchor link kwd nil idlwave-split-link-target assoc delq kwds master-link] 7])
(defalias 'idlwave-convert-xml-clean-statement-aliases #[(aliases) "\306\211\n\306:\2039�@\307\f
\"\211\2032�\310\311\3128\211\"\2032�\312\233\313\314\315\211	$\240\210\202�A\211\202	�,\306\207" [entry syntax aliases #1=#:--cl-var-- x idlwave-system-routines nil assoc string-match " +or +" 4 replace-match ", " t] 7])
(defalias 'idlwave-convert-xml-clean-routine-aliases #[(aliases) "\306\211\211\211\211

\306
:\203N�
@\307A\310\"\211\203E�\311A\"\211\204;�A	B\211B\n\312@\nA\"\241\210
A\211
\202�*\306:\203y�@\211A\203p�A@@B
BA\211\202W�*
\306:\203\272�@\311A\"\211\203\261�\f>\204\241�\fB\313\f!\211@\240\210\fBA\211\202\202�*\306:\203\334�@\314\"\210A\211\202\303�.\306\207" [all-parts parts new remove-list alias aliases nil split-string "/" assoc delete copy-sequence delq #1=#:--cl-var-- x #2=#:--cl-var-- #3=#:--cl-var-- idlwave-system-routines #4=#:--cl-var--] 5])
(defalias 'idlwave-convert-xml-clean-sysvar-aliases #[(aliases) "\306\211\211\211\211
\n\306\n:\203J�\n@\307A\f\"\211\203A�\f>\2041�\fB\310\f!\211@\240\210\f\fB\f\nA\211\n\202�*
\306
:\203l�
@\311\f\"\210
A\211
\202S�.\306\207" [all-parts parts new remove-list alias aliases nil assoc copy-sequence delq #1=#:--cl-var-- x idlwave-system-variables-alist #2=#:--cl-var--] 5])
(defalias 'idlwave-xml-create-sysvar-alist #[(xml-entry) "A@\302	\236A\211\306\307\n\"\210\310\225\311O\304	\236A\211AA)\312\311\211\311\211\311\203p�@\211<\203g�@A@\313=\203g�\302\236A\314\304\236A!ABBA\211\2048�\315\311\205|�\316B\304\fDE\".\207" [xml-entry nameblock name sysvar link x string-match "^ *!" 0 nil t FIELD idlwave-split-link-target delq tags params case-fold-search pelem ptype props fields] 7])
(byte-code "\301B\302\301!\204�\303\301\304\"\210\304\207" [current-load-list idlwave-xml-routine-info-file default-boundp set-default nil] 3)
(defalias 'idlwave-save-routine-info #[nil "\205l�	\306\307\310!!\311\216r\nq\210\312\f\313\314\315 \316\260c\210\317\320\"c\210\321c\210\322
p\"\210\323c\210\324c\210\322p\"\210\323c\210\325c\210\322p\"\210\323c\210\326c\210\322p\"\210\323c\210\327c\210\322p\"\210\323c)r\nq\210\330\331\211\331\332%\210,\207" [idlwave-xml-routine-info-file idlwave-xml-system-rinfo-converted-file #1=#:temp-buffer #2=#:temp-file idlwave-mode-version idlwave-system-routines get-buffer-create generate-new-buffer-name " *temp file*" ((byte-code "\301!\203\n�\302!\210\301\207" [#1# buffer-name kill-buffer] 2)) ";; *-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*\n;; IDLWAVE Routine Information File (IDLWAVE version " ")\n;; Automatically generated from source file:\n;;  " "\n;; on " current-time-string "\n;; Do not edit." format "\n(setq idlwave-xml-routine-info-file \n    \"%s\")" "\n(setq idlwave-system-routines\n    '" prin1 ")" "\n(setq idlwave-system-variables-alist\n    '" "\n(setq idlwave-system-class-info\n    '" "\n(setq idlwave-executive-commands-alist\n    '" "\n(setq idlwave-help-special-topic-words\n    '" write-region nil 0 idlwave-system-variables-alist idlwave-system-class-info idlwave-executive-commands-alist idlwave-help-special-topic-words] 7])
#@93 Convert XML supplied IDL routine info into internal form.
Cache to disk for quick recovery.
(defalias 'idlwave-convert-xml-system-routine-info #[nil "\306\307\310\311 \"!\307\312\"\313\314\211\314\211.\314\211/0\314\21112\314\21134\314\21156\3147\315	!\204A�\316\317	\"\210\202L�\320	!\204L�\316\321	\"\210\322\323!\210\324	!\322\325!\210\326\f\236\211\204d�\316\327!\210\330\fA@\236A7\f\2118AA)\211G\2110\331\245\3149\322\332!\210\314\211:;\314\211<=\314>\f\203\206\f@.\fA\nT.<\203\222�.@/.A@\333\n
\"\313U\203\303�\322\334\n\335_0\245\"\210/\336=\203\337\236\2112\203\343�\340\236A2AB4B4\202\222�\341.!\2113A<\203\371�:3\244:\202\222�3=B=\202\222�/\342=\203\"\343.!\2111@<B<:1A\244:\202\222�/\344=\203T\340\236A\345\236AB>B>\337\236\2112\203\222�2A5\235\204\222�2A5B5\202\222�/\346=\203\222�\337\236A\2112\203z\340\236A\347\314O2\347\314OB6B6\202\222�\350.!;B;\202\222�\3514!\210\3525!\210\3536!\210	9\354 \210\322\355!.\207" [dir catalog-file elem-cnt props rinfo msg-cnt file-name-as-directory expand-file-name "help/online_help" idlwave-sys-dir "idl_catalog.xml" 0 nil file-exists-p error "No such XML routine info file: %s" file-readable-p "Cannot read XML routine info file: %s" message "Reading XML routine info..." xml-parse-file "Reading XML routine info...done" CATALOG "Failed to parse XML routine info" version 20 "Converting XML routine info..." mod "Converting XML routine info...%2d%%" 100 ROUTINE alias_to name idlwave-xml-create-rinfo-list CLASS idlwave-xml-create-class-method-lists STATEMENT link SYSVAR 1 idlwave-xml-create-sysvar-alist idlwave-convert-xml-clean-routine-aliases idlwave-convert-xml-clean-statement-aliases idlwave-convert-xml-clean-sysvar-aliases idlwave-save-routine-info "Converting XML routine info...done" elem type nelem class-result alias routines routine-aliases statement-aliases sysvar-aliases version-string x idlwave-xml-routine-info-file idlwave-system-routines idlwave-system-variables-alist idlwave-system-class-info idlwave-executive-commands-alist idlwave-help-special-topic-words] 5 (#$ . 141923) nil])
(defalias 'idlwave-load-rinfo-next-step #[nil "\305\306\307\215\205�\310\311!\203�\312 \202�\313\314\312#\211*\207" [idlwave-load-rinfo-steps-done arr inhibit-quit idlwave-init-rinfo-when-idle-after idlwave-load-rinfo-idle-timer t exit (byte-code "\305H\204�\306\307!\210\310 \210\306\311!\210\305\312I\210\313\314\312\"\210\315H\204B�\306\316!\210\317\312!\210\320\317\321\312#\210\322	\323\"\306\324!\210\315\312I\210\313\314\312\"\210\325H\204\201�\n;\203w�\326\n!\203w�\306\327!\210\330\331\332\217\210\333\303!\203s�\203s�\330\334 \210\306\335\n\"\210\202w�\306\336!\210\325\312I\210\313\314\312\"\210\337H\204\242�\f\203\230�\306\340!\210\322\f\323\"\306\341!\210\337\312I\210\313\314\312\"\210\342H\204\266�\343\344!\210\342\312I\210\313\314\312\"\210\345H?\205\321�\306\346!\210\347 \210\306\350!\210\345\312I\210\313\314\330\"\207" [arr idlwave-system-routines idlwave-user-catalog-file idlwave-library-routines idlwave-user-catalog-routines 0 message "Loading system routine info in idle time..." idlwave-load-system-routine-info "Loading system routine info in idle time...done" t throw exit 1 "Normalizing idlwave-system-routines in idle time..." idlwave-reset-sintern put done-by-idle idlwave-sintern-rinfo-list sys "Normalizing idlwave-system-routines in idle time...done" 2 file-regular-p "Loading user catalog in idle time..." nil (load-file idlwave-user-catalog-file) ((error (byte-code "\300\301\302\"\207" [throw exit nil] 3))) boundp ding "Outdated user catalog: %s... recreate" "Loading user catalog in idle time...done" 3 "Normalizing user catalog routines in idle time..." "Normalizing user catalog routines in idle time...done" 4 idlwave-scan-library-catalogs "Loading and normalizing library catalogs in idle time..." 5 "Finishing initialization in idle time..." idlwave-routines "Finishing initialization in idle time...done"] 4) sit-for 1 idlwave-load-rinfo-next-step run-with-idle-timer nil] 4])
(defalias 'idlwave-load-all-rinfo #[(&optional force) "\204\n�	\306H\204
�\307 \210\204�	\310H\204$�\311\312!\210\313\n\314\"\311\315!\210\n\2032�\316\n!\211GS\233
;\203q�\317
!\203q�\320\321\322\217\210\323\324!\203U�\203U�\320\325\326
\"\210\320\204b�	\327H\204q�\311\330!\210\313 \314\" \311\331!\210\204{�	\332H\204�\333\334!\210\335\336!\207" [force idlwave-load-rinfo-steps-done idlwave-system-routines idlwave-routines idlwave-last-system-routine-info-cons-cell idlwave-user-catalog-file 0 idlwave-load-system-routine-info 1 message "Normalizing idlwave-system-routines..." idlwave-sintern-rinfo-list sys "Normalizing idlwave-system-routines...done" copy-sequence file-regular-p nil (byte-code "\204\n�	\303H\204�\304\n!\210\303\207" [force idlwave-load-rinfo-steps-done idlwave-user-catalog-file 2 load-file] 2) ((error)) boundp idlwave-library-routines error "Outdated user catalog: %s... recreate" 3 "Normalizing user catalog routines..." "Normalizing user catalog routines...done" 4 idlwave-scan-library-catalogs "Loading and normalizing library catalogs..." run-hooks idlwave-after-load-rinfo-hook idlwave-true-path-alist idlwave-user-catalog-routines] 4])
(defalias 'idlwave-update-buffer-routine-info #[nil "\304	\305=\203�\306\307!\210\310\311\312 !!\202.�	\204�\304\202.�\n\313=\203.�\306\314!\210\310pC!\315\316\"\211)\207" [res idlwave-scan-all-buffers-for-routine-info major-mode idlwave-buffer-routines nil t message "Scanning all buffers..." idlwave-get-routine-info-from-buffers reverse buffer-list idlwave-mode "Scanning current buffer..." idlwave-sintern-rinfo-list set] 3])
#@61 Put the different sources for routine information together.
(defalias 'idlwave-concatenate-rinfo-lists #[(&optional quiet run-hook) "\306	\n\f$\241\210\307\f\204 �\310\311	G\nGG\fG
G&\210\205(�\312\313!\207" [idlwave-last-system-routine-info-cons-cell idlwave-buffer-routines idlwave-compiled-routines idlwave-library-catalog-routines idlwave-user-catalog-routines idlwave-class-alist append nil message "Routines Found: buffer(%d) compiled(%d) library(%d) user(%d) system(%d)" run-hooks idlwave-update-rinfo-hook quiet idlwave-system-routines run-hook] 7 (#$ . 147658)])
#@48 Return the class alist - make it if necessary.
(defalias 'idlwave-class-alist #[nil "\206/�\305\n\305:\203,�@\306\f8\211\203%�	\236\204%�	CBA\211\202�*)\207" [idlwave-class-alist class idlwave-routines #1=#:--cl-var-- x nil 2] 3 (#$ . 148245)])
(defalias 'idlwave-save-buffer-update #[nil "\300\301!\207" [idlwave-update-current-buffer-info save-buffer] 2])
(defalias 'idlwave-kill-buffer-update #[nil "\300\301!\207" [idlwave-update-current-buffer-info kill-buffer] 2])
(defalias 'idlwave-new-buffer-update #[nil "\300\301!\207" [idlwave-update-current-buffer-info find-file] 2])
#@76 Update idlwave-routines for current buffer.  Can run from after-save-hook.
(defalias 'idlwave-update-current-buffer-info #[(why) "\305=\205�	\306=\204�\n	>\205�\205�\f\205�\307\310\311\217\207" [major-mode idlwave-auto-routine-info-updates why idlwave-scan-all-buffers-for-routine-info idlwave-routines idlwave-mode t nil (byte-code "\302\303\304 	\305=?\205�\306\307pC!\310\"\211\"\210\311\312!\210)\207" [routines why nil idlwave-replace-buffer-routine-info buffer-file-name kill-buffer idlwave-sintern-rinfo-list idlwave-get-routine-info-from-buffers set idlwave-concatenate-rinfo-lists quiet] 5) ((error))] 3 (#$ . 148847)])
#@70 Cut the part from FILE out of `idlwave-buffer-routines' and add NEW.
(defalias 'idlwave-replace-buffer-routine-info #[(file new) "\305\211\203)�\306\307\n@8!=\203�\n\305\240\210\310\202\"�	\203\"�\305\nA\211\204�\311\f\312\305\"\"\211*\207" [idlwave-buffer-routines found list file new nil idlwave-routine-source-file 3 t append delq] 6 (#$ . 149493)])
#@76 Call `idlwave-get-buffer-routine-info' on idlwave-mode buffers in BUFFERS.
(defalias 'idlwave-get-routine-info-from-buffers #[(buffers) "\306\211\211\212\211A@\211\203*�\nq\210\f\307=\203�
\203�\306\310\311\217\211	B\202�)\312\313	\"+\207" [res routine-lists buf buffers major-mode buffer-file-name nil idlwave-mode (idlwave-get-buffer-routine-info) ((error)) apply nconc] 4 (#$ . 149863)])
#@73 Scan the current buffer for routine info.  Return (PRO-LIST FUNC-LIST).
(defalias 'idlwave-get-buffer-routine-info #[nil "\304\305\211\305\212\214~\210eb\210\306\307\305\304#\203+�\310\311\224\312 \210`\"\313\n!\211	B\202�*	,\207" [case-fold-search routine-list string entry t nil re-search-forward "^[ 	]*\$pro\\|function\$[ 	]" buffer-substring-no-properties 0 idlwave-end-of-statement idlwave-parse-definition] 5 (#$ . 150271)])
#@28 Parse a module definition.
(defalias 'idlwave-parse-definition #[(string) "\306\307\211\211\211\211\211.\310\311/\"\203#�\312\313\306\211/$/\202�\310\314/\"\2037�\312\315\306\307/$/\202#�\310\316/\"\203K�\312\317\306\307/$/\2027�\310\320/\"\203n�\321\225\322\323/\"\227\324\224\203h�\322\324/\"\322\325/\"\310\326/
#\203\225�\321\225\324\224\203\212�\322\323/\"	B\202n�\322\323/\"B\202n�\237\327	\330\"\f\n\331\232\203\250�\332\202\251�\333\334\335!\204\267�\336\337 D\202\300�\340\341\337 !0\342F\n\343\230\203\312�\344\202\313�\313\203\323�\345\202\324�\313\346\205\365�\n\343\230\203\343�\347\202\344�\350\351\352\350#\n\343\230\203\363�\353\202\364�\313QR	\205�\307\354\355	\"B\257.\207" [class keywords type args name start t nil string-match ";.*" replace-match "" "\$[^a-zA-Z0-9$_]\$\\$[ 	]*\n" "\\1 " "\n" " " "\\<\$pro\\|function\$\\>\\s-+\$\\([a-zA-Z0-9$_]+\$::\\)?\$[a-zA-Z0-9$_]+\$" 0 match-string 1 3 4 ",\\s-*\$[a-zA-Z][a-zA-Z0-9$_]*\\|\\(_ref\$?_extra\\)\\s-*\$=\$?" sort #[(a b) "\227	\227\231\207" [a b] 2] "pro" pro fun boundp idlwave-scanning-lib buffer buffer-file-name user file-name-nondirectory "UserLib" "function" "Result = " "Obj ->[%s::]" "%s" "(" ", " mapconcat identity ")" mapcar list case-fold-search string idlwave-scanning-lib-dir] 12 (#$ . 150719)])
#@61 Return the syslib directory, or a dummy that never matches.
(defalias 'idlwave-sys-dir #[nil "\203\f�\301\230\204\f�\207\302\303!\206�\304\207" [idlwave-system-directory "" getenv "IDL_DIR" "@@@@@@@@"] 2 (#$ . 152065)])
#@386 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-user-catalog-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.
(defalias 'idlwave-create-user-catalog-file #[(&optional arg) ";\203�\306!\203�\307\310\311\217\210;\203,�G\312V\203,�\313\314!!\203,�\315!\316\230\2030�\317\320!\210	\203B�\n\203B�\n@:\203B�\321\n!\207\203\\�\322\f\203T�\323\324\325!\"\202Z�\323\326\325!\"!\207\327\330!\210\331\332!\210\333
\334\335#\207" [idlwave-user-catalog-file arg idlwave-path-alist idlwave-library-path idlwave-true-path-alist idlwave-shell-path-query file-regular-p nil (load-file idlwave-user-catalog-file) ((error)) 0 file-accessible-directory-p file-name-directory file-name-nondirectory "" error "`idlwave-user-catalog-file' does not point to a file in an accessible directory" idlwave-scan-user-lib-files idlwave-display-user-catalog-widget mapcar #[(x) "\303\304!	\"\211\203�\nAB\202�C)\207" [x idlwave-true-path-alist path-entry assoc file-truename] 4] idlwave-expand-path list message "Asking the shell for IDL path..." require idlw-shell idlwave-shell-send-command (idlwave-user-catalog-command-hook nil) hide] 5 (#$ . 152296) "P"])
(defalias 'idlwave-user-catalog-command-hook #[(&optional arg) "\203�\302	!\207\303\304!\210\305\306\307\"\210\310	!\207" [arg idlwave-path-alist idlwave-scan-user-lib-files idlwave-shell-get-path-info no-write idlwave-scan-library-catalogs "Locating library catalogs..." no-load idlwave-display-user-catalog-widget] 3])
(byte-code "\301B\302\303!\207" [current-load-list idlwave-user-catalog-widget-help-string (lambda (#1=#:defconst-tmp-var) (defconst idlwave-user-catalog-widget-help-string #1#)) "This is the front-end to the creation of the IDLWAVE user catalog.\nPlease select the directories on IDL's search path from which you\nwould like to extract routine information, to be stored in the file:\n\n             %s\n\nIf this is not the correct file, first set variable\n`idlwave-user-catalog-file', and call this command again.\n\nN.B. Many libraries include pre-scanned catalog files\n(\".idlwave_catalog\").  These are marked with \"[LIB]\", and need\nnot be scanned.  You can scan your own libraries off-line using the\nperl script `idlwave_catalog'.\n\nAfter selecting the directories, choose [Scan & Save] to scan the library\ndirectories and save the routine info.\n\n"] 2)
#@71 Create the widget to select IDL search path directories for scanning.
(defalias 'idlwave-display-user-catalog-widget #[(dirs-list) "\305\306!\210\305\307!\210\204�\310\311!\210\312\313\314!!\210\315\313\314!!\210\316 \210\317\303!\210\320\321	\n\"!\210\322\323\324\325\326$\210\320\327!\210\322\323\324\330\331$\210\320\327!\210\322\323\324\332\333$\210\320\327!\210\322\323\324\334\335$\210\320\327!\210\322\323\324\336\337$\210\320\340!\210\320\341!\210\342\322\343\344\345\346\347\350\"\"\351\352\353\354\347\355\"&	\356\357#\210\320\360!\210\361\f!\210\362 \210eb\210\363 \207" [dirs-list idlwave-user-catalog-widget-help-string idlwave-user-catalog-file idlwave-widget widget-keymap require widget wid-edit error "Don't know IDL's search path" kill-buffer get-buffer-create "*IDLWAVE Widget*" switch-to-buffer kill-all-local-variables make-local-variable widget-insert format widget-create push-button :notify idlwave-widget-scan-user-lib-files "Scan & Save" "  " idlwave-delete-user-catalog-file "Delete File" (lambda (&rest ignore) (let ((path-list (widget-get idlwave-widget :path-dirs))) (mapcar (lambda (x) (unless (memq 'lib (cdr x)) (idlwave-path-alist-add-flag x 'user))) path-list) (idlwave-display-user-catalog-widget path-list))) "Select All Non-Lib" (lambda (&rest ignore) (let ((path-list (widget-get idlwave-widget :path-dirs))) (mapcar (lambda (x) (idlwave-path-alist-remove-flag x 'user)) path-list) (idlwave-display-user-catalog-widget path-list))) "Deselect All" #[(&rest ignore) "\300p!\207" [kill-buffer] 2] "Quit" "\n\n" "Select Directories: \n" apply checklist :value delq nil mapcar #[(x) "\301A>\205	�@\207" [x user] 2] :greedy t :tag "List of directories" #[(x) "\301\302A>\203�\303@P\202�@D\207" [x item lib "[LIB] "] 3] widget-put :path-dirs "\n" use-local-map widget-setup delete-other-windows] 12 (#$ . 154917) nil])
(defalias 'idlwave-delete-user-catalog-file #[(&rest ignore) "\301\302\303\"!\205�\304!\210\305\306\"\207" [idlwave-user-catalog-file yes-or-no-p format "Delete file %s " delete-file message "%s has been deleted"] 4])
(defalias 'idlwave-widget-scan-user-lib-files #[(&rest ignore) "\306	!\307	\310\"\211\311\f\211A@\211\203>�\312
A>\203'�\313
@P\202)�
@\n\235\2036�\314
\315\"\210\202�\316
\315\"\210\202�\317!-\207" [idlwave-widget widget selected-dirs path-alist this-path-alist dir-entry widget-value widget-get :path-dirs nil lib "[LIB] " idlwave-path-alist-add-flag user idlwave-path-alist-remove-flag idlwave-scan-user-lib-files] 4])
(defalias 'idlwave-scan-user-lib-files #[(path-alist) "\306\307\310\211\310\211\310\2113456\31078\203!�\311 \210\212\312\313!q\210\314 \210\3155!\211A@\211\203\217�\316\fA>\203/�\f@\211\317\f!\203/�\320\f\321\322#
\211A@\2113\203/�\3233!\203Q�\3243!\204s�\325\3263\"\210\202Q�\325\3273\"\210\330 \210\3313\332\"\210\333\334pC!4\"4\202Q�)\325\335!\210\336\313!\210\336\312\337!!\210\340\3109:\341;!\210*\342\343!\203\271�#\203\271�\343\340!\210\330 \210\344c\210\345\346\347 \"c\210\350c\210p<\351\3524\"\210)\345\353\354;!\"c\210eb\210\355\340!\210\336p!\210.\325\356!\210\325\3574G;#\210\360\361!\210\362\306!\207" [idlwave-scanning-lib idlwave-scanning-lib-dir idlwave-completion-case dirs-alist dir files t "" nil idlwave-write-paths get-buffer-create "*idlwave-scan.pro*" idlwave-mode reverse user file-directory-p directory-files full "\\.[pP][rR][oO]\\'" file-regular-p file-readable-p message "Skipping %s (no read permission)" "Scanning %s..." erase-buffer insert-file-contents visit append idlwave-get-routine-info-from-buffers "Creating user catalog file..." kill-buffer "*IDLWAVE Widget*" 0 find-file boundp font-lock-mode ";; IDLWAVE user catalog file\n" format ";; Created %s\n\n" current-time-string "\n(setq idlwave-user-catalog-routines\n    '(" mapc #[(x) "\301c\210\302!\210db\207" [x "\n    " prin1] 2] "))\n\n;;; %s ends here\n" file-name-nondirectory save-buffer "Creating user catalog file...done" "Info for %d routines saved in %s" sit-for 2 idlwave-update-routine-info file idlwave-user-catalog-routines path-alist idlwave-path-alist idlwave-true-path-alist idlwave-auto-write-paths auto-mode-alist font-lock-maximum-size idlwave-user-catalog-file standard-output] 5])
(defalias 'idlwave-read-paths #[nil ";\205�\301!\205�\302\303\304\217\207" [idlwave-path-file file-regular-p nil (byte-code "\301\302\211\211$\207" [idlwave-path-file load t] 5) ((error))] 3])
(defalias 'idlwave-write-paths #[nil "\205H�	\205H�\306\307\310\f!\210*\311\305!\203�
\203�\305\306!\210\312 \210\313c\210\314\315\316 \"c\210\314\317	\"c\210\320c\210p\321\322\"\210)\323c\210\324\306!\210\325p!\207" [idlwave-path-alist idlwave-system-directory auto-mode-alist font-lock-maximum-size idlwave-path-file font-lock-mode 0 nil find-file boundp erase-buffer ";; IDLWAVE paths\n" format ";; Created %s\n\n" current-time-string "\n(setq idlwave-system-directory \"%s\")\n" "\n(setq idlwave-path-alist\n    '(" mapc #[(x) "\301c\210\302!\210db\207" [x "\n      " prin1] 2] "))\n" save-buffer kill-buffer standard-output] 3 nil nil])
(defalias 'idlwave-expand-path #[(path &optional default-dir) "\305\306!\210\307\211\211\211A@\211\203H�	\310\311O\312\230\211\203$�	\311\307O\2033�\313	!\2043�\314	\f\"\203A�\315\316	!\n\"\202\n�	\nB\202\n�\305\317!\210\n\237+\207" [recursive dir path1 path default-dir message "Expanding path..." nil 0 1 "+" file-name-absolute-p expand-file-name append idlwave-recursive-directory-list "Expanding path...done"] 3])
(defalias 'idlwave-recursive-directory-list #[(dir) "C\305\211\211\f\211A@\211\203@�\306!\203	�\307\310\311#\237	\211A@\211\2039�\306\n!\203 �\312\n!\fB\202 �B\202	�,\207" [dir files file path1 path nil file-directory-p directory-files t "[^.]" file-name-as-directory] 4])
#@388 Scan for library catalog files (.idlwave_catalog) and ingest.

All directories on `idlwave-path-alist' (or `idlwave-library-path'
instead, if present) are searched.  Print MESSAGE-BASE along with the
libraries being loaded, if passed, and skip loading/normalizing if
NO-LOAD is non-nil.  The variable `idlwave-use-library-catalogs' can
be set to nil to disable library catalog scanning.
(defalias 'idlwave-scan-library-catalogs #[(&optional message-base no-load) "\205V�	\203�\306	!\202�\307\310\n\"\311\312\211\211\211\211\203-�\313!\210\211A@\211\203A�\314\315\215\210\202-�\204I�\205T�\313\316P!.\207" [idlwave-use-library-catalogs idlwave-library-path idlwave-path-alist all-routines catalog flags idlwave-expand-path mapcar car "" nil message continue (byte-code "\306\307\310\"\211!\203P�\n\204:�\311\211\312\313\217\210\f\203+�
\230\204+�\314\315\f
P\"\210
\203:�\316\317\320#\"\203P�\321\"\211\203P�\322\323\"\210\311\207" [dir catalog no-load idlwave-library-catalog-routines message-base idlwave-library-catalog-libname file-readable-p expand-file-name ".idlwave_catalog" nil (byte-code "\301\302\211\211$\207" [catalog load t] 5) ((error (byte-code "\300\301\302\"\207" [throw continue t] 3))) message "%s" append idlwave-sintern-rinfo-list sys assoc idlwave-path-alist-add-flag lib old-libname all-routines idlwave-path-alist dir-entry] 6) "done" dir dir-entry old-libname dirs message-base no-load idlwave-library-catalog-routines] 7 (#$ . 160747)])
#@46 The idl programs to get info from the shell.
(defconst idlwave-routine-info\.pro "\n;; START OF IDLWAVE SUPPORT ROUTINES\npro idlwave_print_safe,item,limit\n  catch,err\n  if err ne 0 then begin\n     print,'Could not print item.'\n     return\n  endif\n  if n_elements(item) gt limit then $\n     print,item[0:limit-1],'<... truncated at ',strtrim(limit,2),' elements>' $\n  else print,item\nend\n\npro idlwave_print_info_entry,name,func=func,separator=sep\n  ;; See if it's an object method\n  if name eq '' then return\n  func    = keyword_set(func)\n  methsep = strpos(name,'::')\n  meth    = methsep ne -1\n\n  ;; Get routine info\n  pars   = routine_info(name,/parameters,functions=func)\n  source = routine_info(name,/source,functions=func)\n  nargs  = pars.num_args\n  nkw    = pars.num_kw_args\n  if nargs gt 0 then args = pars.args\n  if nkw   gt 0 then kwargs = pars.kw_args\n\n  ;; Trim the class, and make the name\n  if meth then begin\n      class = strmid(name,0,methsep)\n      name  = strmid(name,methsep+2,strlen(name)-1)\n      if nargs gt 0 then begin\n          ;; remove the self argument\n          wh = where(args ne 'SELF',nargs)\n          if nargs gt 0 then args = args[wh]\n      endif\n  endif else begin\n      ;; No class, just a normal routine.\n      class = \"\"\n  endelse\n\n  ;; Calling sequence\n  cs = \"\"\n  if func then cs = 'Result = '\n  if meth then cs = cs + 'Obj -> [' + '%s' + '::]'\n  cs = cs + '%s'\n  if func then cs = cs + '(' else if nargs gt 0 then cs = cs + ', '\n  if nargs gt 0 then begin\n      for j=0,nargs-1 do begin\n          cs = cs + args[j]\n          if j lt nargs-1 then cs = cs + ', '\n      endfor\n  end\n  if func then cs = cs + ')'\n  ;; Keyword arguments\n  kwstring = ''\n  if nkw gt 0 then begin\n      for j=0,nkw-1 do begin\n          kwstring = kwstring + ' ' + kwargs[j]\n      endfor\n  endif\n\n  ret=(['IDLWAVE-PRO','IDLWAVE-FUN'])[func]\n\n  print,ret + ': ' + name + sep + class + sep + source[0].path  $\n    + sep + cs + sep + kwstring\nend\n\npro idlwave_routine_info,file\n  on_error,1\n  sep = '<@>'\n  print,'>>>BEGIN OF IDLWAVE ROUTINE INFO (\"' + sep + '\" IS THE SEPARATOR)'\n  all = routine_info()\n  fileQ=n_elements(file) ne 0\n  if fileQ then file=strtrim(file,2)\n  for i=0L,n_elements(all)-1L do begin\n     if fileQ then begin\n        if (routine_info(all[i],/SOURCE)).path eq file then $\n           idlwave_print_info_entry,all[i],separator=sep\n     endif else idlwave_print_info_entry,all[i],separator=sep\n  endfor\n  all = routine_info(/functions)\n  for i=0L,n_elements(all)-1L do begin\n     if fileQ then begin\n        if (routine_info(all[i],/FUNCTIONS,/SOURCE)).path eq file then $\n           idlwave_print_info_entry,all[i],separator=sep,/FUNC\n     endif else idlwave_print_info_entry,all[i],separator=sep,/FUNC\n  endfor\n  print,'>>>END OF IDLWAVE ROUTINE INFO'\nend\n\npro idlwave_get_sysvars\n  on_error,1\n  catch,error_status\n  if error_status ne 0 then begin\n      print, 'Cannot get info about system variables'\n  endif else begin\n      help,/brief,output=s,/system_variables  ; ? unsafe use of OUTPUT=\n      s = strtrim(strjoin(s,' ',/single),2)   ; make one line\n      v = strsplit(s,' +',/regex,/extract)    ; get variables\n      for i=0L,n_elements(v)-1 do begin\n          t = ['']                            ; get tag list\n          a=execute('if n_tags('+v[i]+') gt 0 then t=tag_names('+v[i]+')')\n          print, 'IDLWAVE-SYSVAR: '+v[i]+' '+strjoin(t,' ',/single)\n      endfor\n  endelse\nend\n\npro idlwave_get_class_tags, class\n  res = execute('tags=tag_names({'+class+'})')\n  if res then print,'IDLWAVE-CLASS-TAGS: '+class+' '+strjoin(tags,' ',/single)\nend\n;; END OF IDLWAVE SUPPORT ROUTINES\n" (#$ . 162274))
#@62 Remembers if the routine info procedure is already compiled.
(defvar idlwave-idlwave_routine_info-compiled nil (#$ . 166041))
(defalias 'idlwave-shell-compile-helper-routines #[(&optional wait) "\203\f�\305\306\307!!\2046�\212\310\306\311!!q\210\312 \210	c\210\313\314!\210)\315\316\n\317Q\320\321$\210\315\322\323\306\307!\"\320\321#\210\324\315\322\325\f\211#\320\321#\207" [idlwave-idlwave_routine_info-compiled idlwave-routine-info\.pro idlwave-shell-temp-pro-file wait idlwave-shell-temp-rinfo-save-file file-readable-p idlwave-shell-temp-file rinfo idlwave-find-file-noselect pro erase-buffer save-buffer 0 idlwave-shell-send-command ".run \"" "\"" nil hide format "save,'idlwave_print_safe','idlwave_routine_info','idlwave_print_info_entry','idlwave_get_class_tags','idlwave_get_sysvars',FILE='%s',/ROUTINES" t "if execute(\"_v=routine_info('idlwave_routine_info',/SOURCE)\") eq 0 then restore,'%s' else if _v.path eq '' then restore,'%s'"] 5])
#@76 Query the shell for routine_info of compiled modules and update the lists.
(defalias 'idlwave-shell-update-routine-info #[(&optional quiet run-hooks wait file) "\304!\210\305\306\307	\203�\310	\311Q\202�\312\"\313\314\315\nEE\316$\207" [wait file quiet run-hooks idlwave-shell-compile-helper-routines idlwave-shell-send-command format "idlwave_routine_info%s" ",'" "'" "" progn (idlwave-shell-routine-info-filter) idlwave-concatenate-rinfo-lists hide] 7 (#$ . 167002)])
(byte-code "\301B\302\301!\204�\303\301\304\"\210\305B\302\305!\204�\303\305\304\"\210\306B\302\306!\204-�\303\306\304\"\210\307B\302\307!\204<�\303\307\304\"\210\304\207" [current-load-list idlwave-completion-help-info default-boundp set-default nil idlwave-completion-help-links idlwave-current-obj_new-class idlwave-complete-special] 3)
#@1834 Complete a function, procedure or keyword name at point.
This function is smart and figures out what can be 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

As a special case, the universal argument C-u forces completion of
function names in places where the default would be a keyword.

Two prefix argument, C-u C-u, prompts for a regexp by which to limit
completion.

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.
(defalias 'idlwave-complete #[(&optional arg module class) "\306 \210\203�\250\203�\307\232\203�9\203�\310	\n#\202!�\311 \3128\313\232\314\232\2054�\315\316!C@	\203M�\317\320	\"\203M�	\321\211\224O	\321\225\322O\204h�A\242\323=\203h�\324\325!\203h�AB\326 \202V\327 \203x�\f\302=\204x�\330 \202VC\203\204�\331C!\206V\f\204\216�\332\333!\202V\f\302=\203\234�\334D\335 \202V\f\336=\203\3378E\340E\341\"F\342E!?\205\272�\343F!G\344F\203\306�\345\202\307�\346PH\341I\347\322IF\322G\257D\350\336F\203\345�\351\202\346�\347\306 \352\353\354HF\203\353\355F\356=\203\377�\357\202F\"\202\346#H\360\361&-\202V\f\362=\203\206\3378E\340E\363\"F\342E!?\205/\343F!G\364F\203;\345\202<\346PH\363I\347\322IF\322G\257D\350\362F\203Z\351\202[\347\306 \352\353\354HF\203z\353\355F\356=\203t\357\202vF\"\202{\346#H\360\361&-\202V\f\365>\203\230\366\232\203\230\367\337!\202V\f\370=\203d\3378\211J@\211KL\341I\340J\341\"\211F\343F!G\353\371\n\203\306\345\202\307\346\"H\372K\341\n\306 $\211M\205\337\337M8@\373=;\374M\375\"NM\204\374\n\356=\204\374\332\376\377\nK\"\"\210\201Q�K\341\nNG;&\211N\204\332\201R�\377\nK\"\"\210\201S�KIFMG\257D\350\201S�\211N\322\353\201T�\377\nK\"\201U�N\235\204P\201V�N\235\203V\201W�\202W\346#H\201X�&.\202V\f\201Y�=\203Q\3378\211J@\211KL\363I\340J\363\"\211F\343F!G\353\201Z�\n\203\226\345\202\227\346\"H\372K\363\n\306 $\211M\205\257\337M8@\373=;\374M\375\"N\322OM\204\321\n\356=\204\321\332\201[�\377\nK\"\"\210\201Q�K\363\nNG;&N\n\204\371K\226\201\\�\230\203\371P\201]�P\202\376\377\nK\"ON\204
\332\201^�O\"\210\201S�KIF\322G\257D\350\201S�\211N\322\353\201_�O\201`�N\235\204=\201a�N\235\203C\201W�\202D\346#H\201X�&.\f\202V\332\201b�!,\207" [arg module class where-list what idlwave-force-class-query idlwave-routines (16) idlwave-make-force-complete-where-list idlwave-where 2 (4) (16) read-string "Completion Regexp: " string-match "::" 0 nil idlwave-display-completion-list get-buffer-window "*Completions*" idlwave-scroll-completions idlwave-in-quote idlwave-complete-filename idlwave-call-special error "Nothing to complete here" (class) idlwave-complete-class procedure 3 idlwave-determine-class pro idlwave-explicit-class-listed idlwave-all-class-inherits "procedure" "-method" "" routine idlwave-complete-in-buffer method idlwave-selector format "Select a %s name%s" " (class is %s)" t "unknown" idlwave-attach-method-classes idlwave-add-file-link-selector function fun "function" (procedure-keyword function-keyword) (4) idlwave-complete procedure-keyword "procedure%s-keyword" idlwave-best-rinfo-assq system idlwave-entry-keywords do-link "Nothing known about procedure %s" idlwave-make-full-name completion-regexp-list last-command this-command idlwave-complete-special idlwave-completion-help-info cw-list class-selector super-classes isa type-selector where name method-selector entry list msg-name idlwave-current-obj_new-class idlwave-fix-keywords "No keywords available for procedure %s" keyword "Select keyword for procedure %s%s" ("_EXTRA") ("_REF_EXTRA") " (note _EXTRA)" idlwave-attach-keyword-classes function-keyword "function%s-keyword" "Nothing known about function %s" "OBJ_NEW" "::Init (via OBJ_NEW)" "No keywords available for function %s" "Select keyword for function %s%s" ("_EXTRA") ("_REF_EXTRA") "This should not happen (idlwave-complete)"] 13 (#$ . 167835) "P"])
#@408 List of special completion functions.
These functions are called for each completion.  Each function must
check if its own special completion context is present.  If yes, it
should use `idlwave-complete-in-buffer' to do some completion and
return t.  If such a function returns t, *no further* attempts to
complete other contexts will be done.  If the function returns nil,
other completions will be tried.
(defvar idlwave-complete-special nil (#$ . 173193))
(defalias 'idlwave-call-special #[(functions &rest args) "\304\211\305\306\215+\207" [functions ret fun funcs nil exit (byte-code "\211A@\211\203�\304	\n\"\211\203��\305\306\"\210\202��\307\207" [funcs fun args ret apply throw exit nil] 3)] 3])
(defalias 'idlwave-make-force-complete-where-list #[(what &optional module class) "\306\307	\n\"\310\n!\311\232\203�\312\313\314\315\316$!\211\202H�\250\203/�\312S8@!\211\202H�\203E�9\203E�\317\320!\"\203E�\202H�\321\322!\323\315\211\n\206R�\316\315F\324=\203e�\f\211\324\f\315\257\202\204\325=\203\226�\315\211+,\326-	\206~�\327\330\331 \332#\333!\f\211\325\315\211\211F\315\257,\202\204\334=\203\246�\f\211\334\f\315\257\202\204\335=\203\327�\315\211+,\336-	\206\277�\327\337\331 \332#.\333.!.\f\211\335.\315\211\211F\315\257,\202\204\340=\203\347�\f\211\324
\315\257\202\204\341=\203$\342
\326\"\211+\343+!,\326-	\206\f\327\344\345+\"\331 \332#\346!\f\211\325\315\n\315F\315\257-\202\204\347=\2034\f\211\334
\315\257\202\204\350=\203q\342
\336\"\211+\343+!,\336-	\206Y\327\344\351+\"\331 \332#.\346.!.\f\211\335.\315\n\315F\315\257-\202\204\302=\203\201\f\211\302\f\315\257\202\204\321\352!.\207" [what-list module class what nil-list class-list (("procedure") ("procedure-keyword") ("function") ("function-keyword") ("procedure-method") ("procedure-method-keyword") ("function-method") ("function-method-keyword") ("class")) idlwave-sintern-routine-or-method idlwave-sintern-class 0 intern completing-read "Complete what? " nil t assoc symbol-name error "Invalid WHAT" (nil nil nil nil) procedure procedure-keyword pro idlwave-completing-read "Procedure: " idlwave-routines idlwave-selector idlwave-sintern-routine function function-keyword fun "Function: " procedure-method procedure-method-keyword idlwave-determine-class idlwave-all-class-inherits format "Procedure in %s class: " idlwave-sintern-method function-method function-method-keyword "Function in %s class: " "Invalid value for WHAT" class-selector super-classes type-selector func] 8])
(defalias 'idlwave-completing-read #[(&rest args) "\302\303!\304\216\305\303\306\"\210\307\310	\"*\207" [old-value args default-value completion-ignore-case ((byte-code "\301\302\"\207" [old-value set-default completion-ignore-case] 3)) set-default t apply completing-read] 3])
#@47 Use the comint stuff to complete a file name.
(defalias 'idlwave-complete-filename #[nil "\304\305!\210\306\307\310\302!\203�\n;\203�\311\n!\203�\n\202�\312 +\207" [comint-file-name-chars comint-completion-addsuffix idlwave-shell-default-directory default-directory require comint "~/A-Za-z0-9+@:_.$#%={}\\-" nil boundp file-directory-p comint-dynamic-complete-filename] 2 (#$ . 176042)])
(defalias 'idlwave-make-full-name #[(class name) "\203�\302\303\"\202\f�\304	P\207" [class name format "%s::" ""] 3])
#@55 Like `idlwave-rinfo-assq', but sintern strings first.
(defalias 'idlwave-rinfo-assoc #[(name type class list) "\304\305	\"\n\306	!$\207" [name class type list idlwave-rinfo-assq idlwave-sintern-routine-or-method idlwave-sintern-class] 5 (#$ . 176566)])
(defalias 'idlwave-rinfo-assq #[(name type class list) "\300\301\215\207" [exit (byte-code "\305	\n\236\211\205-�\306=\204�A@=\203%�\3078\f=\203%�\310\311\"\210\n>A\202�)\207" [match name list type class nil t 2 throw exit] 3)] 2])
(defalias 'idlwave-rinfo-assq-any-class #[(name type class list) "\306!B\307\211	\203#�\310\f	\211A@
$\211\203\n�\307\211\204�\n+\207" [class classes rtn name type list idlwave-all-class-inherits nil idlwave-rinfo-assq] 6])
#@217 Like `idlwave-rinfo-assq', but get all twins and sort, then return first.
If WITH-FILE is passed, find the best rinfo entry with a file
included.  If KEEP-SYSTEM is set, don't prune system for compiled
syslib files.
(defalias 'idlwave-best-rinfo-assq #[(name type class list &optional with-file keep-system) "\306\307	\n$\"\310\211G\311V\203F�\312
\313\"\2049�\314
@8@\315=\2039�\316
A!\211\2039�\f\311\232\2049�
A\203F�\317\310\320\321
\"\"
@*\207" [name type class list syslibp twins idlwave-routine-twins idlwave-rinfo-assq-any-class nil 1 sort idlwave-routine-entry-compare-twins 3 system idlwave-any-syslib delq mapcar #[(x) "\3018A@\205	�\207" [x 3] 2] keep-system with-file] 7 (#$ . 177305)])
#@60 Like `idlwave-best-rinfo-assq', but sintern strings first.
(defalias 'idlwave-best-rinfo-assoc #[(name type class list &optional with-file keep-system) "\306\307	\"\n\310	!\f
&\207" [name class type list with-file keep-system idlwave-best-rinfo-assq idlwave-sintern-routine-or-method idlwave-sintern-class] 7 (#$ . 178026)])
#@85 Does the entry list ENTRIES contain a syslib entry?
If yes, return the index (>=1).
(defalias 'idlwave-any-syslib #[(entries) "\302\303\304\305\215*\207" [cnt file nil 0 exit (byte-code "\203'�	T\303\304@8!\211\203 �\305\n!\203 �\306\307	\"\210\202��A\211\204�\310\207" [entries cnt file idlwave-routine-source-file 3 idlwave-syslib-p throw exit nil] 4)] 2 (#$ . 178360)])
#@51 Return a list of all associations of Key in LIST.
(defalias 'idlwave-all-assq #[(key list) "\304\211\n\236\211\203�	B>A\202�	\237*\207" [elt rtn key list nil] 2 (#$ . 178748)])
#@149 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.
(defalias 'idlwave-all-method-classes #[(method &optional type) "\204\n�\302\303\304 \"\207\305\306\307\310\311 \"\"\210\312	!)\207" [method rtn mapcar car idlwave-class-alist nil mapc #[(x) "\3038\205�	\203�	A@=\205�\3038\nB\211\207" [x type rtn 2] 2] idlwave-all-assq idlwave-routines idlwave-uniquify] 5 (#$ . 178943)])
#@169 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.
(defalias 'idlwave-all-method-keyword-classes #[(method keyword &optional type) "?\206�	??\205�\303\304\305\306\307 \"\"\210\310\n!)\207" [method keyword rtn nil mapc #[(x) "\3048\205\"�	\203�	A@=\205\"�\305\n\306!\"\205\"�\3048B\211\207" [x type keyword rtn 2 assoc idlwave-entry-keywords] 4] idlwave-all-assq idlwave-routines idlwave-uniquify] 5 (#$ . 179431)])
#@61 Return list of all elements in LIST which are also in CLUB.
(defalias 'idlwave-members-only #[(list club) "\303	\203�	@\n\235\203�	@B	A\211\204�\237)\207" [rtn list club nil] 3 (#$ . 179981)])
#@60 Return list of all elements in LIST which are not in CLUB.
(defalias 'idlwave-nonmembers-only #[(list club) "\303	\203�	@\n\235\204�	@B	A\211\204�\237)\207" [rtn list club nil] 3 (#$ . 180188)])
#@128 Return whether or not the class is listed explicitly, ala a->b::c.
INFO is as returned by idlwave-what-function or -procedure.
(defalias 'idlwave-explicit-class-listed #[(info) "\3028\211\205�\212	b\210\303\304!))\207" [info apos 3 looking-at "->[a-zA-Z][a-zA-Z0-9$_]*::"] 3 (#$ . 180398)])
#@95 List of special functions for determining class.
Must accept two arguments: `apos' and `info'
(defvar idlwave-determine-class-special nil (#$ . 180698))
(defalias 'idlwave-determine-class #[(info type) "\3068\3078\310@;\203�@\226\202�@\"@\203#�\311\202$�\312\236\f\2030�\fA\202:�
\2039�
A\202:�\313%\n\205G�\n\306\n\\{\314\230\211&\205[�\212\nb\210\315v\210\313'\316\317!*()*\320\211+,\320-	\204r�\320\202[	\313=\203Z&\203\227�\321\n\322\"\203\227�.\203\227�*\204\227�\321\n\322\"\323	!	\313=\203\253�(\203\253�\306\324 8\206\252�		\313=\203\317�/\203\317�*\204\317�\325/\n\"\211,\203\317�\323,!.+	\313=\2037*\204\337�%\2037\326\327\330@0\"\"-\323-G\331U\203�*\204�\332\333@\"\2025-G\334U\203*\204-@@\2025.+\335\336\337@;\203+\336\3400@#\202,\341\"-\320\211\211\342&!	\203V	\313=\204V+\203P&\203P\320\343\344\217\210AA	\240\210	\202[	.\207" [info class apos idlwave-query-class nassoc dassoc 2 3 assoc keyword-default method-default t "->" -1 looking-at "self\\>" nil get-text-property idlwave-class idlwave-sintern-class idlwave-current-routine idlwave-call-special mapcar list idlwave-all-method-classes 0 error "No classes available with method %s" 1 idlwave-completing-read format "Class%s: " " for %s method %s" "" idlwave-class-history (byte-code "\303\211\304\\\305	\306\n\307BBBB#\207" [apos class idlwave-class-arrow-face add-text-properties 2 idlwave-class face (rear-nonsticky t)] 8) ((error)) query arrow case-fold-search is-self idlwave-force-class-query force-query store special-class class-alist idlwave-store-inquired-class idlwave-determine-class-special type] 9])
(defalias 'idlwave-selector #[(a) "A@	=\205!�\3048\203�\n\305=\206!�\3048\n=\206!�\3048>\207" [a type-selector class-selector super-classes 2 t] 2])
(defalias 'idlwave-add-file-link-selector #[(a) "\304!\305\211\203�\306!\211\203�@	BB\n*\207" [a file sel idlwave-completion-help-links idlwave-selector nil idlwave-entry-has-help] 3])
#@749 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        (PRO-OR-FUNC POINT CLASS ARROW)  Like PRO-LIST, for what can
               be completed 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:  Location of the arrow
(defalias 'idlwave-where #[nil "\306 \210\212\307\310!\210`)\311!\211@	A@\312	8\313	8\206!�\314\315	8\206)�\314%\316!\211&@'&A@(\312&8)\313&8\206H�\314*\317 +\320,`{$\321\211-.\321\211/0\3211
*W\203n�\321\322\323$\"\203|�\324-\2028\322\325*\314V\203\214�*`{\202\216�$\"\203\244�\326-(0*1)/\2028\322\327$\"\2048\322\330$\"\203\272�\324-\2028\322\331$\"\203\310�\324-\2028\n\203\363�
*V\203\363�%\332U\203\363�+\333>\203\363�\334-\n.
10\f/\2028'\203+\335=\203\336-'.*1(0)/\2028\337-\212\340\341\320#\2037\342\314\224!/\315\225\2034\343\344\315!!\2025\3200)'*()F\n
\fF-.10/F+\257.\207" [bos func-entry func func-class func-arrow func-point idlwave-routines idlwave-start-of-substatement pre idlwave-what-function 2 3 0 4 idlwave-what-procedure idlwave-last-valid-char t nil string-match "\\`[ 	]*\$pro\\|function\$[ 	]+[a-zA-Z0-9_]*\\'" class "\\`[ 	]*\$[a-zA-Z][a-zA-Z0-9$_]*\$?\\'" procedure "\\`[ 	]*\$pro\\|function\$\\>" "OBJ_NEW([ 	]*['\"]\$[a-zA-Z0-9$_]*\$?\\'" "\\<inherits\\s-+\$[a-zA-Z0-9$_]*\$?\\'" 1 (40 44) function-keyword 44 procedure-keyword function re-search-backward "->[ 	]*\$\\$[ 	]*\\(;.*\$?\n\\s-*\\)?\$\\([$a-zA-Z0-9_]+\$::\\)?[$a-zA-Z0-9_]*\\=" copy-marker idlwave-sintern-class match-string func-level pro-entry pro pro-class pro-arrow pro-point last-char case-fold-search cw cw-mod cw-arrow cw-class cw-point] 8 (#$ . 182719)])
(defalias 'idlwave-this-word #[(&optional class) "\206�\301\212\302x\210`\302w\210`{)\207" [class "a-zA-Z0-9$_." nil] 3])
(defalias 'idlwave-what-function #[(&optional bound) "\300\301\215\207" [exit (byte-code "\306\211\307\306\211\211\310 \311\216\312!\210\214\212\313\206 �\307]d}\210\306\314\315\217\203u�`Tg\316U\203o�\317\320\321#\203o�\322\323!\323\224b\211\317\324\321#\203_�\325\307\224!\322\323!\206^�\321\326\327\330\n\"\331!	\f\257\"\210
b\210\202$�\326\327\306\".\n\207" [class arrow-start func cnt func-point pos nil 0 syntax-table ((set-syntax-table saved-syntax)) set-syntax-table 1 (byte-code "\300\301!\210\302\207" [up-list -1 t] 2) ((error)) 40 re-search-backward "\$::\\|\\<\$\$[a-zA-Z][a-zA-Z0-9$_]*\$[ 	]*\\=" t match-string 2 "->[ 	]*\$\\([a-zA-Z][a-zA-Z0-9$_]*\$::\\)?\\=" copy-marker throw exit idlwave-sintern-routine-or-method idlwave-sintern-class saved-syntax idlwave-find-symbol-syntax-table bound] 8)] 2])
(defalias 'idlwave-what-procedure #[(&optional bound) "`\306\211\211\211\211\212\307\310!\210`
{\311\312\"\203)�\313\314\"`\314\224\\\202e�\315 \203e�`
{\211\203e�\311\316\"\203e�\317\224\205F�\313\317\"\317\224\203S�`\317\224\\\202T�
\320`\314\224\\!\313\321\"\206d�\322)\323\n\"\324\n!	\fF.\207" [string arrow-start class pro pro-point pos nil idlwave-start-of-substatement pre string-match "\\`[ 	]*\$[a-zA-Z][a-zA-Z0-9$_]*\$[ 	]*\$,\\|\\'\$" match-string 1 idlwave-skip-object "\\`[ 	]*\$->\$[ 	]*\$\\([a-zA-Z][a-zA-Z0-9$_]*\$::\\)?\$[a-zA-Z][a-zA-Z0-9$_]*\$?[ 	]*\$,\\|\\(\\$\\s *\\(;.*\$?\\)?$\\)" 4 copy-marker 3 t idlwave-sintern-routine-or-method idlwave-sintern-class] 6])
(defalias 'idlwave-skip-object #[nil "`\301\302\215\205\n�b)\207" [pos exit (byte-code "\212\302\303w\210\304\303w\210\305!\203�\306\225b\210\202!�g\307=\204!�\310\311\303\"\210\312\313\215\210\305\314!\2035�\310\311\306\224\211\"\2029�\310\311\303\")\207" [idlwave-identifier pos " 	" nil "*" looking-at 0 40 throw exit endwhile (byte-code "g\301=\203�\302u\210\303!\204�\304\305\306\"\210\307\225b\210\202��g\310>\203)�\306\311\312\217\210\202��\304\313\314\"\210\202��" [idlwave-identifier 46 1 looking-at throw exit nil 0 (40 91) (forward-list 1) ((error (byte-code "\300\301\302\"\207" [throw exit nil] 3))) endwhile t] 3) "[ 	]*->"] 4)] 2])
#@320 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.
(defalias 'idlwave-last-valid-char #[nil "\300\301\215\207" [exit (byte-code "\212\300\301x\210h\302=\203�\303u\210\304\301x\210h\305>\203 �\306\307\301\"\210\202�h\310=\203?�\311\312!\210\313\314!\2037�\315\225b\210\202�\306\307\301\"\210\202�\306\307h\"\210\202�" ["a-zA-Z0-9_$" nil 47 -1 " 	" (59 36) throw exit 10 beginning-of-line 0 looking-at "\$[^\n]*\$\\$[ 	]*\$;[^\n]*\$?\n" 1] 3)] 2 (#$ . 187284)])
#@49 A form to evaluate after successful completion.
(defvar idlwave-complete-after-success-form nil (#$ . 188027))
#@72 A form to evaluate after completion selection in *Completions* buffer.
(defvar idlwave-complete-after-success-form-force nil (#$ . 188144))
#@60 A mark pointing to the beginning of the completion string.
(defconst idlwave-completion-mark (make-marker) (#$ . 188290))
#@384 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 the intern types, e.g. 'function,
'procedure, 'class-tag, 'keyword, 'sysvar, etc..  SPECIAL-SELECTOR is
used only once, for `all-completions', and can be used to, e.g.,
accumulate information on matching completions.
(defalias 'idlwave-complete-in-buffer #[(type stype list selector prompt isa &optional prepare-display-function special-selector) "\306\307`\307\211\307\211 \307\211!\307\"#\204$�\310$\311P!\210\212\312\307x\210h\313=`\314\315%D	F&\314\315%D\315\316DF')	\n{\211\227!\317(\f\"\320\f#)#\211 ;\205e� \227\"\307* \204y�\310$\321P\f\"\202W!\"\232\204\306� \306=\204\306�	\n|\210\f!\230\203\252�\f\322\230\203\236�+\203\252�,\204\252�\"c\210\202\256� c\210\320 #)#\306=\203\302�\314%	#\210\306\202W \306=\204\354�\323\324\f#-\206\331�)#!\211G\325U\203\376�!\"\232\203\376�\314%	#\210\326\327\f.#\210\307\202W\326\330!\210*\204
\331\332#\"\210#
>/\3060\333#\334\"#1\203-1#!#\f!\230\203K\f\322\230\203?+\203K,\204K\335\336#\"#\337#$	/$\210+\306.\n\207" [completion-ignore-case beg end slash part spart t nil error ": No completions available" "a-zA-Z0-9_$" 47 idlwave-after-successful-completion quote force idlwave-sintern try-completion ": no completion for \"%s\"" "" idlwave-uniquify all-completions 1 message "%s is already the complete %s" "Making completion list..." mapc #[(x) "\303\304\301@#\211\205�@	B\nB\211)\207" [x link idlwave-completion-help-links get-text-property 0] 5] sort #[(a b) "\227	\227\231\207" [a b] 2] mapcar #[(x) "<\203�\211@\227\240\210\202�\227\207" [x] 2] idlwave-display-completion-list completion dpart dcompletion list prompt type idlwave-complete-after-success-form idlwave-complete-after-success-form-force stype selector idlwave-completion-help-links idlwave-complete-empty-string-as-lower-case idlwave-completion-force-default-case special-selector isa complete completion-highlight-first-word-only prepare-display-function] 6 (#$ . 188419)])
#@28 Complete a class at point.
(defalias 'idlwave-complete-class #[nil "\301 \210\302\212\303\304`\305Z\302#\205�eb\205�\306\307\310\302#*\203#�\311\312!c\207\313\314\211\315 \310\316\317\320&\207" [case-fold-search idlwave-routines t re-search-backward "\\<\$pro\\|function\$[ 	]+\\=" 15 re-search-forward "^[ 	]*\$pro\\|function\$[ 	]+\$[a-zA-Z0-9_]+::\$" nil match-string 2 idlwave-complete-in-buffer class idlwave-class-alist "Select a class" "class" (lambda (list) (mapcar (lambda (x) (let* ((entry (idlwave-class-info x)) (link (nth 1 (assq 'link entry)))) (if link (push (cons x link) idlwave-completion-help-links)) x)) list))] 8 (#$ . 190585) nil])
(defalias 'idlwave-attach-classes #[(list type show-classes) "\203�	\203�	;\203�\n\204�\207\306Y\205�\f\307Y\306U?\310\311=?\2055�\n\2055�	\nB\312!\f\205H�\313\314\315\316\"\"\317\211\317\211\315\320\".\n\207" [show-classes class-selector super-classes list emacs-major-version do-prop 0 21 t class-tag abs apply max mapcar length nil #[(x) "\306=\203�\307	\n\"C\202/�\310=\203�\311\f\n
#\202!�\312\n
\"\203/�\313\314\315\316\"\"G\203G�\317\320 \nGZ\321\"P!\202J�\317!\"\203r�#X\203f�!\322\323\324\325#\326R$\202u�\327\330!#$\202u�\314$%\203\213�\331\n!\332\333\nG\334\323\324\317#\n%\210$\203\225�\n$D\207\n\207" [type class-selector x classes method-selector type-selector class-tag idlwave-class-or-superclass-with-tag kwd idlwave-all-method-keyword-classes idlwave-all-method-classes delq nil mapcar #[(x) "	>\205�\207" [x inherit] 2] " " make-string 46 "<" mapconcat identity "," ">" format "%s<%d classes>" copy-sequence put-text-property 0 help-echo inherit nclasses do-dots lmax space do-buf max class-info do-prop] 8] do-buf do-dots type inherit lmax classes nclasses class-info space] 6])
(defalias 'idlwave-attach-method-classes #[(list) "\302\303	#\207" [list idlwave-completion-show-classes idlwave-attach-classes method] 4])
(defalias 'idlwave-attach-keyword-classes #[(list) "\302\303	#\207" [list idlwave-completion-show-classes idlwave-attach-classes kwd] 4])
(defalias 'idlwave-attach-class-tag-classes #[(list) "\302\303	#\207" [list idlwave-completion-show-classes idlwave-attach-classes class-tag] 4])
(defalias 'idlwave-pset #[(item) "\211\207" [item rtn] 2])
#@138 Select an item in LIST with a popup menu.
TITLE is the title to put atop the popup.  If SORT is non-nil,
sort the list before displaying
(defalias 'idlwave-popup-select #[(ev list title &optional sort) "\306\211\211
\203;�
G\307U\203�
@\202;�\203#�\310
\311\"\312\313C\314\315
\"\"CB\316\n\f\"\317\n\",\207" [idlwave-max-popup-menu-items resp menu rtn maxpopup list nil 1 sort #[(a b) "\226	\226\231\207" [a b] 2] append "" mapcar #[(x) "\211B\207" [x] 2] idlwave-split-menu-emacs x-popup-menu title ev] 6 (#$ . 192915)])
#@51 Split the MENU into submenus of maximum length N.
(defalias 'idlwave-split-menu-xemacs #[(menu N) "G	TX\203\n�\207@A\nC\306\307\203R�\2034�\f	W\2034�\fT@
BA\211\204�
\237\310\311
@\306H\fS
8\306H#
B\211B\307\306\202�\237-\207" [menu N title entries cnt nextmenu 0 nil format "%s...%s"] 6 (#$ . 193463)])
#@51 Split the MENU into submenus of maximum length N.
(defalias 'idlwave-split-menu-emacs #[(menu N) "A@G	TX\203\f�\207@A@A\306\307\306\203W�\2037�\f	W\2037�\fT@
BA\211\204\"�
\237\310
!\210\311\312
@@\fS
8@#
B\211B\306\307\202�\237\nB\211-\207" [menu N title entries cnt nextmenu nil 0 prin1 format "%s...%s"] 6 (#$ . 193798)])
(byte-code "\301B\302\301!\204�\303\301\304\"\210\304\207" [current-load-list idlwave-completion-setup-hook default-boundp set-default nil] 3)
#@45 Scroll the completion window on this frame.
(defalias 'idlwave-scroll-completions #[(&optional message) "\303\304\305\"\306 \307\216\310	!\210\311\312\313\217\210\n\205�\302\314\n\"+\207" [win cwin message get-buffer-window "*Completions*" visible selected-window ((select-window win)) select-window nil (scroll-up) ((error (byte-code "<\203�\3048\203�\305	!\210\306\n!\210\202�\307e\"\210\304\207" [last-command win idlwave-complete-after-success-form cwin 2 select-window eval set-window-start] 3))) "%s"] 3 (#$ . 194302)])
#@77 Display the completions in LIST in the completions buffer and echo MESSAGE.
(defalias 'idlwave-display-completion-list #[(list &optional message beg complete) "\306\307!\203
�\310\311\307\"\204�	\312\223\210\313 \314!\210\315\f
E\316\311\317\307#\210\2033�@:\2033�\320 \210\321\322!\210\304\323\f\206>�\324\"\207" [idlwave-completion-mark beg idlwave-before-completion-wconf list message complete get-buffer-window "*Completions*" idlwave-local-value idlwave-completion-p nil current-window-configuration idlwave-display-completion-list-emacs idlwave-display-completion-list idlwave-set-local t idlwave-completion-fontify-classes run-hooks idlwave-completion-setup-hook "%s" "Making completion list...done" this-command] 4 (#$ . 194843)])
#@60 Call FUNCTION as a completion chooser and pass ARGS to it.
(defalias 'idlwave-choose #[(function &rest args) "\306\307	\n\"\210)\310=\203'�\311\304!\203'�\f\204'�\212\312\313x\210`)\314
`\315#\210)\316!\207" [completion-ignore-case function args major-mode font-lock-mode beg t apply idlwave-shell-mode boundp "a-zA-Z0-9_" nil remove-text-properties (face nil) eval idlwave-complete-after-success-form-force] 4 (#$ . 195597)])
(defalias 'idlwave-keyboard-quit #[nil "\301\216\242\302=\205�\303 )\207" [last-command ((keyboard-quit)) idlwave-display-completion-list idlwave-restore-wconf-after-completion] 2 nil nil])
#@59 Restore the old (before completion) window configuration.
(defalias 'idlwave-restore-wconf-after-completion #[nil "\205�	\205�\302	!\207" [idlwave-completion-restore-window-configuration idlwave-before-completion-wconf set-window-configuration] 2 (#$ . 196227)])
#@591 Make the user select an element from the alist in the variable SYM.
The keys of the alist are expected to be strings.  The function returns the
car of the selected association.
To do this, PROMPT is displayed and the user must hit a letter key to
select an entry.  If the user does not reply within DELAY seconds, a help
window with the options is displayed automatically.
The key which is associated with each option is generated automatically.
First, the strings are checked for preselected keys, like in "[P]rint".
If these don't exist, a letter in the string is automatically selected.
(defalias 'idlwave-one-key-select #[(sym prompt delay) "J\306\307!\205\n�\310\311\211J\312N=\203�\313N\202/�\314	!\315\313#\210\315\312	#\210\316\317
\320\321\322##\210\323!\203F�\324\213\210\202I�\325 \316\311!\210\326\327\f\"8,\207" [sym alist temp-buffer-show-hook keys-alist char prompt fboundp fit-window-to-buffer (fit-window-to-buffer) nil :one-key-alist-last :one-key-alist-cache idlwave-make-one-key-alist put message "%s[%s]" mapconcat #[(x) "\301@!\207" [x char-to-string] 2] "" sit-for ((byte-code "\302\220\303\304\"\221\210\305 \303\207" [keys-alist char "*Completions*" mapcar #[(x) "\301A@!\210\301\302!\207" [x princ "\n"] 2] read-char] 4)) read-char 2 assoc delay] 8 (#$ . 196500)])
#@41 Make an alist for single key selection.
(defalias 'idlwave-make-one-key-alist #[(alist) "\306\211\211\211\211\307\306\n\f\f\203*�\f@@\n\fA\f\310\311\215\210\202�\237.\207" [alist case-fold-search cnt help char start nil 0 exit (byte-code "\306\307\"\203!�\310\311\312\"\227!\313\314	#	\nEB\315\316\317\"\210\320\306\321\f#\203]�\320\225\310\311\320\"\227!\322	\"\204#�\313\314	\323\324\311\320\"\325Q\317\211$#	\nEB\315\316\317\"\210\202#�\320\306\326\f#\203\230�\320\225\310\311\320\"!\322	\"\204_�\313\314	\323\324\311\320\"\325Q\317\211$#	\nEB\315\316\317\"\210\202_�\310\327
T\211!!\313\314	#	\nEB\306\207" [name char help keys-alist start cnt string-match "\\[\$.\$\\]" string-to-char match-string 1 format "%c:  %s" throw exit t 0 "[A-Z]" assoc replace-match "[" "]" "[a-z]" int-to-string] 8) name keys-alist l] 8 (#$ . 197820)])
#@55 Set the buffer-local value of VAR in BUFFER to VALUE.
(defalias 'idlwave-set-local #[(var value &optional buffer) "\212\206�pq\210\303	!\nL)\207" [buffer var value make-local-variable] 2 (#$ . 198722)])
#@72 Return the value of VAR in BUFFER, but only if VAR is local to BUFFER.
(defalias 'idlwave-local-value #[(var &optional buffer) "\212\206�pq\210\302	p\"\205�	J)\207" [buffer var local-variable-p] 3 (#$ . 198933)])
#@56 Keymap for completion-list-mode with idlwave-complete.
(defvar idlwave-completion-map nil (#$ . 199155))
(defalias 'idlwave-display-completion-list-xemacs #[(list &rest cl-args) "\303\220\304\305\306\307	%\221\210\212\303q\210\310\n\206�\311\312 !\211!)\207" [list cl-args idlwave-completion-map "*Completions*" apply display-completion-list :activate-callback idlwave-default-choose-completion use-local-map idlwave-make-modified-completion-map-xemacs current-local-map] 7])
#@68 Execute `default-choose-completion' and then restore the win-conf.
(defalias 'idlwave-default-choose-completion #[(&rest args) "\301\302\303#\207" [args apply idlwave-choose default-choose-completion] 4 (#$ . 199640)])
#@71 Replace `choose-completion' and `mouse-choose-completion' in OLD-MAP.
(defalias 'idlwave-make-modified-completion-map-xemacs #[(old-map) "\302!\303	\304\305#\210\303	\306\307#\210	)\207" [old-map new-map copy-keymap define-key [button3up] idlwave-mouse-completion-help [button3] #[nil "\211\207" [last-command this-command] 2 nil nil]] 4 (#$ . 199866)])
#@58 Display completion list and install the choose wrappers.
(defalias 'idlwave-display-completion-list-emacs #[(list) "\302\220\303!\221\210\212\302q\210\304	\206�\305\306 !\211!)\207" [list idlwave-completion-map "*Completions*" display-completion-list use-local-map idlwave-make-modified-completion-map-emacs current-local-map] 3 (#$ . 200230)])
#@71 Replace `choose-completion' and `mouse-choose-completion' in OLD-MAP.
(defalias 'idlwave-make-modified-completion-map-emacs #[(old-map) "\302!\303\304\305	#\210\303\306\307	#\210\310	\311\312#\210	)\207" [old-map new-map copy-keymap substitute-key-definition choose-completion idlwave-choose-completion mouse-choose-completion idlwave-mouse-choose-completion define-key [mouse-3] idlwave-mouse-completion-help] 4 (#$ . 200584)])
#@52 Choose the completion that point is in or next to.
(defalias 'idlwave-choose-completion #[(&rest args) "\301\302\303#\207" [args apply idlwave-choose choose-completion] 4 (#$ . 201021) nil])
#@69 Click on an alternative in the `*Completions*' buffer to choose it.
(defalias 'idlwave-mouse-choose-completion #[(&rest args) "\301\302\303#\207" [args apply idlwave-choose mouse-choose-completion] 4 (#$ . 201219) "e"])
#@73 Regexp for skipping continued blank or comment-only lines in
structures
(defvar idlwave-struct-skip "[ 	]*\$\\$.*\n\\(^[ 	]*\\(\\$[ 	]*\$?\$;.*\$?\n\\)*\\)?[ 	]*" (#$ . 201446))
#@28 Regexp for structure tags.
(defvar idlwave-struct-tag-regexp (concat "[{,]" idlwave-struct-skip "\$[a-zA-Z][a-zA-Z0-9_]*\$" "[ 	]*:") (#$ . 201634))
#@134 Return a list of all tags in the structure defined at point.
Point is expected just before the opening `{' of the struct definition.
(defalias 'idlwave-struct-tags #[nil "\212\305 \211@A\306	b\210\214	\n}\210\307\f\n\310#\2036�\306\311\312\217\203/�`	U\203/�\313\314!B\315\225b\210\202�)\237-\207" [borders beg end tags idlwave-struct-tag-regexp idlwave-struct-borders nil re-search-forward t (byte-code "\300\301!\210\302\207" [up-list -1 t] 2) ((error)) match-string-no-properties 5 0] 5 (#$ . 201792)])
#@53 Find a given TAG in the structure defined at point.
(defalias 'idlwave-find-struct-tag #[(tag) "\305 \211@A\306\307\310\f\311Q\n\306#,\207" [borders beg end case-fold-search tag idlwave-struct-borders t re-search-forward "\$^[ 	]*\\|[,{][ 	]*\$" "[ 	]*:"] 5 (#$ . 202313)])
#@135 Return a list of all `inherits' names in the struct at point.
Point is expected just before the opening `{' of the struct definition.
(defalias 'idlwave-struct-inherits #[nil "\212\306 \211@A\307\310	b\210\214	\n}\210\311\312
\313
\314\260\n\307#\203>�\310\315\316\217\2037�`	U\2037�\317\320!\fB\321\225b\210\202�)\f\237.\207" [borders beg end case-fold-search names idlwave-struct-skip idlwave-struct-borders t nil re-search-forward "[{,]" "inherits" "\$[a-zA-Z][a-zA-Z0-9_]*\$" (byte-code "\300\301!\210\302\207" [up-list -1 t] 2) ((error)) match-string-no-properties 9 0] 7 (#$ . 202601)])
#@58 Return t if point is inside an IDL structure definition.
(defalias 'idlwave-in-structure #[nil "`\212\302 \206\n�\303 ?\205-�\304\305\211\306#\205-�\307 \211@	AU\206,�	@V\205,�	AW)*\207" [beg borders idlwave-in-comment idlwave-in-quote idlwave-find-structure-definition nil back idlwave-struct-borders] 5 (#$ . 203212)])
#@61 Return the borders of the {...} after point as a cons cell.
(defalias 'idlwave-struct-borders #[nil "\301\212\302\301w\210`\301\303\304\217\210`*B\207" [beg nil "^{" (forward-list 1) ((error (goto-char beg)))] 3 (#$ . 203543)])
#@415 Search forward for a structure definition.  If VAR is non-nil,
search for a structure assigned to variable VAR.  If NAME is non-nil,
search for a named structure NAME, if a string, or a generic named
structure otherwise.  If BOUND is an integer, limit the search.  If
BOUND is the symbol `all', we search first back and then forward
through the entire file.  If BOUND is the symbol `back' we search only
backward.
(defalias 'idlwave-find-structure-definition #[(&optional var name bound) "\306\307\n\250\205\n�\n\f\203�\310\311\f\227!\312R\202�\313\314\315
\2038�
;\2030�\316
\227\317R\2029�\320\321R\2029�\322\260\n\323=\204I�\n\324=\203R�\325\326\307#\204b�\n\324=?\205i�\327\307#\205i�\330\224b\210\331\332!,\207" [ws case-fold-search bound lim var name "[ 	]*\$\\$.*\n[ 	]*\$*" t "\\<" regexp-quote "\\>" "\$\$" "=" "\${\$" "\$\\<" "\$[^a-zA-Z0-9_$]" "\\<\$[a-zA-Z_0-9$]+\$" "," "" all back re-search-backward nil re-search-forward 3 match-string-no-properties 5 re] 8 (#$ . 203781)])
(byte-code "\301B\302\301!\204�\303\301\304\"\210\305B\302\305!\204�\303\305\304\"\210\306\307\310\"\210\306\311\312\"\207" [current-load-list idlwave-class-info default-boundp set-default nil idlwave-class-reset add-hook idlwave-update-rinfo-hook #[nil "\301\211\207" [idlwave-class-reset t] 2] idlwave-after-load-rinfo-hook #[nil "\301\211\207" [idlwave-class-info nil] 2]] 3)
(defalias 'idlwave-class-info #[(class) "\306\211\n\203�\203.�\306\307\306\310\311\n\"\"\202.�\f\211	\211A@\211\203.�\312!\210\202�\313
!\211\n\236\206?�\314
!\210
\n\236*\207" [entry list idlwave-class-info idlwave-class-reset idlwave-system-class-info class nil delq mapcar #[(x) "\302\303\236A\206\n�@!\211A?\205�)\207" [x filebuf idlwave-class-file-or-buffer found-in] 4] idlwave-sintern-class-info idlwave-sintern-class idlwave-scan-class-info] 6])
#@48 Sintern the class names in a class-info entry.
(defalias 'idlwave-sintern-class-info #[(entry) "\303\236\301\236\304@\305\"\240\210	\205�	\306\307	A\"\241*\207" [entry inherits taglist tags idlwave-sintern-class set mapcar #[(x) "\301\302\"\207" [x idlwave-sintern-class set] 3]] 4 (#$ . 205663)])
#@271 Find class structure definition(s)
If ALL-HOOK is set, find all named structure definitions in a given
class__define routine, on which ALL-HOOK will be run.  If ALT-CLASS is
set, look for the name__define pro, and inside of it, for the ALT-CLASS
class/struct definition
(defalias 'idlwave-find-class-definition #[(class &optional all-hook alt-class) "\306\307\211\211\310\311\f\227\312\313R\307\306#\205:�
\2031�\212\314 \210`)\315\307\306\n#\211\205:�
!\210\202 �\315\307\2069�\f\",\207" [name list end-lim case-fold-search class all-hook t nil re-search-forward "^[ 	]*pro[ 	]+" "__define" "\\>" idlwave-end-of-subprogram idlwave-find-structure-definition alt-class] 5 (#$ . 205976)])
#@39 Find buffer visiting CLASS definition
(defalias 'idlwave-class-file-or-buffer #[(class) "\227\303P\304\305\306	\301\307\310 $8!\211\211\205�\311\n!*B\207" [class pro file "__define" idlwave-routine-source-file 3 idlwave-rinfo-assoc nil idlwave-routines idlwave-get-buffer-visiting] 8 (#$ . 206678)])
#@66 Scan all class and named structure info in the class__define pro
(defalias 'idlwave-scan-class-info #[(class) "\306\307	!\211@\nA\310	!?\206�\f?\205�\311!??\205K�\212\f\203-�\fq\210\202B�\312\313!q\210\314 \210
\315=\204>�\315 \210\316!\210\212\317b\210\320	\321\"*-\207" [idlwave-auto-routine-info-updates class filebuf file buf major-mode nil idlwave-class-file-or-buffer idlwave-sintern-class file-regular-p get-buffer-create " *IDLWAVE-tmp*" erase-buffer idlwave-mode insert-file-contents 1 idlwave-find-class-definition #[(name) "\305!\211\306\307 B\310\311 BE	=\204�\n\312BC\244\313\n!\210\n\fB\211*\207" [name this-class entry class idlwave-class-info idlwave-sintern-class tags idlwave-struct-tags inherits idlwave-struct-inherits found-in idlwave-sintern-class-info] 5]] 4 (#$ . 206988)])
#@44 Return the FOUND-IN property of the class.
(defalias 'idlwave-class-found-in #[(class) "\301\302!\236A\207" [class found-in idlwave-class-info] 3 (#$ . 207810)])
#@34 Return the native tags in CLASS.
(defalias 'idlwave-class-tags #[(class) "\301\302!\236A\207" [class tags idlwave-class-info] 3 (#$ . 207979)])
#@42 Return the direct superclasses of CLASS.
(defalias 'idlwave-class-inherits #[(class) "\301\302!\236A\207" [class inherits idlwave-class-info] 3 (#$ . 208130)])
#@54 Return a list of native and inherited tags in CLASS.
(defalias 'idlwave-all-class-tags #[(class) "\300\301\302\217\207" [err (byte-code "\301\302\303\304\305!B\"\"\207" [class apply append mapcar idlwave-class-tags idlwave-all-class-inherits] 7) ((error (byte-code "\301 \210\302\303\304!\"\207" [err idlwave-class-tag-reset error "%s" error-message-string] 4)))] 3 (#$ . 208297)])
#@130 Return a list of all superclasses of CLASS (recursively expanded).
The list is cached in `idlwave-class-info' for faster access.
(defalias 'idlwave-all-class-inherits #[(class) "\204�\306\207	\306=\203�\306\207	\307=\203�\306\207\310	!\306\305\236\211\203)�\nA\202t�\311\312\313	!\"\306\211\211\203g�\211A@\211@B\314\311\315\313\f@!\"\"\fA\316V\2038�\317\320!\210\2028�\237\305
BC\244\210
,*\207" [idlwave-support-inheritance class entry info cl all-inherits nil t idlwave-class-info mapcar #[(x) "\301B\207" [x 0] 2] idlwave-class-inherits append #[(x) "	ATB\207" [x cl] 2] 999 error "Class scan: inheritance depth exceeded. Circular inheritance?" rtn inherits] 6 (#$ . 208689)])
#@167 Return the flat entry keywords alist from routine-info entry.
If RECORD-LINK is non-nil, the keyword text is copied and a text
property indicating the link is added.
(defalias 'idlwave-entry-keywords #[(entry &optional record-link) "\302\303\304\305	\233\"\210\237)\207" [kwds entry nil mapc #[(key-list) "@\302\303A\")\207" [key-list file mapcar #[(key-cons) "@A\203%�\f\203%�\306\n!\307\310\nG\301\f	\205!�
\311	!PP\n%\210\nC\nB\211\n*\207" [key-cons link key record-link file idlwave-html-link-sep copy-sequence put-text-property 0 number-to-string kwds] 8]] 3] 5] 4 (#$ . 209412)])
#@68 Find keyword KEYWORD in entry ENTRY, and return (with link) if set
(defalias 'idlwave-entry-find-keyword #[(entry keyword) "\300\301\215\207" [exit (byte-code "\301\302\303\233\"\207" [entry mapc #[(key-list) "@\305	A\"\n\205*�\n@\203\"�\nA\203\"�\f\306\nA!Q\202$�\nAB\307\310\n\"*\207" [key-list keyword kwd file idlwave-html-link-sep assoc number-to-string throw exit] 5] 5] 4)] 2 (#$ . 210017)])
(byte-code "\301B\302\301!\204�\303\301\304\"\210\305B\302\305!\204�\303\305\304\"\210\306B\302\306!\204-�\303\306\304\"\210\307B\302\307!\204<�\303\307\304\"\210\310\311!\210\312\313\314\"\210\315\316\317\"\207" [current-load-list idlwave-current-tags-class default-boundp set-default nil idlwave-current-class-tags idlwave-current-native-class-tags idlwave-sint-class-tags idlwave-new-sintern-type class-tag add-to-list idlwave-complete-special idlwave-complete-class-structure-tag add-hook idlwave-update-rinfo-hook idlwave-class-tag-reset] 3)
#@68 Complete a structure tag on a `self' argument in an object method.
(defalias 'idlwave-complete-class-structure-tag #[nil "`\306\212\307\310x\210`	\311ZW\205�\312\313!)\205Q�\314\315 8\316\n!\n\204)�\317\320!\210\n\f\232\2043�\321\n!\210\322\323\n\324P!\310E\325\326\211\310\327\330\n\"\331\332&\210+\306*\207" [case-fold-search pos class-selector super-classes idlwave-current-tags-class idlwave-completion-help-info t "a-zA-Z0-9._$" nil 4 looking-at "self\\." 2 idlwave-current-routine idlwave-all-class-inherits error "Not in a method procedure or function" idlwave-prepare-class-tag-completion idlwave-complete-class-structure-tag-help idlwave-sintern-routine "__define" idlwave-complete-in-buffer class-tag format "Select a tag of class %s" "class tag" idlwave-attach-class-tag-classes idlwave-current-native-class-tags idlwave-cpl-bold idlwave-current-class-tags] 8 (#$ . 210987) nil])
(defalias 'idlwave-class-tag-reset #[nil "\301\211\207" [idlwave-current-tags-class nil] 2])
#@74 Find and parse the necessary class definitions for class structure tags.
(defalias 'idlwave-prepare-class-tag-completion #[(class) "\305	\306\307\310	!\"\306\311\312	!\"\211\207" [idlwave-sint-class-tags class idlwave-current-tags-class idlwave-current-class-tags idlwave-current-native-class-tags nil mapcar #[(x) "\301\302\"C\207" [x idlwave-sintern-class-tag set] 3] idlwave-all-class-tags downcase idlwave-class-tags] 4 (#$ . 211991)])
(byte-code "\301B\302\301!\204�\303\301\304\"\210\305B\302\305!\204�\303\305\304\"\210\306\307!\210\306\310!\210\311\312\313\"\210\314\315\316\"\210\314\317\320\"\207" [current-load-list idlwave-sint-sysvars default-boundp set-default nil idlwave-sint-sysvartags idlwave-new-sintern-type sysvar sysvartag add-to-list idlwave-complete-special idlwave-complete-sysvar-or-tag add-hook idlwave-update-rinfo-hook idlwave-sysvars-reset idlwave-after-load-rinfo-hook idlwave-sintern-sysvar-alist] 3)
#@29 Complete a system variable.
(defalias 'idlwave-complete-sysvar-or-tag #[nil "`\306\212\307\310x\210`Sf\311\232)\203\"�\312\313\314\211\310\315\316&\210\306\202u�\212\317\310x\210`Sf\311\232\2059�\320\321!\2059�\322\225	X)\203t�\323\324\325!!\211\236\326
\236A
\204V�\327\330\f\"\210\204`�\327\331\f\"\210\332\fD\313\333\211\310\334\335&\210+\306\202u�\310*\207" [case-fold-search pos idlwave-completion-help-info idlwave-system-variables-alist var entry t "[a-zA-Z0-9_$]" nil 33 (idlwave-complete-sysvar-help) idlwave-complete-in-buffer sysvar "Select a system variable" "system variable" "a-zA-Z0-9_$." looking-at "\$[a-zA-Z][a-zA-Z0-9_$]*\$\\." 0 idlwave-sintern-sysvar match-string 1 tags error "!%s is not a known system variable" "System variable !%s is not a structure" idlwave-complete-sysvar-tag-help sysvartag "Select a system variable tag" "system variable tag"] 8 (#$ . 212941) nil])
(defalias 'idlwave-complete-sysvar-help #[(mode word) "A@\206�	\306	\n\"\f\307=\203$�	;\205;�\205;�\305\236A@\202;�\f\310=\2038�\205;�\305\236A@\211\202;�\311\312!*\207" [idlwave-completion-help-info word idlwave-system-variables-alist entry mode link assoc test set error "This should not happen"] 4])
(defalias 'idlwave-complete-sysvar-tag-help #[(mode word) "A@\306	\n\"\304\236A\307\236A@\310\211\311=\203/�;\205Y�\205Y�
\202Y�\312=\203V�\205Y�\313\f\314#A\211\203O�\315
\"\202P�
\211\202Y�\316\317!.\207" [idlwave-completion-help-info var idlwave-system-variables-alist entry tags main assoc link nil test set assoc-string t idlwave-substitute-link-target error "This should not happen" target main-base mode word] 5])
#@47 Split a given link into link file and anchor.
(defalias 'idlwave-split-link-target #[(link) "\302	\"\205�	\303\211\224O\304	\303\225\305O!B\207" [idlwave-html-link-sep link string-match 0 string-to-number nil] 5 (#$ . 214621)])
#@50 Substitute the target anchor for the given link.
(defalias 'idlwave-substitute-link-target #[(link target) "\304\305\306	\"\203�	\307\211\224O\202�	\n\203 �\310\n!Q\202!�	)\207" [main-base link target idlwave-html-link-sep nil string-match "#" 0 number-to-string] 4 (#$ . 214857)])
(byte-code "\301B\302\301!\204�\303\301\304\"\210\304\207" [current-load-list idlwave-help-do-class-struct-tag default-boundp set-default nil] 3)
(defalias 'idlwave-complete-class-structure-tag-help #[(mode word) "\306=\203�\307\207\310=\203G�\307\211\311\f\"\211\203>�\312\n!
\236\203'�\313\314!\210\315\n!\211\2039�	\316P\nB\202>�\n\316P*\f\317\211\207\313\320!\207" [mode found-in class-with idlwave-current-tags-class word idlwave-system-class-info test nil set idlwave-class-or-superclass-with-tag idlwave-sintern-class error "No help available for system class tags" idlwave-class-found-in "__define" t "This should not happen" name kwd idlwave-help-do-class-struct-tag] 3])
#@85 Find and return the CLASS or one of its superclass with the
associated TAG, if any.
(defalias 'idlwave-class-or-superclass-with-tag #[(class tag) "\303!B\304\305\306\215*\207" [class cl sclasses idlwave-all-class-inherits nil exit (byte-code "\2052�\211A@\304	!\211\203.�\305\306\307\n@\306\307\310&\310=\203'�\311\312	\"\210\nA\211\204�)\202��\207" [sclasses cl tags tag idlwave-class-tags compare-strings 0 nil t throw exit] 9)] 3 (#$ . 215851)])
(defalias 'idlwave-sysvars-reset #[nil "\301\302!\205�\302 \205�\205�\303\304\305\306#\207" [idlwave-idlwave_routine_info-compiled fboundp idlwave-shell-is-running idlwave-shell-send-command "idlwave_get_sysvars" idlwave-process-sysvars hide] 4])
(defalias 'idlwave-process-sysvars #[nil "\302 \210\303\211\304 \207" [idlwave-sint-sysvars idlwave-sint-sysvartags idlwave-shell-filter-sysvars nil idlwave-sintern-sysvar-alist] 2])
(defalias 'idlwave-sintern-sysvar-alist #[nil "\304\211\211A@\211\205+�\n\305\n@\306\"\240\210\301\n\236\211\203�	\307\310	A\"\241\210\202�+\207" [idlwave-system-variables-alist tags entry list nil idlwave-sintern-sysvar set mapcar #[(x) "\301@\302\"AB\207" [x idlwave-sintern-sysvartag set] 3]] 5])
#@40 Get any new system variables and tags.
(defalias 'idlwave-shell-filter-sysvars #[nil "\306	\307\211\211\211\211\211\211\307\310\311#\203\\�\306\225\312\313\"\314\225\205=�\315\312\314\"!\316!\236\303\n\236\317\320\321\"BE	B\202�	\206b�\211.\n\207" [idlwave-shell-command-output idlwave-system-variables-alist old-entry link class name 0 nil string-match "^IDLWAVE-SYSVAR: !\$[a-zA-Z0-9_$]+\$\$ \\(.*\$\\)?" match-string 1 3 idlwave-split-string idlwave-sintern-sysvar tags mapcar #[(x) "\302!\303	\236A\236AB\207" [x old-entry idlwave-sintern-sysvartag tags] 4] type var old start text] 10 (#$ . 217067)])
#@59 Goto the *Completions* buffer and fontify the class info.
(defalias 'idlwave-completion-fontify-classes #[nil "\301\302!\205%�\212\303q\210\212eb\210\304\305\306\304\307#\205$�\310\311\224\311\225\312\313$\210\202�+\207" [buffer-read-only featurep font-lock "*Completions*" nil re-search-forward "\\.*<[^>]+>" t put-text-property 0 face font-lock-string-face] 5 (#$ . 217733)])
(defalias 'idlwave-uniquify #[(list) "\302\303G\304\305$\306\307\310\311\"\")\207" [list ht make-hash-table :size :test equal delq nil mapcar #[(x) "\302	\"?\205�\303\304	#\210\207" [x ht gethash puthash t] 4]] 5])
#@130 Add `=' or `(' after successful completion of keyword and function.
Restore the pre-completion window configuration if possible.
(defalias 'idlwave-after-successful-completion #[(type slash &optional verify) "\306=\204D�\307=\2033�	\310\232\204D�	\311\232\204�	\312\232\203$�\313c\210\202D�	\314\232\203D�\315c\210\316u\210\202D�\317=\203D�\n\203D�\204D�\320c\210\f\321=\204g�\322\323!\203j�\324\325\323\"\203j�\326
!p=\203j�\327
!\f\232\203j�\330 \210
\310\211\223\210\310\211\207" [type idlwave-function-completion-adds-paren idlwave-keyword-completion-adds-equal slash verify idlwave-completion-mark procedure function nil t 1 "(" 2 "()" -1 keyword "=" force get-buffer-window "*Completions*" idlwave-local-value idlwave-completion-p marker-buffer marker-position idlwave-restore-wconf-after-completion idlwave-before-completion-wconf] 3 (#$ . 218342)])
#@54 Call `idlwave-context-help' on the clicked location.
(defalias 'idlwave-mouse-context-help #[(ev &optional arg) "\302!\210\303	!\207" [ev arg mouse-set-point idlwave-context-help] 2 (#$ . 219212) "eP"])
(byte-code "\301B\302\301!\204�\303\301\304\"\210\304\207" [current-load-list idlwave-last-context-help-pos default-boundp set-default nil] 3)
#@441 Display IDL Online Help on context.
If point is on a keyword, help for that keyword will be shown.  If
point is on a routine name or in the argument list of a routine, help
for that routine will be displayed.  Works for system routines and
keywords, it pulls up text help.  For other routies and keywords,
visits the source file, finding help in the header (if
`idlwave-help-source-try-header' is non-nil) or the routine definition
itself.
(defalias 'idlwave-context-help #[(&optional arg) "\301!\207" [arg idlwave-do-context-help] 2 (#$ . 219569) "P"])
#@52 Display online help about the completion at point.
(defalias 'idlwave-mouse-completion-help #[(ev) "\303\n!\207" [last-command this-command ev idlwave-do-mouse-completion-help] 2 (#$ . 220130) "eP"])
#@455 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.
(defalias 'idlwave-routine-info #[(&optional arg external) "\304 \210\305\306e`S]\307`\\d^{\"\203A�\310`\311\"\203=�\2035�\212\312u\210\313\314!\2053�\315\316\224\316\225\317#\210\320\321!)\207\320\322\310`\311\"\"\207\320\323!\207\324\325\232\326 \211@\203X�\327\330\331!\"\202[�\332\333!+\207" [arg idlwave-query-class idlwave-force-class-query module idlwave-routines string-match "->" 2 get-text-property idlwave-class -1 looking-at ".?\$->\$" remove-text-properties 1 (idlwave-class nil face nil) message "Class property removed from arrow" "Arrow has text property identifying object to be class %s" "Arrow has no class text property" nil (4) idlwave-what-module apply idlwave-display-calling-sequence idlwave-fix-module-if-obj_new error "Don't know which calling sequence to show"] 6 (#$ . 220339) "P"])
#@443 Call RESOLVE_ROUTINE 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.
(defalias 'idlwave-resolve #[(&optional arg) "\306	\307\232\310 \311\3128@\"A@\313=\203�\314\202�\315\316\317\320\321
\f#\"!\322\"\306#\323\324!\"\203O�\325\326!\"\312\224\205G�\325\327!\"#\325\330!\"
\227\315\230\203Y�\331\"#\204m�\332\320\333\f\227\"#\334\306\335$\202\207�\332\320\336#\227\"#\332\320\337#\227\f\227\"$\340\306\335\257\".\207" [idlwave-query-class arg idlwave-force-class-query module name type nil (4) idlwave-what-module idlwave-make-full-name 2 pro "pro" "function" read-string "Resolve: " format "%s %s" "" string-match "\$pro\\|function\$[ 	]+\$\\(.*\$::\\)?\$.*\$" match-string 1 3 4 ",/is_function" idlwave-shell-send-command "resolve_routine,'%s'%s" idlwave-update-routine-info t "resolve_routine,'%s__define'%s" "resolve_routine,'%s__%s'%s" (idlwave-update-routine-info) resolve kwd class] 8 (#$ . 221619) "P"])
(defalias 'idlwave-find-module-this-file #[nil "\300\301!\207" [idlwave-find-module (4)] 2 nil nil])
#@279 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 limit to this buffer.  With two prefix ARG's
force class query for object methods.
(defalias 'idlwave-find-module #[(&optional arg) "\306	\307\232	\310\232\311\312 !\211\203+�\313\314\f8\f@\"\fA@\315=\203&�\316\202'�\317P\202,�\320\321\322\306\323\324\203;�\325 \202=�\326 \"\"!-\327\203O�\330
-\"\203V�\331\332
\"\202Y�\331\333!-\".\306\211/0\334\335.\"\203o�
.\334\336.\"\203\205�.\337\340O/.\341\342O.\334\343.\"\203\233�\344\345.\"0\344\314.\".\346.0\".\3470!0/\350\232\203\264�\351\202\300�/\352\232\203\277�\315\202\300�\353/\354./0\306%.	\207" [idlwave-query-class arg idlwave-force-class-query this-buffer module default nil (16) (4) idlwave-fix-module-if-obj_new idlwave-what-module idlwave-make-full-name 2 pro "<p>" "<f>" "none" idlwave-uniquify delq mapcar #[(x) "\3018\242\302=?\205 �\303\3048@\"A@\305=\203�\306\202�\307PC\207" [x 3 system idlwave-make-full-name 2 pro "<p>" "<f>"] 3] idlwave-save-buffer-update idlwave-routines idlwave-completing-read assoc format "Module (Default %s): " "Module in this file: " string-match "\\`\\s-*\\'" "<[fp]>" -2 -1 0 -3 "\$.*\$::\$.*\$" match-string 1 idlwave-sintern-routine-or-method idlwave-sintern-class "f" fun "p" t idlwave-do-find-module list name type class] 7 (#$ . 223044) "P"])
(defalias 'idlwave-do-find-module #[(name type class &optional force-source this-buffer) "\306	\"\307\211\211p`\307\211)*+,\310	-\311 \312%).\206+�\313)8+\314)8\203>�\306\314)8	\"\202@�,+\203K�\315+!\204c�\316\203\\�\317\320\227\"\202a�\317\321	\227\"!	\203m�	\322\232\203s�\323\324!\202\343�+@\325=\203\202�\323\326\n\"\202\343�\203\214�\327!\204\223�\323\330\n\"\202\343�/\204\244�\331\332\"*\333*\334\"\210db\210\3340\335\336-\337=\203\267�\340\202\303�-\341=\203\302�\342\202\303�\343\344\345\n\227!\346\260\307\334#\203\327�\347\224b\202\342�\333
!\210\fb\210\323\350\n\").\207" [class name name2 file pos buf idlwave-make-full-name nil idlwave-best-rinfo-assq idlwave-routines WITH-FILE 3 2 idlwave-routine-source-file idlwave-expand-lib-file-name format "%s__define.pro" "%s.pro" "" error "Abort" system "Source code for system routine %s is not available" file-regular-p "Source code for routine %s is not available" idlwave-find-file-noselect find pop-to-buffer t re-search-backward "^[ 	]*\\<" fun "function" pro "pro" "\$pro\\|function\$" "\\>[ 	]+" regexp-quote "[^a-zA-Z0-9_$]" 0 "Could not find routine %s" entry buf1 source name1 type force-source this-buffer case-fold-search] 8])
#@105 Return a default module for stuff near point.
Used by `idlwave-routine-info' and `idlwave-find-module'.
(defalias 'idlwave-what-module #[nil "\306 \210\307\212\310 \210\311\312!*\203-�\313\314\315!\314\316!\"\317\320!\227\321\232\203%�\303\202&�\322\323\317\324!!E\207\325 \316	8	@@	A@@\326\327!\212\327\330w\210g)!\n\331=\203n�
\332\232\204n�\313
\316\324	88\"\211\303\333
\324	8AB\303\"E\202\335�\n\334=\203\237�
\332\232\204\237�!\335=\204\207�\311\336!\203\237�\313
\316\324	88\"\211\322\333
\324	8AB\322\"E\202\335�\n\337>\203\275�
\332\232\204\275�!\335=\203\275�\340
!\211\322\330E\202\335�\f\203\315�\f\322\333	A@\322\"E\202\335�\203\334�\303\333	@\303\"E\202\335�\330.\207" [case-fold-search where cw pro func this-word idlwave-routines t idlwave-beginning-of-statement looking-at "[ 	]*\$pro\\|function\$[ 	]+\$\\([a-zA-Z0-9_$]+\$::\\)?\$[a-zA-Z0-9$_]+\$\$[, 	\n]\\|$\$" idlwave-sintern-routine-or-method match-string-no-properties 4 2 match-string 1 "pro" fun idlwave-sintern-class 3 idlwave-where idlwave-this-word "a-zA-Z0-9$_" nil procedure "" idlwave-determine-class function 40 "[a-zA-Z0-9_]*[ 	]*(" (function-keyword procedure-keyword) idlwave-sintern-routine next-char] 7 (#$ . 225774)])
#@69 Call idlwave-what-module and find the inherited class if necessary.
(defalias 'idlwave-what-module-find-class #[nil "\303 \3048\305G\306U\203\"�	;\203\"�@A@\307\310\"E\202#�+\207" [module class classes idlwave-what-module 2 nil 3 apply idlwave-find-inherited-class] 5 (#$ . 227009)])
#@76 Find the class which defines TYPE NAME and is CLASS or inherited by CLASS.
(defalias 'idlwave-find-inherited-class #[(name type class) "\304	\n\305 $\211\203�\3068\202�\n)\207" [name type class entry idlwave-best-rinfo-assoc idlwave-routines 2] 6 (#$ . 227308)])
#@127 Check if MODULE points to obj_new.
If yes, and if the cursor is in the keyword region, change to the
appropriate Init method.
(defalias 'idlwave-fix-module-if-obj_new #[(module) "@`\306\307	;\2036�	\227\310\232\2036�\212\311 \210`\n{\312\313\f\")\2036�\314\315\316\f\"\317\314!\320\321
!E*,\207" [module name pos case-fold-search string class t nil "obj_new" idlwave-beginning-of-statement string-match "obj_new([^'\"]*['\"]\$[a-zA-Z0-9_]+\$" "Init" match-string 1 idlwave-sintern-method fun idlwave-sintern-class] 4 (#$ . 227583)])
#@196 Update a list of keywords.
Translate OBJ_NEW, adding all super-class keywords, or all keywords
from all classes if class equals t.  If SYSTEM is non-nil, don't
demand _EXTRA in the keyword list.
(defalias 'idlwave-fix-keywords #[(name type class keywords &optional super-classes system) "\306	\226\307\232\203P�\n\310=\204�\n\311=\203P�\212\312 \210`)\211`{\306\313\314\315\f\"\203O�\316\317\320\f\"!\211\203O�
\211$\203O�\321%\322\323\324\325!\326
\327 $\330\"\"%,
\306=\203e�\331\332\333	\327 \"\"\210\334%!%&\203\347�'\203\347�
;\203\347�(\204\213�\335\336!%\236\204\213�\335\337!%\236\203\347�'\313)*\340\341\215*\203\347�\327 +\313,+:\203\340�+@,\342,8\203\327�\342,8&>\203\327�,A@-=\203\327�,@	=\203\327�\331\343\322,\330\"\"\210+A\211+\202\242�*\334%!%%)\207" [case-fold-search name major-mode bos string class t "OBJ_NEW" idlwave-mode idlwave-shell-mode idlwave-beginning-of-statement nil string-match "obj_new([^'\"]*['\"]\$[a-zA-Z0-9_]+\$" idlwave-sintern-class match-string 1 append idlwave-entry-keywords idlwave-rinfo-assq idlwave-sintern-method "INIT" fun idlwave-routines do-link mapc #[(entry) "\3038\205�A@	=\205�\304\n\305\306\"\"\211\207" [entry type keywords 2 append idlwave-entry-keywords do-link] 5] idlwave-all-assq idlwave-uniquify idlwave-sintern-keyword "_extra" "_ref_extra" exit (byte-code "\211A@\211\205�\303	\n\"\203��\304\305\306\"\210\202��\207" [regexps re name string-match throw exit t] 3) 2 #[(k) "\301\302\"\207" [k add-to-list keywords] 3] idlwave-current-obj_new-class keywords super-classes idlwave-keyword-class-inheritance system re regexps #1=#:--cl-var-- entry type] 9 (#$ . 228135)])
#@632 Expand KEYWORD to one of the valid keyword parameters of MODULE.
KEYWORD may be an exact match or an abbreviation of a keyword.
If the match is exact, KEYWORD itself is returned, even if there may be other
keywords of which KEYWORD is an abbreviation.  This is necessary because some
system routines have keywords which are prefixes of other keywords.
If KEYWORD is an abbreviation of several keywords, a list of all possible
completions is returned.
If the abbreviation was unique, the correct keyword is returned.
If it cannot be a keyword, the function return nil.
If we do not know about MODULE, just return KEYWORD literally.
(defalias 'idlwave-expand-keyword #[(keyword module) "@A@\3068\307\f!\310	\n\311 $\312!\307\313!\236\206-�\307\314!\236\315\316
\236\203@�
\202v�\317
\"\211\203^�G\320U\203Y�@\202v�\202v�\203l�\203l�\f\202v�\203u�\316\202v�\f.	\207" [module name type class keyword kwd 2 idlwave-sintern-keyword idlwave-best-rinfo-assoc idlwave-routines idlwave-entry-keywords "_EXTRA" "_REF_EXTRA" t nil all-completions 1 entry kwd-alist extra completion-ignore-case candidates] 5 (#$ . 229823)])
(byte-code "\301B\303\301!\204�\304\301\305 \"\210\302B\303\302!\204 �\304\302\305 \"\210\306	\307\310#\210\306	\311\312#\210\306	\313\314#\210\306	\315\316#\210\306\n\317\320#\210\306	\317\320#\210\321B\303\321!\204S�\304\321\322\"\210\323B\303\323!\204c�\304\323\324 \"\210\322\207" [current-load-list idlwave-rinfo-mouse-map idlwave-rinfo-map default-boundp set-default make-sparse-keymap define-key [mouse-2] idlwave-mouse-active-rinfo [(shift mouse-2)] idlwave-mouse-active-rinfo-shift [mouse-3] idlwave-mouse-active-rinfo-right " " idlwave-active-rinfo-space "q" idlwave-quit-help idlwave-popup-source nil idlwave-rinfo-marker make-marker] 4)
(defalias 'idlwave-quit-help #[nil "\302\303!\302\304!\203�\305\306!\203�\307!\210\306 \210\310	!\205\"�\311	!*\207" [olh-window ri-window get-buffer-window "*Help*" "*IDLWAVE Help*" fboundp idlwave-help-quit select-window window-live-p delete-window] 3 nil nil])
(defalias 'idlwave-display-calling-sequence #[(name type class &optional initial-class) "\206�	\306\n	\307 $\206�\310\n	\f$\211@\206�\n\311
8\206%�	\312!@\313
!A\314A!\211BC\315
8@\316=\317
8D\320
\321\"E\322
8@F\323G\324H\325I\326J\327K\n	p\330\257,\331L\3320\330\211MN\330\211OP\330Q\333\n	E$E
\204\240�\334\335\n\203\233�\336P\202\234�\337$\202\204\n\203\252�\n\337\232\203\260�\334\340!\202\204D\204\275�\334\341\n#\202\204\212R`\330\223\210\342\343!q\210\344S!\210\330T\345 \210\346\347!\210\330'\346\350!\210((@\203L\351\352LU\353J\354\301,B\257N@B\330VW\355c\210W\211AW@\211V\203H\356c\210`MVc\210V\227	\227\232\2032\357M`\360\361D#\210\202\310\nV\307 $\203\357M`N#\210\202\362c\210*\351\352LU\353H\354\363,B\257NF\203p\364\3600\365FFN\"N\366c\210`M	\203\210\367D	\n	\n	\n&\202\220\367D\n\211\211\211%\362\261\210\357M`N#\210\370c\210E\204\252\371c\210\202\263\372K\373\374E\"\210\375PCGQC\211AC@\211\203?\351\352LU\353I\376\311
8@@
A@\330\311
8@AF\354\376,B\257\nN\377\367\201[�P\375\232\203Q\375V\203\201\\�\202	\201]�\202	\337Q\375V\203\201^�\202\337#
N#\210PTPC\203\273PXV\203\273\367\201_�X\"c\210\330\211C\202\275eb\210\201`�T)\201a�\343!\210\201b�\343!\211O\205\204Y\205\204\201c� Z\201d�\216\201e�O!\210\201f�\201g� \311\245\201h� Z!\210\201i� *.\207" [initial-class class name type idlwave-unresolved-routines entry idlwave-best-rinfo-assq idlwave-routines idlwave-rinfo-assq 2 idlwave-all-class-inherits idlwave-routine-twins idlwave-study-twins 3 system 4 idlwave-entry-keywords do-link 5 "Button2: Insert KEYWORD (SHIFT=`/KEYWORD') | Button3: Online Help " "Button2/3: Online Help" "Button2: Jump to source and back | Button3: Source in Help window." "Button2: Display info about same method in superclass" 0 nil local-map idlwave-help-link idlwave-fix-keywords error "No %s %s known %s" "in class " "" "No function or procedure call at point" "Calling sequence of %s %s not available" get-buffer-create "*Help*" use-local-map erase-buffer make-local-variable idlwave-popup-source idlwave-current-obj_new-class mouse-face highlight help-echo data "Classes: " " " add-text-properties face bold "\n" usage append link "Usage:    " format "Keywords:" " No keywords accepted." 9 mapc #[(x) "\306\307	@G#\310 Y\203�\311c\210\312\313c\210`\314\315\f\305\316
B\317\316	@\257\n\2038�\320\321D\"	@c\210\322\n`#\210\306\307	@G#\211\207" [col x beg km-prop idlwave-rinfo-mouse-map data + 1 window-width "\n         " 9 " " mouse-face highlight keyword help-echo append face add-text-properties help-echo-kwd props system] 10] 1 source idlwave-insert-source-location superclasses twins dtwins all calling-seq keywords html-file help-echo-kwd help-echo-use help-echo-src help-echo-class col km-prop beg props win cnt total idlwave-rinfo-marker idlwave-rinfo-map buffer-read-only idlwave-rinfo-mouse-map c classes idlwave-rinfo-max-source-lines idlwave-resize-routine-help-window ww "\n%-8s  %s" "Sources:" "Source:" "- " "\n          Source information truncated to %d entries." t display-buffer get-buffer-window selected-window ((select-window ww)) select-window enlarge-window frame-height window-height shrink-window-if-larger-than-buffer] 13])
#@131 Insert a source location into the routine info buffer.
Start line with PREFIX.  If a file name is inserted, add FILE-PROPS to
it.
(defalias 'idlwave-insert-source-location #[(prefix entry &optional file-props) "@A@\3068\307\236\310\236\311\236/\312\2360
\203(�\313\310\"\206A�/\2034�\313\311\"\206A�0\203@�\313\312\"\206A�\3141\3152\316\211345c\210	\317=\203_�\3162\320c\210\202\334�	\321=\203n�\3162\322c\210\202\334�\n\204|�\f\203|�\323c\210\202\334�\n\204\206�\324c\210\202\334�\325\n!\203\241�\326\327\330\n!\"\203\233�\331c\210\202\334�\332c\210\202\334�0A\206\252�/A\2114\203\272�\333\3344\"c\210\202\334�\335\n!\2114\203\315�\333\3344\"c\210\202\334�\336\n!\203\331�\337c\210\202\334�\340c\2102\203
\3410\203\353�\342\202\354�\343/\203\365�\344\202\366�\343\f\203\376�\345\202\377�\343
\203\346\202\343\347\260c\2101\314V\203'`3\333\3501\"c\210\3513`\352\353D#\210\n\205H\n\354\232?\205H`3\355\356\nC\"c\2106\205H\3513`6#.\207" [entry key file types shell-flag buffer-flag 2 compiled buffer user lib idlwave-count-memq 1 t nil system "System    " builtin "Builtin   " "Unresolved" "ERROR" idlwave-syslib-p string-match "obsolete" file-name-directory "Obsolete  " "SystemLib " format "%-10s" idlwave-special-lib-test idlwave-lib-p "Library   " "Other     " "  [" "L" "-" "C" "S" "B" "] " "(%dx) " add-text-properties face bold "" apply abbreviate-file-name user-flag lib-flag ndupl doflags beg special prefix file-props] 7 (#$ . 235243)])
#@127 Check the path of FILE against the regexps which define special libs.
Return the name of the special lib if there is a match.
(defalias 'idlwave-special-lib-test #[(file) "\305\211\f;\203*�\211A@\211\203&�\306\n@\f\"\203�\nA\305\211\202\f�	\202+�\305+\207" [idlwave-special-lib-alist rtn entry alist file nil string-match] 4 (#$ . 236749)])
(defalias 'idlwave-mouse-active-rinfo-right #[(ev) "\301\302\"\207" [ev idlwave-mouse-active-rinfo right] 3 nil "e"])
(defalias 'idlwave-mouse-active-rinfo-shift #[(ev) "\301\302\303#\207" [ev idlwave-mouse-active-rinfo nil shift] 4 nil "e"])
(defalias 'idlwave-active-rinfo-space #[nil "\300\301\302\"\207" [idlwave-mouse-active-rinfo nil right] 3 nil nil])
#@139 Does the mouse actions in the routine info buffer.
Optional args RIGHT and SHIFT indicate, if mouse-3 was used, and if SHIFT
was pressed.
(defalias 'idlwave-mouse-active-rinfo #[(ev &optional right shift) "\203�\306!\210\307\211\211\211\211\211\211\211\211\211\211\211\"#$%&	\310`\311\"	\310`\305\"\310`\303\"\310`\304\"	@&	A@%\312	8$\313	8\314	8#\315	8\316 \317#\320\"\"&\321=\203\212�\322\"!\203{�\323\"!\210\324\325%!$\326\n!	$\202&\327=\203\235�\330\f%$$\202&\305=\203\363�'\203\311�\331\307%$
\332\257C()*\333%$\307$+\202+?\211+\203\331�\334\335\336\217\202\"\203\346�\323\"!\210\202\353�\337#!\210\340,!b\202&\303=\205'\203\f\330\f%$%\202\341#-#.\f\207" [ev initial-class word keyword link source mouse-set-point nil get-text-property data 2 3 4 6 idlwave-this-word get-buffer-window t class window-live-p select-window idlwave-display-calling-sequence idlwave-sintern-method idlwave-sintern-class usage idlwave-online-help idlwave-help-with-source "" idlwave-help-get-special-help err (idlwave-do-find-module name type class source) ((error (byte-code "\303\304	!\203\f�\305	!\210\306\nA@!\207" [idlwave-popup-source bufwin err nil window-live-p select-window error] 2))) pop-to-buffer marker-position idlwave-rinfo-insert-keyword bufwin buf type name id right idlwave-routines idlwave-help-source-try-header idlwave-extra-help-function idlwave-popup-source idlwave-rinfo-marker shift] 13 (#$ . 237468) "e"])
#@71 Insert KEYWORD in BUFFER.  Make sure buffer is displayed in a window.
(defalias 'idlwave-rinfo-insert-keyword #[(keyword buffer &optional shift) "\306!\n\203�\227	\203�\307	!\210\202�\310!\210\306!h\311=\203)�c\202O�\212\312\313`\314Ze^\315#)\204:�\316c\210\f\203A�\317c\210c\210\f?\205O�
\205O�\320c)\207" [buffer bwin idlwave-complete-empty-string-as-lower-case keyword shift idlwave-keyword-completion-adds-equal get-buffer-window select-window pop-to-buffer 47 re-search-backward "[(,][ 	]*\$\\$[ 	]*\\(;.*\$?\n\\)?[ 	]*\\=" 100 t ", " "/" "="] 4 (#$ . 238982)])
#@71 List the load path shadows of all routines defined in current buffer.
(defalias 'idlwave-list-buffer-load-path-shadows #[(&optional arg) "\301 \210\302=\203�\303\304\305\306!\307#\207\310\311!\207" [major-mode idlwave-routines idlwave-mode idlwave-list-load-path-shadows nil idlwave-update-current-buffer-info save-buffer "in current buffer" error "Current buffer is not in idlwave-mode"] 4 (#$ . 239569) "P"])
#@298 List the load path shadows of all routines compiled under the shell.
This is very useful for checking an IDL application.  Just compile the
application, do RESOLVE_ALL, and `C-c C-i' to compile all referenced
routines and update IDLWAVE internal info.  Then check for shadowing
with this command.
(defalias 'idlwave-list-shell-load-path-shadows #[(&optional arg) "\301\302!\203�\302 \204�\303\304!\207\204�\303\305!\207\306\307\310#\207" [idlwave-compiled-routines fboundp idlwave-shell-is-running error "Shell is not running" "No compiled routines.  Maybe you need to update with `C-c C-i'" idlwave-list-load-path-shadows nil "in the shell"] 4 (#$ . 239989) "P"])
#@62 List the load path shadows of all routines known to IDLWAVE.
(defalias 'idlwave-list-all-load-path-shadows #[(&optional arg) "\300\301\211\302#\207" [idlwave-list-load-path-shadows nil "globally"] 4 (#$ . 240665) "P"])
#@416 List the routines which are defined multiple times.
Search the information IDLWAVE has about IDL routines for multiple
definitions.
When SPECIAL-ROUTINES in non-nil, only look for shadows of these routines.

When IDL hits a routine call which is not defined, it will search on
the load path in order to find a definition.  The output of this
command can be used to detect possible name clashes during this process.
(defalias 'idlwave-list-load-path-shadows #[(arg &optional special-routines loc) "\306 \210\204�	\204�\307\310!\204�\311\312!\210\313\n	\f\314&\315<\316 =\317\320<=\321\322\257>?\2068�
G\211@\323\245A\324\211BC\314\211DE\314\211FG\314\211HI\314\211JK?\203i�
K?\325\326!\210\327
\330\"\325\331!\210\332=\333\334#\210\332=\335\336#\210\325\337!\210\212\340\341!q\210\314L\342 \210
\211A@\211E\203]\343BT\211BA\"\324U\203\271�\325\344B\323_@\245\"\210\345EK\206\302�
\"FEI>\203\323�\314G\202\331�\346F!G\313FI\"IGG\347V\204\350\351\352G@8\"\347V\204\350\353\352G@8\"\347V\204\350\354\352G@8\"\347V\203\224�CTC\355\356\357\352E8E@\"EA@\360=\203-\361\202.\362#c\210G\211AG@\211H\203\224�\313\363E@EA@\352E8ED>\"J\364\365HJ#\210\2021eb\210\366L)M\206j\362MC\324V\203\216\367\370\341!!\210\325\371C\211\347U\203\207\362\202\210\372M$\202\223\325\373M\".\207" [idlwave-user-catalog-routines idlwave-library-catalog-routines idlwave-system-routines idlwave-compiled-routines idlwave-buffer-routines routines idlwave-routines y-or-n-p "You don't have any user or library catalogs.  Continue anyway? " error "Abort" append nil local-map make-sparse-keymap mouse-face highlight help-echo "Mouse2: Find source" 100 0 message "Sorting routines..." sort #[(a b) "\302\3038@\"\227\302\303	8	@\"\227\231\207" [a b idlwave-make-full-name 2] 4] "Sorting routines...done" define-key [(mouse-2)] #[(ev) "\301!\210\302\303\304`\305\"\"\207" [ev mouse-set-point apply idlwave-do-find-module get-text-property find-args] 5 nil "e"] [(return)] #[nil "\300\301\302`\303\"\"\207" [apply idlwave-do-find-module get-text-property find-args] 5 nil nil] "Compiling list...( 0%%)" get-buffer-create "*Shadows*" erase-buffer mod "Compiling list...(%2d%%)" idlwave-routine-twins idlwave-study-twins 1 idlwave-count-memq lib 2 user buffer format "\n%s%s" idlwave-make-full-name fun "()" "" find-args idlwave-insert-source-location "\n   - " t display-buffer get-buffer "%d case%s of shadowing found %s" "s" "No shadowing conflicts found %s" km-prop keymap props special-routines nroutines step n cnt idlwave-sort-prefer-buffer-info routine twins dtwins twin done props1 lroutines buffer-read-only loc] 8 (#$ . 240891)])
(defalias 'idlwave-print-source #[(routine) "\3048\211@\305	!\306!\203�\307\n\310=\203'�;\203%�\311\312\"\204'�\313\314\315\316\n\2033�\2024�\317#!+\207" [routine source stype sfile 3 idlwave-routine-source-file idlwave-syslib-p syslib compiled string-match "\\S-" unresolved princ format "      %-10s %s\n" "No source code available"] 6])
#@207 Return all twin entries of ENTRY in LIST.
LIST defaults to `idlwave-routines'.
Twin entries are those which have the same name, type, and class.
ENTRY will also be returned, as the first item of this list.
(defalias 'idlwave-routine-twins #[(entry &optional list) "@A@\3068\307	\f\206�\310 \"\311\211\f
\211A@\211\f\203I�\f=\204�\n\fA@=\203�\306\f8=\203�\fB\202�\312	\n
$\211\f\203]�\fB\237.B\207" [entry name type class list candidates 2 idlwave-all-assq idlwave-routines nil idlwave-rinfo-assq twins candidate idlwave-unresolved-routines] 6 (#$ . 243948)])
#@355 Return dangerous twins of first entry in ENTRIES.
Dangerous twins are routines with same name, but in different files on
the load path.  If a file is in the system library and has an entry in
the `idlwave-system-routines' list, we omit the latter as
non-dangerous because many IDL routines are implemented as library
routines, and may have been scanned.
(defalias 'idlwave-study-twins #[(entries) "@\211@	A@\306	8\307\310\211\310\211\310\211\310\211A@\211\203\235�
T\311	8\211@\211\3118B\312!\313=\203Q�\202^�\203]�\314!\202^�\315\203t�\204t�\316!\203t�\317\320\"\211\203\215�	AA\306	8B\240\210\202$�CEB\202$�\237\203\261�\321\313\236\"\322 \203\304�\320\313\"\211\203\304�	\323\240\210\324\325\".\f\207" [entries entry name type class cnt 2 0 nil 3 idlwave-routine-source-file system file-truename unresolved idlwave-syslib-p t assoc delq idlwave-syslib-scanned-p builtin sort idlwave-routine-twin-compare source type-cons file alist syslibp key] 5 (#$ . 244553)])
#@69 Internal variable used to influence `idlwave-routine-twin-compare'.
(defvar idlwave-sort-prefer-buffer-info t (#$ . 245609))
(defalias 'idlwave-xor '(macro . #[(a b) "\302\303	E\304\302	EDE\207" [a b and or not] 6]))
#@283 Compare two routine info entries for sortiung.  This is the general case.
It first compates class, names, and type.  If it turns out that A and B
are twins (same name, class, and type), calls another routine which
compares twins on the basis of their file names and path locations.
(defalias 'idlwave-routine-entry-compare #[(a b) "@A@\3058\306	!\306\305\f8!\232\2043�\305\f8\204!�\307\202m�	\204)�\310\202m�	\227\305\f8\227\231\202m�\227\f@\227\232\204E�\227\f@\227\231\202m�\n\fA@=\204i�\n\311=\203W�\312\202X�\313\fA@\311=\203d�\312\202e�\313W\202m�\314\f\"+\207" [a class type name b 2 idlwave-downcase-safe nil t fun 1 0 idlwave-routine-entry-compare-twins] 4 (#$ . 245835)])
#@148 Compare two routine entries, under the assumption that they are
twins.  This basically calls `idlwave-routine-twin-compare' with the
correct args.
(defalias 'idlwave-routine-entry-compare-twins #[(a b) "@A@\3068\3078\211@\3078\211\f@
\310\f!\310\f!\311;\203:�\312!
CE\202@�

CE;\203S�\312!
CE\202[�

CE\".	\207" [a name type class asrc atype 2 3 idlwave-routine-source-file idlwave-routine-twin-compare file-truename b bsrc btype afile bfile] 6 (#$ . 246532)])
#@208 Compare two routine twin entries for sorting.
In here, A and B are not normal routine info entries, but special
lists (KEY FILENAME (TYPES...)).
This expects NAME TYPE CLASS to be bound to the right values.
(defalias 'idlwave-routine-twin-compare #[(a b) "@\n@A@\nA@\3068\306\n8	\307>\310>\311>\311> 	\312=\206;�\205;�\f?!\312=\206J� \205J�
?\"\313>#\313>$\314 %	;\205h�\315\316	!%\"&;\205v�\315\316!%\"'&%>G('%>G)\f;\203\224�\317\f!\227\202\225�\320*
;\203\243�\317
!\227\202\244�\320+,\203\273�\321\322\323,\227!\323-\227!#\202\303�\321\324\323-\227!\".\325.*\"/,\205\336�/\205\336�\326\327*\"\330\2300\325.+\"1,\205\371�1\205\371�\326\327+\"\330\2302\204\203\203\204\202\313!\204\"\203-!\203(\"\204-\"\202\3133\203K#\204<$\203K#\203F$\204K#\202\313\204U \203d\203_ \204d\202\313&\204n'\203}&\203x'\204}&\202\313/\204\2071\203\226/\203\2211\204\226/\202\313,\203\276/\203\2761\203\2760\204\2572\203\2760\203\2712\204\2762\202\313()V\203\312\331\202\313\332.\207" [a akey b bkey afile bfile 2 (builtin system) (builtin system) compiled unresolved buffer idlwave-true-path-alist assoc file-name-directory file-name-nondirectory "" format "\\`%s__\$%s\\|define\$\\.pro\\'" regexp-quote "\\`%s\\.pro" string-match match-string 1 "define" t nil atypes btypes asysp bsysp acompp bcompp aunresp bunresp abufp bbufp tpath-alist apathp bpathp anpath bnpath aname bname class name fname-re anamep adefp bnamep bdefp idlwave-sort-prefer-buffer-info] 5 (#$ . 247037)])
(defalias 'idlwave-routine-source-file #[(source) "\3018\203�\302A@\3018\"\207A@\207" [source 2 expand-file-name] 4])
#@44 Donwcase if string, else return unchanged.
(defalias 'idlwave-downcase-safe #[(string) ";\203�\227\207\207" [string] 1 (#$ . 248792)])
#@27 How often is ELT in LIST?
(defalias 'idlwave-count-eq #[(elt list) "\301\302\303\304\"\"G\207" [list delq nil mapcar #[(x) "	=\207" [x elt] 2]] 5 (#$ . 248937)])
#@34 How often is ELT a key in ALIST?
(defalias 'idlwave-count-memq #[(elt alist) "\301\302\303\304\"\"G\207" [alist delq nil mapcar #[(x) "@	=\207" [x elt] 2]] 5 (#$ . 249107)])
#@43 Non-nil if FILE is in the system library.
(defalias 'idlwave-syslib-p #[(file) "\303\304\305\306\307 \"!!\304	!\310\311\312!P\n\"*\207" [true-syslib file true-file file-name-as-directory file-truename expand-file-name "lib" idlwave-sys-dir string-match "^" regexp-quote] 5 (#$ . 249289)])
#@35 Non-nil if file is in the library
(defalias 'idlwave-lib-p #[(file) "\302\303!!\304	\305 \")\207" [file true-dir file-name-directory file-truename assoc idlwave-true-path-alist] 3 (#$ . 249587)])
#@48 Add a flag to the path list entry, if not set.
(defalias 'idlwave-path-alist-add-flag #[(list-entry flag) "A\303\301\n\"\210	\241)\207" [list-entry flags flag add-to-list] 3 (#$ . 249791)])
#@47 Remove a flag to the path list entry, if set.
(defalias 'idlwave-path-alist-remove-flag #[(list-entry flag) "\303	A\"	\n\241)\207" [flag list-entry flags delq] 3 (#$ . 249990)])
#@181 Return `idlwave-path-alist' alist with true-names.
Info is cached, but relies on the functions setting `idlwave-path-alist'
to reset the variable `idlwave-true-path-alist' to nil.
(defalias 'idlwave-true-path-alist #[nil "\206\n�\302\303	\"\211\207" [idlwave-true-path-alist idlwave-path-alist mapcar #[(x) "\301\302\303@!!!AB\207" [x file-name-as-directory file-truename directory-file-name] 4]] 3 (#$ . 250177)])
#@59 Non-nil if the system lib file !DIR/lib has been scanned.
(defalias 'idlwave-syslib-scanned-p #[nil "\301\302\303\304\305 \"!!\306\307 \"A)\207" [true-syslib file-name-as-directory file-truename expand-file-name "lib" idlwave-sys-dir assoc idlwave-true-path-alist] 5 (#$ . 250602)])
#@97 Search for the previous procedure or function.
Return nil if not found.  For use with imenu.el.
(defalias 'idlwave-prev-index-position #[nil "\301 \302\216\303\304\305\306#*\207" [save-match-data-internal match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) idlwave-find-key "\\<\$pro\\|function\$\\>" -1 nomark] 4 (#$ . 250893)])
#@117 Return the unit name.
Assumes that point is at the beginning of the unit as found by
`idlwave-prev-index-position'.
(defalias 'idlwave-unit-name #[nil "\301\302!\210\301\303!\210`\304\305!\210\306\307!\203�\307`\"\202�`{)\207" [begin forward-sexp 2 -1 re-search-forward "[a-zA-Z_][a-zA-Z0-9$_]+\$::[a-zA-Z_][a-zA-Z0-9$_]+\$?" fboundp buffer-substring-no-properties] 3 (#$ . 251278)])
(byte-code "\300\301\302\303\304\217\"\210\305\306!\203�\306\307\310\"\210\302\207" [defalias idlwave-function-menu nil (byte-code "\300\301!\210\302\207" [require func-menu function-menu] 2) ((error (byte-code "\300\301\302\217\207" [nil (byte-code "\300\301!\210\301\207" [require imenu] 2) ((error))] 3))) fboundp eval-after-load "func-menu" (progn (or (assq 'idlwave-mode fume-function-name-regexp-alist) (not (boundp 'fume-function-name-regexp-idl)) (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)) (setq fume-find-function-name-method-alist (cons '(idlwave-mode . fume-find-next-idl-function-name) fume-find-function-name-method-alist))))] 5)
#@55 Edit the current file in IDL Development environment.
(defalias 'idlwave-edit-in-idlde #[nil "\301\302\303\304\305\306 &\207" [idlwave-shell-explicit-file-name start-process "idldeclient" nil "-c" "-e" buffer-file-name] 7 (#$ . 252515) nil])
#@32 Start the IDLhelp application.
(defalias 'idlwave-launch-idlhelp #[nil "\203�\302 \207\303\304\305	#\207" [idlwave-help-use-assistant idlwave-help-application idlwave-help-assistant-raise start-process "idlhelp" nil] 4 (#$ . 252765) nil])
(byte-code "\302B\304\302!\204�\305\302\306\"\210\303B\304\303!\204�\305\303\307\"\210\310\311!\204+�\312\313\314\"\203c�\315B\316\315\317\320#\210\304\315!\204@�\305\315\321\"\210\322\315	\320\n$\210\323B\316\323\317\320#\210\304\323!\204\\�\305\323\321\"\210\322\323	\320$\210\321\207" [current-load-list idlwave-mode-map idlwave-mode-menu-def idlwave-mode-debug-menu-def default-boundp set-default ("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 Entire Statement" idlwave-indent-statement :active t :keys "C-u \\[indent-for-tab-command]"] ["Indent Subprogram" idlwave-indent-subprogram t] ["(Un)Comment Region" idlwave-toggle-comment-region t] ["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" ["Complete" idlwave-complete t] ("Complete Specific" ["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])) ("Routine Info" ["Show Routine Info" idlwave-routine-info t] ["Online Context Help" idlwave-context-help t] "--" ["Find Routine Source" idlwave-find-module t] ["Resolve Routine" idlwave-resolve (featurep 'idlw-shell)] "--" ["Update Routine Info" idlwave-update-routine-info t] ["Rescan XML Help Catalog" idlwave-convert-xml-system-routine-info t] "--" "IDL User Catalog" ["Select Catalog Directories" (idlwave-create-user-catalog-file nil) t] ["Scan Directories" (idlwave-update-routine-info '(16)) (and idlwave-path-alist (not idlwave-catalog-process))] ["Scan Directories &" (idlwave-update-routine-info '(64)) (and idlwave-path-alist (not idlwave-catalog-process))] "--" "Routine Shadows" ["Check Current Buffer" idlwave-list-buffer-load-path-shadows t] ["Check Compiled Routines" idlwave-list-shell-load-path-shadows t] ["Check Everything" idlwave-list-all-load-path-shadows t]) ("Misc" ["Kill auto-created buffers" idlwave-kill-autoloaded-buffers t] "--" ["Insert TAB character" idlwave-hard-tab t]) "--" ("External" ["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 idlw-shell.el" idlwave-shell-show-commentary t] "--" ["Info" idlwave-info t] "--" ["Help with Topic" idlwave-help-assistant-help-with-topic idlwave-help-use-assistant] ["Launch IDL Help" idlwave-launch-idlhelp t])) ("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)]) featurep easymenu load "easymenu" t idlwave-mode-menu put variable-documentation "IDL and WAVE CL editing menu" nil easy-menu-do-define idlwave-mode-debug-menu] 5)
#@55 Call the customize function with idlwave as argument.
(defalias 'idlwave-customize #[nil "\300\301!\204�\302\303\304\"\210\305\306!\207" [featurep idlw-shell load "idlw-shell" t customize-browse idlwave] 3 (#$ . 257316) nil])
#@72 Create a full customization menu for IDLWAVE, insert it into the menu.
(defalias 'idlwave-create-customize-menu #[nil "\300\301!\203#�\302\303!\204�\304\305\306\"\210\307\310\311\312\313\301\314!\315BBB#\210\316\317!\207\320\321!\207" [fboundp customize-menu-create featurep idlw-shell load "idlw-shell" t easy-menu-change ("IDLWAVE") "Customize" ["Browse IDLWAVE group" idlwave-customize t] "--" 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)"] 7 (#$ . 257549) nil])
#@66 Use the finder to view the file documentation from `idlwave.el'.
(defalias 'idlwave-show-commentary #[nil "\300\301!\207" [finder-commentary "idlwave.el"] 2 (#$ . 258294) nil])
#@69 Use the finder to view the file documentation from `idlw-shell.el'.
(defalias 'idlwave-shell-show-commentary #[nil "\300\301!\207" [finder-commentary "idlw-shell.el"] 2 (#$ . 258477) nil])
#@52 Read documentation for IDLWAVE in the info system.
(defalias 'idlwave-info #[nil "\300\301!\207" [info "idlwave"] 2 (#$ . 258672) nil])
#@552 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.
(defalias 'idlwave-list-abbrevs #[(arg) "\306J\307\211\211\211\211\310\211!\"\311\312\"\"\210\313!\314\"!\315\316	#\317\220#\203J�\320\321!\210\320\322!\210\320\315\n\323\324\325$!\210\320\315\n\326\327\330$!\210\202d�\320\331!\210\320\332!\210\320\315\n\323\333\334$!\210\320\315\n\326\335\334$!\210\336\337!\"\221\210.\212\317q\210\340\211$)\207" [len-rpl len-str fmt func rpl str idlwave-mode-abbrev-table nil 0 mapatoms #[(sym) "J\205T�\306!JK\f\203�\307!\2023�<\2031�\3108;\2031�\311\3108P\312\2023�\312\f\204>�\n	\230?\205T�
	G]\nG]	\nE\fB\211\f\207" [sym str rpl func arg len-str symbol-name prin1-to-string 2 "EVAL: " #1="" len-rpl abbrevs] 3] sort #[(a b) "@	@\231\207" [a b] 2] format "%%-%ds   %%-%ds   %%s\n" "*Help*" princ "Abbreviations and Actions in IDLWAVE-Mode\n" "=========================================\n\n" "KEY" "REPLACE" "HOOK" "---" "-------" "----" "Code Abbreviations and Templates in IDLWAVE-Mode\n" "================================================\n\n" "ACTION" #1# "------" mapcar #[(list) "@A@\3058\306\307\f	\n$!\207" [list str rpl func fmt 2 princ format] 6] t abbrevs table arg truncate-lines] 8 (#$ . 258815) "P"])
(byte-code "\301\302\303\"\210\204\f�\304 \210\305\306!\210\307\310!\207" [idlwave-routines eval-after-load "speedbar" (speedbar-add-supported-extension ".pro") idlwave-start-load-rinfo-timer run-hooks idlwave-load-hook provide idlwave] 3)

${this.title}

Code Editor : idlwave.elc